Revert "Update LICENSE.md"

This reverts commit 37893460f3.

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,67 @@
+name: Iris Bug Report
+description: File a bug report for Iris
+labels: [ bug ]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for taking the time to fill this out!
+        If this does not work for you, feel free to use the [blank](https://github.com/VolmitSoftware/Iris/issues/new) format.
+  - type: textarea
+    id: how
+    attributes:
+      label: Problem
+      description: Please give a text description of how you reached the problem
+      value: |
+        1. Install Iris...
+        2. Do this...
+        3. Do that...
+        4. Observe the error...
+    validations:
+      required: true
+  - type: textarea
+    id: what
+    attributes:
+      label: Solution
+      description: Explain where you think the problem comes from (optional)
+      placeholder: The code to place a is missing b and c...
+    validations:
+      required: false
+  - type: dropdown
+    id: mcversion
+    attributes:
+      label: Minecraft Version
+      description: What version of Minecraft is the server on?
+      options:
+        - 1.14.X
+        - 1.15.X
+        - 1.16.X
+        - 1.17
+        - 1.17.1
+        - 1.18
+        - 1.19
+        - 1.20
+        - 1.21
+        - 1.22
+    validations:
+      required: true
+  - type: input
+    id: irisversion
+    attributes:
+      label: Iris Version
+      description: What version of Iris are you running? (see console)
+      placeholder: DO NOT SAY "LATEST"
+    validations:
+      required: true
+  - type: input
+    id: logs
+    attributes:
+      label: Log
+      description: Paste a full log. Always use [mclogs](https://mclo.gs) Or [Pastebin](https://pastebin.com/). Must not be a crash report. Must be a full log. Must not be a screenshot of a log.
+      placeholder: https://mslog.gs/...
+    validations:
+      required: true
+  - type: markdown
+    id: thanks
+    attributes:
+      value: "Thank you for filling out the form! We will be with you soon. Please do not ask support to review your report."

.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,46 @@
+name: Iris Feature Request
+description: File a feature request for Iris. If you want to report a bug this is not the place.
+labels: [ feature ]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for taking the time to fill this out!
+        If this does not work for you, feel free to use the [blank](https://github.com/VolmitSoftware/Iris/issues/new) format.
+  - type: dropdown
+    id: arc
+    attributes:
+      label: Adding, Removing, or Changing
+      description: What are you doing
+      options:
+        - Adding
+        - Removing
+        - Changing
+    validations:
+      required: true
+  - type: input
+    id: atype
+    attributes:
+      label: Type of Modification
+      description: What is it for?
+      value: I want to ...
+    validations:
+      required: true
+  - type: textarea
+    id: desc
+    attributes:
+      label: What are you trying to modify
+      description: Give as detailed of a description as you can for the modification that you want done (include pictures if applicable)
+      value: The way I would implement this is ...
+    validations:
+      required: true
+  - type: textarea
+    id: alternative
+    attributes:
+      label: Alternatives
+      description: What alternatives have you considered?
+      value: If this could not be implemented I would ...
+  - type: markdown
+    id: thanks
+    attributes:
+      value: "Thank you for filling out the form! We will be with you soon. Please do not ask support to review your report."

.gitignore

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

LICENSE.md

@@ -0,0 +1,518 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
+
+                            Preamble
+
+The GNU General Public License is a free, copyleft license for software and other kinds of works.
+
+The licenses for most software and other practical works are designed to take away your freedom to share and change the
+works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all
+versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use
+the GNU General Public License for most of our software; it applies also to any other work released this way by its
+authors. You can apply it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make
+sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive
+source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and
+that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.
+Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it:
+responsibilities to respect the freedom of others.
+
+For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients
+the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must
+show them these terms so they know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute
+and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.
+For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems
+will not be attributed erroneously to authors of previous versions.
+
+Some devices are designed to deny users access to install or run modified versions of the software inside them, although
+the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the
+software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely
+where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we stand ready to extend this provision to those
+domains in future versions of the GPL, as needed to protect the freedom of users.
+
+Finally, every program is threatened constantly by software patents. States should not allow patents to restrict
+development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger
+that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and modification follow.
+
+                       TERMS AND CONDITIONS
+
+0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you".  "
+Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission,
+other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a
+work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based on the Program.
+
+To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily
+liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.
+Propagation includes copying, distribution (with or without modification), making available to the public, and in some
+countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction
+with a user through a computer network, with no transfer of a copy, is not conveying.
+
+An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright
+notice, and (2)
+tells the user that there is no warranty for the work (except to the extent that warranties are provided), that
+licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a
+list of user commands or options, such as a menu, a prominent item in the list meets this criterion.
+
+1. Source Code.
+
+The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means
+any non-source form of a work.
+
+A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body,
+or, in the case of interfaces specified for a particular programming language, one that is widely used among developers
+working in that language.
+
+The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in
+the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to
+enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is
+available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used
+to run it.
+
+The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (
+for an executable work) run the object code and to modify the work, including scripts to control those activities.
+However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs
+which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding
+Source includes interface definition files associated with source files for the work, and the source code for shared
+libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data
+communication or control flow between those subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users can regenerate automatically from other parts of the
+Corresponding Source.
+
+The Corresponding Source for a work in source code form is that same work.
+
+2. Basic Permissions.
+
+All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided
+the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program.
+The output from running a covered work is covered by this License only if the output, given its content, constitutes a
+covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not convey, without conditions so long as your license
+otherwise remains in force. You may convey covered works to others for the sole purpose of having them make
+modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do not control copyright. Those thus making or running
+the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that
+prohibit them from making any copies of your copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not
+allowed; section 10 makes it unnecessary.
+
+3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling
+obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or
+restricting circumvention of such measures.
+
+When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the
+extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you
+disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users,
+your or third parties' legal rights to forbid circumvention of technological measures.
+
+4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating
+that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices
+of the absence of any warranty; and give all recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for
+a fee.
+
+5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source
+code under the terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent works, which are not by their nature extensions of
+the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or
+distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the
+compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause
+this License to apply to the other parts of the aggregate.
+
+6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License, in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library,
+need not be included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used
+for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In
+determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a
+particular product received by a particular user, "normally used" refers to a typical or common use of that class of
+product, regardless of the status of the particular user or of the way in which the particular user actually uses, or
+expects or is expected to use, the product. A product is a consumer product regardless of whether the product has
+substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of
+the product.
+
+"Installation Information" for a User Product means any methods, procedures, authorization keys, or other information
+required to install and execute modified versions of a covered work in that User Product from a modified version of its
+Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code
+is in no case prevented or interfered with solely because modification has been made.
+
+If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the
+conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to
+the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding
+Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not
+apply if neither you nor any third party retains the ability to install modified object code on the User Product (for
+example, the work has been installed in ROM).
+
+The requirement to provide Installation Information does not include a requirement to continue to provide support
+service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product
+in which it has been modified or installed. Access to a network may be denied when the modification itself materially
+and adversely affects the operation of the network or violates the rules and protocols for communication across the
+network.
+
+Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format
+that is publicly documented (and with an implementation available to the public in source code form), and must require
+no special password or key for unpacking, reading or copying.
+
+7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of
+its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were
+included in this License, to the extent that they are valid under applicable law. If additional permissions apply only
+to part of the Program, that part may be used separately under those permissions, but the entire Program remains
+governed by this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or
+from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you
+modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have
+or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by
+the copyright holders of that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the
+Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with
+a term that is a further restriction, you may remove that term. If a license document contains a further restriction but
+permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of
+that license document, provided that the further restriction does not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a
+statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as
+exceptions; the above requirements apply either way.
+
+8. Termination.
+
+You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to
+propagate or modify it is void, and will automatically terminate your rights under this License (including any patent
+licenses granted under the third paragraph of section 11).
+
+However, if you cease all violation of this License, then your license from a particular copyright holder is
+reinstated (a)
+provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b)
+permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days
+after the cessation.
+
+Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you
+of the violation by some reasonable means, this is the first time you have received notice of violation of this
+License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the
+notice.
+
+Termination of your rights under this section does not terminate the licenses of parties who have received copies or
+rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not
+qualify to receive new licenses for the same material under section 10.
+
+9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a
+covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not
+require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered
+work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run,
+modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third
+parties with this License.
+
+An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or
+subdividing an organization, or merging organizations. If propagation of a covered work results from an entity
+transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work
+the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with
+reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For
+example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License,
+and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using,
+selling, offering for sale, or importing the Program or any portion of it.
+
+11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the
+Program is based. The work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already
+acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or
+selling its contributor version, but do not include claims that would be infringed only as a consequence of further
+modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent
+sublicenses in a manner consistent with the requirements of this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential
+patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its
+contributor version.
+
+In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not
+to enforce a patent
+(such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a
+patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not
+available for anyone to copy, free of charge and under the terms of this License, through a publicly available network
+server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available,
+or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a
+manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "
+Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in
+a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in
+that country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring
+conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing
+them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is
+automatically extended to all recipients of the covered work and works based on it.
+
+A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of,
+or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You
+may not convey a covered work if you are a party to an arrangement with a third party that is in the business of
+distributing software, under which you make payment to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a
+discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from
+those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered
+work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to
+infringement that may otherwise be available to you under applicable patent law.
+
+12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this
+License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to
+satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence
+you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further
+conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License
+would be to refrain entirely from conveying the Program.
+
+13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work
+licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the
+resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special
+requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply
+to the combination as such.
+
+14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to
+time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new
+problems or concerns.
+
+Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the
+GNU General Public License "or any later version" applies to it, you have the option of following the terms and
+conditions either of that numbered version or of any later version published by the Free Software Foundation. If the
+Program does not specify a version number of the GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used,
+that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the
+Program.
+
+Later license versions may give you additional or different permissions. However, no additional obligations are imposed
+on any author or copyright holder as a result of your choosing to follow a later version.
+
+15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING
+THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR
+IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU
+ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO
+MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
+INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO
+LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
+TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to
+their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil
+liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program
+in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve
+this is to make it free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to
+most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer
+to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of
+course, your program's commands might be different; for a GUI interface, you would use an "about box".
+
+You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for
+the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is
+a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If
+this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,18 +1,17 @@
-# IrisBukkit
+# Iris
 
 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)
+# [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
+Building Iris 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.
+Consider supporting our development by buying Iris on spigot! We work hard to make Iris the best it can be for everyone.
+
+## Preface: if you need help compiling and you are a developer / intend to help out in the community or with development we would love to help you regardless in the discord! however do not come to the discord asking for free copies, or a tutorial on how to compile.
 
 ### Command Line Builds
 
@@ -31,23 +30,17 @@ for everyone.
         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!
+3. Once the project has setup, run `gradlew iris`
+4. The Iris jar will be placed in `Iris/build/Iris-XXX-XXX.jar` Enjoy! Consider supporting us by buying it on spigot!
 
 ### IDE Builds (for development)
 
-* Run `gradlew setup` any time you get dependency issues with craftbukkit
 * Configure ITJ Gradle to use JDK 17 (in settings, search for gradle)
-* Add a build line in the build.gradle for your own build task to directly compile IrisBukkit into your plugins folder
-  if you
+* Add a build line in the build.gradle for your own build task to directly compile Iris into your plugins folder if you
   prefer.
 * Resync the project & run your newly created task (under the development folder in gradle tasks!)
 
-# IrisBukkit Toolbelt
+# Iris Toolbelt
 
 Everyone needs a tool-belt.
 
@@ -73,7 +66,6 @@ IrisAccess access=IrisToolbelt.createWorld() // If you like builders...
   .name("myWorld") // The world name
   .dimension("terrifyinghands")
   .seed(69133742) // The world seed
-  .headless(true)  // Headless make gen go fast
   .pregen(PregenTask // Define a pregen job to run
   .builder()
     .center(new Position2(0,0)) // REGION coords (1 region = 32x32 chunks)

build.gradle

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

bukkit/build.gradle

@@ -1,290 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

core/build.gradle

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

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

@@ -0,0 +1,985 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonParser;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.ServerConfigurator;
+import com.volmit.iris.core.link.IrisPapiExpansion;
+import com.volmit.iris.core.link.MultiverseCoreLink;
+import com.volmit.iris.core.link.MythicMobsLink;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.v1X.NMSBinding1X;
+import com.volmit.iris.core.pregenerator.LazyPregenerator;
+import com.volmit.iris.core.safeguard.IrisSafeguard;
+import com.volmit.iris.core.safeguard.UtilsSFG;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.EnginePanic;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisCompat;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.engine.platform.BukkitChunkGenerator;
+import com.volmit.iris.engine.platform.DummyChunkGenerator;
+import com.volmit.iris.server.master.IrisMasterServer;
+import com.volmit.iris.server.node.IrisServer;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.exceptions.IrisException;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.function.NastyRunnable;
+import com.volmit.iris.util.io.FileWatcher;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.io.InstanceState;
+import com.volmit.iris.util.io.JarScanner;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.misc.getHardware;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.plugin.IrisService;
+import com.volmit.iris.util.plugin.Metrics;
+import com.volmit.iris.util.plugin.VolmitPlugin;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.reflect.ShadeFix;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.Queue;
+import com.volmit.iris.util.scheduling.ShurikenQueue;
+import io.papermc.lib.PaperLib;
+import net.bytebuddy.agent.ByteBuddyAgent;
+import net.kyori.adventure.platform.bukkit.BukkitAudiences;
+import net.kyori.adventure.text.serializer.ComponentSerializer;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.filefilter.IOFileFilter;
+import org.apache.commons.io.filefilter.TrueFileFilter;
+import org.bukkit.*;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.generator.BiomeProvider;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.IllegalPluginAccessException;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.*;
+import java.lang.annotation.Annotation;
+import java.net.URL;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static com.volmit.iris.core.safeguard.IrisSafeguard.InitializeSafeguard;
+
+@SuppressWarnings("CanBeFinal")
+public class Iris extends VolmitPlugin implements Listener {
+    public static final String OVERWORLD_TAG = "3800";
+
+    private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();
+
+    public static Iris instance;
+    public static BukkitAudiences audiences;
+    public static MultiverseCoreLink linkMultiverseCore;
+    public static MythicMobsLink linkMythicMobs;
+    public static IrisCompat compat;
+    public static FileWatcher configWatcher;
+    private static IrisServer server;
+    private static VolmitSender sender;
+
+    static {
+        try {
+            fixShading();
+            InstanceState.updateInstanceId();
+        } catch (Throwable ignored) {
+
+        }
+    }
+
+    private final KList<Runnable> postShutdown = new KList<>();
+    private KMap<Class<? extends IrisService>, IrisService> services;
+
+    public static VolmitSender getSender() {
+        if (sender == null) {
+            sender = new VolmitSender(Bukkit.getConsoleSender());
+            sender.setTag(instance.getTag());
+        }
+        return sender;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T service(Class<T> c) {
+        return (T) instance.services.get(c);
+    }
+
+    public static void callEvent(Event e) {
+        if (!e.isAsynchronous()) {
+            J.s(() -> Bukkit.getPluginManager().callEvent(e));
+        } else {
+            Bukkit.getPluginManager().callEvent(e);
+        }
+    }
+
+    public static KList<Object> initialize(String s, Class<? extends Annotation> slicedClass) {
+        JarScanner js = new JarScanner(instance.getJarFile(), s);
+        KList<Object> v = new KList<>();
+        J.attempt(js::scan);
+        for (Class<?> i : js.getClasses()) {
+            if (slicedClass == null || i.isAnnotationPresent(slicedClass)) {
+                try {
+                    v.add(i.getDeclaredConstructor().newInstance());
+                } catch (Throwable ignored) {
+
+                }
+            }
+        }
+
+        return v;
+    }
+
+    public static KList<Class<?>> getClasses(String s, Class<? extends Annotation> slicedClass) {
+        JarScanner js = new JarScanner(instance.getJarFile(), s);
+        KList<Class<?>> v = new KList<>();
+        J.attempt(js::scan);
+        for (Class<?> i : js.getClasses()) {
+            if (slicedClass == null || i.isAnnotationPresent(slicedClass)) {
+                try {
+                    v.add(i);
+                } catch (Throwable ignored) {
+
+                }
+            }
+        }
+
+        return v;
+    }
+
+    public static KList<Object> initialize(String s) {
+        return initialize(s, null);
+    }
+
+    public static void sq(Runnable r) {
+        synchronized (syncJobs) {
+            syncJobs.queue(r);
+        }
+    }
+
+    public static File getTemp() {
+        return instance.getDataFolder("cache", "temp");
+    }
+
+    public static void msg(String string) {
+        try {
+            getSender().sendMessage(string);
+        } catch (Throwable e) {
+            try {
+                instance.getLogger().info(instance.getTag() + string.replaceAll("(<([^>]+)>)", ""));
+            } catch (Throwable ignored1) {
+
+            }
+        }
+    }
+
+    public static File getCached(String name, String url) {
+        String h = IO.hash(name + "@" + url);
+        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
+
+        if (!f.exists()) {
+            try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
+                byte[] dataBuffer = new byte[1024];
+                int bytesRead;
+                while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
+                    fileOutputStream.write(dataBuffer, 0, bytesRead);
+                    Iris.verbose("Aquiring " + name);
+                }
+            } catch (IOException e) {
+                Iris.reportError(e);
+            }
+        }
+
+        return f.exists() ? f : null;
+    }
+
+    public static String getNonCached(String name, String url) {
+        String h = IO.hash(name + "*" + url);
+        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
+
+        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
+            byte[] dataBuffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
+                fileOutputStream.write(dataBuffer, 0, bytesRead);
+            }
+        } catch (IOException e) {
+            Iris.reportError(e);
+        }
+
+        try {
+            return IO.readAll(f);
+        } catch (IOException e) {
+            Iris.reportError(e);
+        }
+
+        return "";
+    }
+
+    public static File getNonCachedFile(String name, String url) {
+        String h = IO.hash(name + "*" + url);
+        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
+        Iris.verbose("Download " + name + " -> " + url);
+        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
+            byte[] dataBuffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
+                fileOutputStream.write(dataBuffer, 0, bytesRead);
+            }
+
+            fileOutputStream.flush();
+        } catch (IOException e) {
+            e.printStackTrace();
+            Iris.reportError(e);
+        }
+
+        return f;
+    }
+
+    public static void warn(String format, Object... objs) {
+        msg(C.YELLOW + String.format(format, objs));
+    }
+
+    public static void error(String format, Object... objs) {
+        msg(C.RED + String.format(format, objs));
+    }
+
+    public static void debug(String string) {
+        if (!IrisSettings.get().getGeneral().isDebug()) {
+            return;
+        }
+
+        try {
+            throw new RuntimeException();
+        } catch (Throwable e) {
+            try {
+                String[] cc = e.getStackTrace()[1].getClassName().split("\\Q.\\E");
+
+                if (cc.length > 5) {
+                    debug(cc[3] + "/" + cc[4] + "/" + cc[cc.length - 1], e.getStackTrace()[1].getLineNumber(), string);
+                } else {
+                    debug(cc[3] + "/" + cc[4], e.getStackTrace()[1].getLineNumber(), string);
+                }
+            } catch (Throwable ex) {
+                debug("Origin", -1, string);
+            }
+        }
+    }
+
+    public static void debug(String category, int line, String string) {
+        if (!IrisSettings.get().getGeneral().isDebug()) {
+            return;
+        }
+        if (IrisSettings.get().getGeneral().isUseConsoleCustomColors()) {
+            msg("<gradient:#095fe0:#a848db>" + category + " <#bf3b76>" + line + "<reset> " + C.LIGHT_PURPLE + string.replaceAll("\\Q<\\E", "[").replaceAll("\\Q>\\E", "]"));
+        } else {
+            msg(C.BLUE + category + ":" + C.AQUA + line + C.RESET + C.LIGHT_PURPLE + " " + string.replaceAll("\\Q<\\E", "[").replaceAll("\\Q>\\E", "]"));
+
+        }
+    }
+
+    public static void verbose(String string) {
+        debug(string);
+    }
+
+    public static void success(String string) {
+        msg(C.IRIS + string);
+    }
+
+    public static void info(String format, Object... args) {
+        msg(C.WHITE + String.format(format, args));
+    }
+
+    public static void safeguard(String format, Object... args) {
+        msg(C.RESET + String.format(format, args));
+    }
+
+    @SuppressWarnings("deprecation")
+    public static void later(NastyRunnable object) {
+        try {
+            Bukkit.getScheduler().scheduleAsyncDelayedTask(instance, () ->
+            {
+                try {
+                    object.run();
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    Iris.reportError(e);
+                }
+            }, RNG.r.i(100, 1200));
+        } catch (IllegalPluginAccessException ignored) {
+
+        }
+    }
+
+    public static int jobCount() {
+        return syncJobs.size();
+    }
+
+    public static void clearQueues() {
+        synchronized (syncJobs) {
+            syncJobs.clear();
+        }
+    }
+
+    public static int getJavaVersion() {
+        String version = System.getProperty("java.version");
+        if (version.startsWith("1.")) {
+            version = version.substring(2, 3);
+        } else {
+            int dot = version.indexOf(".");
+            if (dot != -1) {
+                version = version.substring(0, dot);
+            }
+        }
+        return Integer.parseInt(version);
+    }
+
+    public static String getJava() {
+        String javaRuntimeName = System.getProperty("java.vm.name");
+        String javaRuntimeVendor = System.getProperty("java.vendor");
+        String javaRuntimeVersion = System.getProperty("java.vm.version");
+        return String.format("%s %s (build %s)", javaRuntimeName, javaRuntimeVendor, javaRuntimeVersion);
+    }
+
+    public static void reportErrorChunk(int x, int z, Throwable e, String extra) {
+        if (IrisSettings.get().getGeneral().isDebug()) {
+            File f = instance.getDataFile("debug", "chunk-errors", "chunk." + x + "." + z + ".txt");
+
+            if (!f.exists()) {
+                J.attempt(() -> {
+                    PrintWriter pw = new PrintWriter(f);
+                    pw.println("Thread: " + Thread.currentThread().getName());
+                    pw.println("First: " + new Date(M.ms()));
+                    e.printStackTrace(pw);
+                    pw.close();
+                });
+            }
+
+            Iris.debug("Chunk " + x + "," + z + " Exception Logged: " + e.getClass().getSimpleName() + ": " + C.RESET + "" + C.LIGHT_PURPLE + e.getMessage());
+        }
+    }
+
+    public static void reportError(Throwable e) {
+        String n = e.getClass().getCanonicalName() + "-" + e.getStackTrace()[0].getClassName() + "-" + e.getStackTrace()[0].getLineNumber();
+
+        if (e.getCause() != null) {
+            n += "-" + e.getCause().getStackTrace()[0].getClassName() + "-" + e.getCause().getStackTrace()[0].getLineNumber();
+        }
+
+        File f = instance.getDataFile("debug", "caught-exceptions", n + ".txt");
+
+        if (!f.exists()) {
+            J.attempt(() -> {
+                PrintWriter pw = new PrintWriter(f);
+                pw.println("Thread: " + Thread.currentThread().getName());
+                pw.println("First: " + new Date(M.ms()));
+                e.printStackTrace(pw);
+                pw.close();
+            });
+        }
+
+        Iris.debug("Exception Logged: " + e.getClass().getSimpleName() + ": " + C.RESET + "" + C.LIGHT_PURPLE + e.getMessage());
+    }
+
+    public static void dump() {
+        try {
+            File fi = Iris.instance.getDataFile("dump", "td-" + new java.sql.Date(M.ms()) + ".txt");
+            FileOutputStream fos = new FileOutputStream(fi);
+            Map<Thread, StackTraceElement[]> f = Thread.getAllStackTraces();
+            PrintWriter pw = new PrintWriter(fos);
+            for (Thread i : f.keySet()) {
+                pw.println("========================================");
+                pw.println("Thread: '" + i.getName() + "' ID: " + i.getId() + " STATUS: " + i.getState().name());
+
+                for (StackTraceElement j : f.get(i)) {
+                    pw.println("    @ " + j.toString());
+                }
+
+                pw.println("========================================");
+                pw.println();
+                pw.println();
+            }
+
+            pw.close();
+            Iris.info("DUMPED! See " + fi.getAbsolutePath());
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void panic() {
+        EnginePanic.panic();
+    }
+
+    public static void addPanic(String s, String v) {
+        EnginePanic.add(s, v);
+    }
+
+    private static void fixShading() {
+        ShadeFix.fix(ComponentSerializer.class);
+    }
+
+    private void enable() {
+        instance = this;
+        InitializeSafeguard();
+        ByteBuddyAgent.install();
+        services = new KMap<>();
+        setupAudience();
+        initialize("com.volmit.iris.core.service").forEach((i) -> services.put((Class<? extends IrisService>) i.getClass(), (IrisService) i));
+        INMS.get();
+        IO.delete(new File("iris"));
+        IrisSafeguard.instance.IrisSafeguardSystem();
+        getSender().setTag(getTag());
+        INMS.get().injectBukkit();
+        if (IrisSafeguard.instance.unstablemode && !IrisSafeguard.instance.acceptUnstable)
+            IrisSafeguard.instance.earlySplash();
+        compat = IrisCompat.configured(getDataFile("compat.json"));
+        linkMultiverseCore = new MultiverseCoreLink();
+        linkMythicMobs = new MythicMobsLink();
+        configWatcher = new FileWatcher(getDataFile("settings.json"));
+        services.values().forEach(IrisService::onEnable);
+        services.values().forEach(this::registerListener);
+        ServerConfigurator.setupDataPack();
+        installMainDimension();
+        try {
+            info("Starting server...");
+            try {
+                int port = Integer.parseInt(System.getProperty("com.volmit.iris.server.port"));
+                String[] remote = Optional.ofNullable(System.getProperty("com.volmit.iris.server.remote"))
+                        .map(String::trim)
+                        .map(s -> s.isBlank() ? null : s.split(","))
+                        .orElse(new String[0]);
+                server = remote.length > 0 ? new IrisMasterServer(port, remote) : new IrisServer(port);
+            } catch (NullPointerException | NumberFormatException ignored) {
+                var serverSettings = IrisSettings.get().getServer();
+                if (serverSettings.isActive()) {
+                    server = serverSettings.isRemote() ?
+                            new IrisMasterServer(serverSettings.getPort(), serverSettings.remote) :
+                            new IrisServer(serverSettings.getPort());
+                }
+            }
+        } catch (InterruptedException ignored) {
+        } catch (Throwable e) {
+            error("Failed to start server: " + e.getClass().getSimpleName());
+            e.printStackTrace();
+        }
+
+        if (!IrisSafeguard.instance.acceptUnstable && IrisSafeguard.instance.unstablemode) {
+            Iris.info(C.RED + "World loading has been disabled until the incompatibility is resolved.");
+            Iris.info(C.DARK_RED + "Alternatively, go to plugins/iris/settings.json and set ignoreBootMode to true.");
+        } else {
+            J.s(() -> {
+                J.a(() -> PaperLib.suggestPaper(this));
+                J.a(() -> IO.delete(getTemp()));
+                J.a(LazyPregenerator::loadLazyGenerators, 100);
+                J.a(this::bstats);
+                J.ar(this::checkConfigHotload, 60);
+                J.sr(this::tickQueue, 0);
+                J.s(this::setupPapi);
+                J.a(ServerConfigurator::configure, 20);
+                splash();
+                UtilsSFG.splash();
+                autoStartStudio();
+                checkForBukkitWorlds();
+                IrisToolbelt.retainMantleDataForSlice(String.class.getCanonicalName());
+                IrisToolbelt.retainMantleDataForSlice(BlockData.class.getCanonicalName());
+            });
+        }
+    }
+
+    private void checkForBukkitWorlds() {
+        FileConfiguration fc = new YamlConfiguration();
+        try {
+            fc.load(new File("bukkit.yml"));
+            ConfigurationSection section = fc.getConfigurationSection("worlds");
+            if (section == null) {
+                return;
+            }
+
+            for (String s : section.getKeys(false)) {
+                try {
+
+                    ConfigurationSection entry = section.getConfigurationSection(s);
+                    if (!entry.contains("backup-generator", true)) {
+                        continue;
+                    }
+
+                    String generator = entry.getString("backup-generator");
+                    if (!generator.startsWith("Iris")) {
+                        continue;
+                    }
+
+                    if (new File(Bukkit.getWorldContainer().getPath() + "/" + s).exists()) {
+                        File world = new File(Bukkit.getWorldContainer().getPath() + "/" + s + "/iris/engine-data/");
+                        IOFileFilter jsonFilter = org.apache.commons.io.filefilter.FileFilterUtils.suffixFileFilter(".json");
+                        Collection<File> files = FileUtils.listFiles(world, jsonFilter, TrueFileFilter.INSTANCE);
+                        if (files.size() != 1) {
+                            Iris.info(C.DARK_GRAY + "------------------------------------------");
+                            Iris.info(C.RED + "Failed to load " + C.GRAY + s + C.RED + ". No valid engine-data file was found.");
+                            Iris.info(C.DARK_GRAY + "------------------------------------------");
+                            continue;
+                        }
+
+                        for (File file : files) {
+                            int lastDotIndex = file.getName().lastIndexOf(".");
+                            generator = file.getName().substring(0, lastDotIndex);
+                        }
+                    } else {
+                        if (generator.startsWith("Iris:")) {
+                            generator = generator.split("\\Q:\\E")[1];
+                        } else if (generator.equalsIgnoreCase("Iris")) {
+                            generator = IrisSettings.get().getGenerator().getDefaultWorldType();
+                        } else {
+                            continue;
+                        }
+                    }
+
+                    Iris.info("2 World: %s | Generator: %s", s, generator);
+
+                    if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
+                        continue;
+                    }
+
+                    Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
+                    new WorldCreator(s)
+                            .generator(getDefaultWorldGenerator(s, generator))
+                            .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                            .createWorld();
+                    Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
+                } catch (Exception e) {
+                    Iris.info(C.DARK_GRAY + "------------------------------------------");
+                    Iris.info(C.RED + "Failed to load " + C.GRAY + s);
+                    Iris.info(C.DARK_GRAY + "------------------------------------------");
+                }
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void autoStartStudio() {
+        if (IrisSettings.get().getStudio().isAutoStartDefaultStudio()) {
+            Iris.info("Starting up auto Studio!");
+            try {
+                Player r = new KList<>(getServer().getOnlinePlayers()).getRandom();
+                Iris.service(StudioSVC.class).open(r != null ? new VolmitSender(r) : getSender(), 1337, IrisSettings.get().getGenerator().getDefaultWorldType(), (w) -> {
+                    J.s(() -> {
+                        for (Player i : getServer().getOnlinePlayers()) {
+                            i.setGameMode(GameMode.SPECTATOR);
+                            i.teleport(new Location(w, 0, 200, 0));
+                        }
+                    });
+                });
+            } catch (IrisException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void setupAudience() {
+        try {
+            audiences = BukkitAudiences.create(this);
+        } catch (Throwable e) {
+            e.printStackTrace();
+            IrisSettings.get().getGeneral().setUseConsoleCustomColors(false);
+            IrisSettings.get().getGeneral().setUseCustomColorsIngame(false);
+            Iris.error("Failed to setup Adventure API... No custom colors :(");
+        }
+    }
+
+    public void postShutdown(Runnable r) {
+        postShutdown.add(r);
+    }
+
+    public void onEnable() {
+        enable();
+        super.onEnable();
+        Bukkit.getPluginManager().registerEvents(this, this);
+        setupChecks();
+    }
+
+    public void onDisable() {
+        Bukkit.getWorlds().stream()
+                .filter(IrisToolbelt::isIrisWorld)
+                .forEach(w -> {
+                    Engine engine = IrisToolbelt.access(w).getEngine();
+                    engine.close();
+                });
+        services.values().forEach(IrisService::onDisable);
+        Bukkit.getScheduler().cancelTasks(this);
+        HandlerList.unregisterAll((Plugin) this);
+        postShutdown.forEach(Runnable::run);
+        services.clear();
+        MultiBurst.burst.close();
+        super.onDisable();
+    }
+
+    private void setupPapi() {
+        if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
+            new IrisPapiExpansion().register();
+        }
+    }
+
+    @Override
+    public void start() {
+
+    }
+
+    @Override
+    public void stop() {
+
+    }
+
+    @Override
+    public String getTag(String subTag) {
+        if (IrisSafeguard.instance.unstablemode) {
+            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.RED + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
+        }
+        if (IrisSafeguard.instance.warningmode) {
+            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.GOLD + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
+        }
+        return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.IRIS + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
+
+    }
+
+    private boolean setupChecks() {
+        boolean passed = true;
+        Iris.info("Server type & version: " + instance.getServer().getVersion() + " | " + instance.getServer().getBukkitVersion());
+        if (INMS.get() instanceof NMSBinding1X) {
+            passed = false;
+            Iris.warn("============================================");
+            Iris.warn("=");
+            Iris.warn("=");
+            Iris.warn("=");
+            Iris.warn("Iris is not compatible with this version of Minecraft.");
+            Iris.warn("=");
+            Iris.warn("=");
+            Iris.warn("=");
+            Iris.warn("============================================");
+        }
+        if (!instance.getServer().getVersion().contains("Purpur")) {
+            passed = false;
+            Iris.info("We recommend using Purpur for the best experience with Iris.");
+            Iris.info("Purpur is a fork of Paper that is optimized for performance and stability.");
+            Iris.info("Plugins that work on Spigot / Paper work on Purpur.");
+            Iris.info("You can download it here: https://purpurmc.org");
+        }
+        return passed;
+    }
+
+    private void checkConfigHotload() {
+        if (configWatcher.checkModified()) {
+            IrisSettings.invalidate();
+            IrisSettings.get();
+            configWatcher.checkModified();
+            Iris.info("Hotloaded settings.json ");
+        }
+    }
+
+    private void tickQueue() {
+        synchronized (Iris.syncJobs) {
+            if (!Iris.syncJobs.hasNext()) {
+                return;
+            }
+
+            long ms = M.ms();
+
+            while (Iris.syncJobs.hasNext() && M.ms() - ms < 25) {
+                try {
+                    Iris.syncJobs.next().run();
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    Iris.reportError(e);
+                }
+            }
+        }
+    }
+
+    private void bstats() {
+        if (IrisSettings.get().getGeneral().isPluginMetrics()) {
+            J.s(() -> new Metrics(Iris.instance, 8757));
+        }
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        return super.onCommand(sender, command, label, args);
+    }
+
+    public void imsg(CommandSender s, String msg) {
+        s.sendMessage(C.IRIS + "[" + C.DARK_GRAY + "Iris" + C.IRIS + "]" + C.GRAY + ": " + msg);
+    }
+
+    private void installMainDimension() {
+        try {
+            Properties props = new Properties();
+            props.load(new FileInputStream("server.properties"));
+            String world = props.getProperty("level-name");
+            if (world == null) return;
+
+            FileConfiguration fc = new YamlConfiguration();
+            fc.load(new File("bukkit.yml"));
+            String id = fc.getString("worlds." + world + ".generator");
+            if (id.startsWith("Iris:")) {
+                id = id.split("\\Q:\\E")[1];
+            } else if (id.equalsIgnoreCase("Iris")) {
+                id = IrisSettings.get().getGenerator().getDefaultWorldType();
+            } else {
+                return;
+            }
+
+            IrisDimension dim;
+            if (id == null || id.isEmpty()) {
+                dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
+            } else {
+                dim = IrisData.loadAnyDimension(id);
+            }
+
+            File w = new File(Bukkit.getWorldContainer(), world);
+            File packFolder = new File(w, "/iris/pack");
+            if (!packFolder.exists() || packFolder.listFiles().length == 0) {
+                packFolder.mkdirs();
+                service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w);
+            }
+            if (packFolder.exists()) {
+                IrisDimension worldDim = IrisData.get(packFolder).getDimensionLoader().load(id);
+                if (worldDim != null) dim = worldDim;
+            }
+
+            INMS.get().registerDimension("overworld", dim);
+        } catch (Throwable e) {
+
+        }
+    }
+
+    @Nullable
+    @Override
+    public BiomeProvider getDefaultBiomeProvider(@NotNull String worldName, @Nullable String id) {
+        Iris.debug("Biome Provider Called for " + worldName + " using ID: " + id);
+        return super.getDefaultBiomeProvider(worldName, id);
+    }
+
+    @Override
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
+        if (worldName.equals("test")) {
+            try {
+                throw new RuntimeException();
+            } catch (Throwable e) {
+                Iris.info(e.getStackTrace()[1].getClassName());
+                if (e.getStackTrace()[1].getClassName().contains("com.onarandombox.MultiverseCore")) {
+                    Iris.debug("MVC Test detected, Quick! Send them the dummy!");
+                    return new DummyChunkGenerator();
+                }
+            }
+        }
+
+        IrisDimension dim;
+        if (id == null || id.isEmpty()) {
+            dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
+        } else {
+            dim = IrisData.loadAnyDimension(id);
+        }
+        Iris.debug("Generator ID: " + id + " requested by bukkit/plugin");
+
+        if (dim == null) {
+            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
+
+            service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, true);
+            dim = IrisData.loadAnyDimension(id);
+
+            if (dim == null) {
+                throw new RuntimeException("Can't find dimension " + id + "!");
+            } else {
+                Iris.info("Resolved missing dimension, proceeding with generation.");
+            }
+        }
+        File packFolder = new File(Bukkit.getWorldContainer(), worldName + "/iris/pack");
+        if (packFolder.exists()) {
+            IrisDimension worldDim = IrisData.get(packFolder).getDimensionLoader().load(id);
+            if (worldDim != null) dim = worldDim;
+        }
+
+        Iris.debug("Assuming IrisDimension: " + dim.getName());
+
+        IrisWorld w = IrisWorld.builder()
+                .name(worldName)
+                .seed(1337)
+                .environment(dim.getEnvironment())
+                .worldFolder(new File(Bukkit.getWorldContainer(), worldName))
+                .minHeight(dim.getMinHeight())
+                .maxHeight(dim.getMaxHeight())
+                .build();
+
+        Iris.debug("Generator Config: " + w.toString());
+
+        File ff = new File(w.worldFolder(), "iris/pack");
+        if (!ff.exists() || ff.listFiles().length == 0) {
+            ff.mkdirs();
+            service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w.worldFolder());
+        }
+        if (!INMS.get().registerDimension(worldName, dim)) {
+            throw new IllegalStateException("Unable to register dimension " + dim.getName());
+        }
+        INMS.get().reconnectAll();
+
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
+    }
+
+    public void splash() {
+        if (!IrisSettings.get().getGeneral().isSplashLogoStartup()) {
+            return;
+        }
+
+        String padd = Form.repeat(" ", 8);
+        String padd2 = Form.repeat(" ", 4);
+
+        String colorIris, colorVolmit, colorVersion;
+        if (IrisSafeguard.instance.unstablemode) {
+            colorIris = String.valueOf(C.RED);
+            colorVolmit = String.valueOf(C.DARK_RED);
+            colorVersion = String.valueOf(C.RED);
+        } else if (IrisSafeguard.instance.warningmode) {
+            colorIris = String.valueOf(C.GOLD);
+            colorVolmit = String.valueOf(C.GOLD);
+            colorVersion = String.valueOf(C.GOLD);
+        } else {
+            colorIris = String.valueOf(C.IRIS);
+            colorVolmit = "<rainbow>";
+            colorVersion = String.valueOf(C.IRIS);
+        }
+
+        String[] info = {
+                "",
+                "",
+                "",
+                "",
+                "",
+                padd2 + colorIris + " Iris",
+                padd2 + C.GRAY + " by " + colorVolmit + "Volmit Software",
+                padd2 + C.GRAY + " v" + colorVersion + getDescription().getVersion()
+        };
+
+        String[] splash = {
+                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
+                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + colorIris + "   .(((()))).                     ",
+                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + colorIris + "  .((((((())))))).                  ",
+                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + colorIris + "  ((((((((()))))))))               " + C.GRAY + " @",
+                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + colorIris + "    ((((((((-)))))))))              " + C.GRAY + " @@",
+                padd + C.GRAY + "@@@&&" + colorIris + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
+                padd + C.GRAY + "@@" + colorIris + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
+                padd + C.GRAY + "@" + colorIris + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
+                padd + C.GRAY + "" + colorIris + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
+                padd + C.GRAY + "" + colorIris + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
+                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
+        };
+
+        setupChecks();
+        Iris.info("Java: " + getJava());
+        if (!instance.getServer().getVersion().contains("Purpur")) {
+            if (instance.getServer().getVersion().contains("Spigot") && instance.getServer().getVersion().contains("Bukkit")) {
+                Iris.info(C.RED + " Iris requires paper or above to function properly..");
+            } else {
+                Iris.info(C.YELLOW + "Purpur is recommended to use with iris.");
+            }
+        }
+        if (getHardware.getProcessMemory() < 5999) {
+            Iris.warn("6GB+ Ram is recommended");
+            Iris.warn("Process Memory: " + getHardware.getProcessMemory() + " MB");
+        }
+        Iris.info("Bukkit distro: " + Bukkit.getName());
+        Iris.info("Custom Biomes: " + INMS.get().countCustomBiomes());
+        printPacks();
+
+        for (int i = 0; i < info.length; i++) {
+            splash[i] += info[i];
+        }
+
+        Iris.info("\n\n " + new KList<>(splash).toString("\n") + "\n");
+    }
+
+    private void printPacks() {
+        File packFolder = Iris.service(StudioSVC.class).getWorkspaceFolder();
+        File[] packs = packFolder.listFiles(File::isDirectory);
+        if (packs == null || packs.length == 0)
+            return;
+        Iris.info("Custom Dimensions: " + packs.length);
+        for (File f : packs)
+            printPack(f);
+    }
+
+    private void printPack(File pack) {
+        String dimName = pack.getName();
+        String version = "???";
+        try (FileReader r = new FileReader(new File(pack, "dimensions/" + dimName + ".json"))) {
+            JsonObject json = JsonParser.parseReader(r).getAsJsonObject();
+            if (json.has("version"))
+                version = json.get("version").getAsString();
+        } catch (IOException | JsonParseException ignored) {
+        }
+        Iris.info("  " + dimName + " v" + version);
+    }
+
+    public int getIrisVersion() {
+        String input = Iris.instance.getDescription().getVersion();
+        int hyphenIndex = input.indexOf('-');
+        if (hyphenIndex != -1) {
+            String result = input.substring(0, hyphenIndex);
+            result = result.replaceAll("\\.", "");
+            return Integer.parseInt(result);
+        }
+        return -1;
+    }
+
+    public int getMCVersion() {
+        try {
+            String version = Bukkit.getVersion();
+            Matcher matcher = Pattern.compile("\\(MC: ([\\d.]+)\\)").matcher(version);
+            if (matcher.find()) {
+                version = matcher.group(1).replaceAll("\\.", "");
+                long versionNumber = Long.parseLong(version);
+                if (versionNumber > Integer.MAX_VALUE) {
+                    return -1;
+                }
+                return (int) versionNumber;
+            }
+            return -1;
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+}

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

@@ -0,0 +1,225 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.json.JSONException;
+import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.plugin.VolmitSender;
+import lombok.Data;
+
+import java.io.File;
+import java.io.IOException;
+
+@SuppressWarnings("SynchronizeOnNonFinalField")
+@Data
+public class IrisSettings {
+    public static IrisSettings settings;
+    private IrisSafeGuard safeguard = new IrisSafeGuard();
+    private IrisSettingsGeneral general = new IrisSettingsGeneral();
+    private IrisSettingsWorld world = new IrisSettingsWorld();
+    private IrisSettingsGUI gui = new IrisSettingsGUI();
+    private IrisSettingsAutoconfiguration autoConfiguration = new IrisSettingsAutoconfiguration();
+    private IrisSettingsGenerator generator = new IrisSettingsGenerator();
+    private IrisSettingsConcurrency concurrency = new IrisSettingsConcurrency();
+    private IrisSettingsStudio studio = new IrisSettingsStudio();
+    private IrisSettingsPerformance performance = new IrisSettingsPerformance();
+    private IrisWorldDump worldDump = new IrisWorldDump();
+    private IrisWorldSettings irisWorldSettings = new IrisWorldSettings();
+    private IrisServerSettings server = new IrisServerSettings();
+
+    public static int getThreadCount(int c) {
+        return switch (c) {
+            case -1, -2, -4 -> Runtime.getRuntime().availableProcessors() / -c;
+            case 0, 1, 2 -> 1;
+            default -> Math.max(c, 2);
+        };
+    }
+
+    public static IrisSettings get() {
+        if (settings != null) {
+            return settings;
+        }
+
+        settings = new IrisSettings();
+
+        File s = Iris.instance.getDataFile("settings.json");
+
+        if (!s.exists()) {
+            try {
+                IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+            } catch (JSONException | IOException e) {
+                e.printStackTrace();
+                Iris.reportError(e);
+            }
+        } else {
+            try {
+                String ss = IO.readAll(s);
+                settings = new Gson().fromJson(ss, IrisSettings.class);
+                try {
+                    IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            } catch (Throwable ee) {
+                // Iris.reportError(ee); causes a self-reference & stackoverflow
+                Iris.error("Configuration Error in settings.json! " + ee.getClass().getSimpleName() + ": " + ee.getMessage());
+            }
+        }
+
+        return settings;
+    }
+
+    public static void invalidate() {
+        synchronized (settings) {
+            settings = null;
+        }
+    }
+
+    public void forceSave() {
+        File s = Iris.instance.getDataFile("settings.json");
+
+        try {
+            IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+        } catch (JSONException | IOException e) {
+            e.printStackTrace();
+            Iris.reportError(e);
+        }
+    }
+
+    @Data
+    public static class IrisSafeGuard {
+        public boolean ignoreBootMode = false;
+        public boolean userUnstableWarning = true;
+    }
+
+    @Data
+    public static class IrisSettingsAutoconfiguration {
+        public boolean configureSpigotTimeoutTime = true;
+        public boolean configurePaperWatchdogDelay = true;
+        public boolean autoRestartOnCustomBiomeInstall = true;
+    }
+
+    @Data
+    public static class IrisAsyncTeleport {
+        public boolean enabled = false;
+        public int loadViewDistance = 2;
+        public boolean urgent = false;
+    }
+
+    @Data
+    public static class IrisSettingsWorld {
+        public IrisAsyncTeleport asyncTeleport = new IrisAsyncTeleport();
+        public boolean postLoadBlockUpdates = true;
+        public boolean forcePersistEntities = true;
+        public boolean anbientEntitySpawningSystem = true;
+        public long asyncTickIntervalMS = 700;
+        public double targetSpawnEntitiesPerChunk = 0.95;
+        public boolean markerEntitySpawningSystem = true;
+        public boolean effectSystem = true;
+        public boolean worldEditWandCUI = true;
+    }
+
+    @Data
+    public static class IrisSettingsConcurrency {
+        public int parallelism = -1;
+    }
+
+    @Data
+    public static class IrisSettingsPerformance {
+        public boolean trimMantleInStudio = false;
+        public int mantleKeepAlive = 30;
+        public int headlessKeepAlive = 10;
+        public int cacheSize = 4_096;
+        public int resourceLoaderCacheSize = 1_024;
+        public int objectLoaderCacheSize = 4_096;
+        public int scriptLoaderCacheSize = 512;
+    }
+
+    @Data
+    public static class IrisSettingsGeneral {
+        public boolean commandSounds = true;
+        public boolean debug = false;
+        public boolean disableNMS = false;
+        public boolean pluginMetrics = true;
+        public boolean splashLogoStartup = true;
+        public boolean useConsoleCustomColors = true;
+        public boolean useCustomColorsIngame = true;
+        public String forceMainWorld = "";
+        public int spinh = -20;
+        public int spins = 7;
+        public int spinb = 8;
+        public String cartographerMessage = "Iris does not allow cartographers in its world due to crashes.";
+        public String[] dataPackPaths = new String[0];
+
+
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+        public boolean canUseCustomColors(VolmitSender volmitSender) {
+            return volmitSender.isPlayer() ? useCustomColorsIngame : useConsoleCustomColors;
+        }
+    }
+
+    @Data
+    public static class IrisSettingsGUI {
+        public boolean useServerLaunchedGuis = true;
+        public boolean maximumPregenGuiFPS = false;
+        public boolean colorMode = true;
+    }
+
+    @Data
+    public static class IrisSettingsGenerator {
+        public String defaultWorldType = "overworld";
+        public int maxBiomeChildDepth = 4;
+        public boolean preventLeafDecay = true;
+    }
+
+    @Data
+    public static class IrisSettingsStudio {
+        public boolean studio = true;
+        public boolean openVSCode = true;
+        public boolean disableTimeAndWeather = true;
+        public boolean autoStartDefaultStudio = false;
+    }
+
+    @Data
+    public static class IrisWorldDump {
+        public int mcaCacheSize = 3;
+    }
+
+    @Data
+    public static class IrisServerSettings {
+        public boolean active = false;
+        public int port = 1337;
+        public String[] remote = new String[0];
+
+        public boolean isRemote() {
+            return remote.length != 0;
+        }
+    }
+
+    // todo: Goal:Have these as the default world settings and when put in bukkit.yml it will again overwrite that world from these.
+    @Data
+    public static class IrisWorldSettings {
+        public boolean dynamicEntityAdjustments;
+
+
+    }
+}

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

@@ -0,0 +1,132 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.scheduling.J;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+public class ServerConfigurator {
+    public static void configure() {
+        IrisSettings.IrisSettingsAutoconfiguration s = IrisSettings.get().getAutoConfiguration();
+        if (s.isConfigureSpigotTimeoutTime()) {
+            J.attempt(ServerConfigurator::increaseKeepAliveSpigot);
+        }
+
+        if (s.isConfigurePaperWatchdogDelay()) {
+            J.attempt(ServerConfigurator::increasePaperWatchdog);
+        }
+    }
+
+    private static void increaseKeepAliveSpigot() throws IOException, InvalidConfigurationException {
+        File spigotConfig = new File("spigot.yml");
+        FileConfiguration f = new YamlConfiguration();
+        f.load(spigotConfig);
+        long tt = f.getLong("settings.timeout-time");
+
+        if (tt < TimeUnit.MINUTES.toSeconds(5)) {
+            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + TimeUnit.MINUTES.toSeconds(20) + " (5 minutes)");
+            Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
+            f.set("settings.timeout-time", TimeUnit.MINUTES.toSeconds(5));
+            f.save(spigotConfig);
+        }
+    }
+
+    private static void increasePaperWatchdog() throws IOException, InvalidConfigurationException {
+        File spigotConfig = new File("config/paper-global.yml");
+        FileConfiguration f = new YamlConfiguration();
+        f.load(spigotConfig);
+        long tt = f.getLong("watchdog.early-warning-delay");
+
+        if (tt < TimeUnit.MINUTES.toMillis(3)) {
+            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + TimeUnit.MINUTES.toMillis(15) + " (3 minutes)");
+            Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
+            f.set("watchdog.early-warning-delay", TimeUnit.MINUTES.toMillis(3));
+            f.save(spigotConfig);
+        }
+    }
+
+    private static File[] getDataPacksFolder() {
+        KList<File> files = new KList<>();
+        files.add(new File("plugins/Iris/datapack"));
+        Arrays.stream(IrisSettings.get().getGeneral().dataPackPaths)
+                .map(File::new)
+                .forEach(files::add);
+        return files.toArray(File[]::new);
+    }
+
+    public static void setupDataPack() {
+        File packs = new File("plugins/Iris/packs");
+        if (!packs.exists()) {
+            disableDataPack();
+            return;
+        }
+        for (File i : packs.listFiles()) {
+            if (!i.isDirectory()) continue;
+
+            Iris.verbose("Checking Pack: " + i.getPath());
+            IrisData data = IrisData.get(i);
+            File dims = new File(i, "dimensions");
+
+            if (dims.exists()) {
+                for (File j : dims.listFiles((f, s) -> s.endsWith(".json"))) {
+                    if (!j.isFile()) continue;
+                    IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
+                    if (dim == null) continue;
+
+                    dim.getAllBiomes(() -> data)
+                            .stream()
+                            .map(IrisBiome::getCustomDerivitives)
+                            .filter(Objects::nonNull)
+                            .flatMap(KList::stream)
+                            .forEach(b -> INMS.get().registerBiome(dim.getLoadKey(), b, false));
+                }
+            }
+        }
+        dumpDataPack();
+    }
+
+    public static void dumpDataPack() {
+        if (!INMS.get().dumpRegistry(getDataPacksFolder())) {
+            return;
+        }
+        disableDataPack();
+    }
+
+    public static void disableDataPack() {
+        var packs = INMS.get().getPackRepository();
+        packs.reload();
+        if (!packs.removePack("file/iris"))
+            return;
+        packs.reloadWorldData();
+    }
+}

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

@@ -0,0 +1,313 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.tools.IrisPackBenchmarking;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.core.tools.IrisWorldDump;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.framework.EnginePlayer;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.service.EngineStatusSVC;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.mantle.TectonicPlate;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.plugin.VolmitSender;
+import net.jpountz.lz4.LZ4BlockInputStream;
+import net.jpountz.lz4.LZ4BlockOutputStream;
+import net.jpountz.lz4.LZ4FrameInputStream;
+import net.jpountz.lz4.LZ4FrameOutputStream;
+import org.apache.commons.lang.RandomStringUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+
+import java.io.*;
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+@Decree(name = "Developer", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"dev"})
+public class CommandDeveloper implements DecreeExecutor {
+    private CommandTurboPregen turboPregen;
+    private CommandUpdater updater;
+
+    @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, aliases = "status", sync = true)
+    public void EngineStatus() {
+        var status = EngineStatusSVC.getStatus();
+
+        sender().sendMessage("-------------------------");
+        sender().sendMessage(C.DARK_PURPLE + "Engine Status");
+        sender().sendMessage(C.DARK_PURPLE + "Total Engines: " + C.LIGHT_PURPLE + status.engineCount());
+        sender().sendMessage(C.DARK_PURPLE + "Total Loaded Chunks: " + C.LIGHT_PURPLE + status.loadedChunks());
+        sender().sendMessage(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + status.tectonicLimit());
+        sender().sendMessage(C.DARK_PURPLE + "Tectonic Total Plates: " + C.LIGHT_PURPLE + status.tectonicPlates());
+        sender().sendMessage(C.DARK_PURPLE + "Tectonic Active Plates: " + C.LIGHT_PURPLE + status.activeTectonicPlates());
+        sender().sendMessage(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + status.queuedTectonicPlates());
+        sender().sendMessage(C.DARK_PURPLE + "Lowest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.minTectonicUnloadDuration()));
+        sender().sendMessage(C.DARK_PURPLE + "Highest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.maxTectonicUnloadDuration()));
+        sender().sendMessage(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
+        sender().sendMessage("-------------------------");
+    }
+
+    @Decree(description = "Test")
+    public void benchmarkMantle(
+            @Param(description = "The world to bench", aliases = {"world"})
+            World world
+    ) throws IOException, ClassNotFoundException {
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        int maxHeight = engine.getTarget().getHeight();
+        File folder = new File(Bukkit.getWorldContainer(), world.getName());
+        int c = 0;
+        //MCAUtil.read()
+
+        File tectonicplates = new File(folder, "mantle");
+        for (File i : Objects.requireNonNull(tectonicplates.listFiles())) {
+            TectonicPlate.read(maxHeight, i);
+            c++;
+            sender().sendMessage("Loaded count: " + c);
+
+        }
+
+    }
+
+    @Decree(description = "Test")
+    public void packBenchmark(
+            @Param(description = "The pack to bench", defaultValue = "overworld", aliases = {"pack"})
+            IrisDimension dimension,
+            @Param(description = "The address to use", defaultValue = "-")
+            String address,
+            @Param(description = "Headless", defaultValue = "true")
+            boolean headless,
+            @Param(description = "GUI", defaultValue = "false")
+            boolean gui,
+            @Param(description = "Diameter in regions", defaultValue = "5")
+            int diameter
+    ) {
+        int rb = diameter << 9;
+        Iris.info("Benchmarking pack " + dimension.getName() + " with diameter: " + rb + "(" + diameter + ")");
+        IrisPackBenchmarking benchmark = new IrisPackBenchmarking(dimension, address.replace("-", "").trim(), diameter, headless, gui);
+        benchmark.runBenchmark();
+    }
+
+    @Decree(description = "test")
+    public void mca(
+            @Param(description = "String") World world) {
+        try {
+            IrisWorldDump dump = new IrisWorldDump(world, sender());
+            dump.start();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @Decree(description = "test")
+    public void test() {
+        try {
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @Decree(description = "UnloadChunks for good reasons.")
+    public void unloadchunks() {
+        List<World> IrisWorlds = new ArrayList<>();
+        int chunksUnloaded = 0;
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                if (IrisToolbelt.access(world).getEngine() != null) {
+                    IrisWorlds.add(world);
+                }
+            } catch (Exception e) {
+                // no
+            }
+        }
+
+        for (World world : IrisWorlds) {
+            for (Chunk chunk : world.getLoadedChunks()) {
+                if (chunk.isLoaded()) {
+                    chunk.unload();
+                    chunksUnloaded++;
+                }
+            }
+        }
+        Iris.info(C.IRIS + "Chunks Unloaded: " + chunksUnloaded);
+
+    }
+
+    @Decree
+    public void objects(@Param(defaultValue = "overworld") IrisDimension dimension) {
+        var loader = dimension.getLoader().getObjectLoader();
+        var sender = sender();
+        var keys = loader.getPossibleKeys();
+        var burst = MultiBurst.burst.burst(keys.length);
+        AtomicInteger failed = new AtomicInteger();
+        for (String key : keys) {
+            burst.queue(() -> {
+                if (loader.load(key) == null)
+                    failed.incrementAndGet();
+            });
+        }
+        burst.complete();
+        sender.sendMessage(C.RED + "Failed to load " + failed.get() + " of " + keys.length + " objects");
+    }
+
+    @Decree(description = "Test", aliases = {"ip"})
+    public void network() {
+        try {
+            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
+            for (NetworkInterface ni : Collections.list(networkInterfaces)) {
+                Iris.info("Display Name: %s", ni.getDisplayName());
+                Enumeration<InetAddress> inetAddresses = ni.getInetAddresses();
+                for (InetAddress ia : Collections.list(inetAddresses)) {
+                    Iris.info("IP: %s", ia.getHostAddress());
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "All players in iris worlds")
+    public void getPlayers() {
+        KList<World> IrisWorlds = new KList<>();
+        for (World w : Bukkit.getServer().getWorlds()) {
+            if(IrisToolbelt.isIrisWorld(w)) {
+                IrisWorlds.add(w);
+            }
+        }
+
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                sender().sendMessage(C.IRIS + "- " + IrisWorld.getName() + C.GRAY + ", " + IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers().stream().count() + " players");
+                for (EnginePlayer player : IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers()) {
+                    sender().sendMessage(C.DARK_GRAY + "> " + player.getPlayer().getName());
+                }
+            }
+        } else {
+            Iris.info(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                Iris.info(C.IRIS + "- " + IrisWorld.getName() + C.GRAY + ", " + IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers().stream().count() + " players");
+                for (EnginePlayer player : IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers()) {
+                    Iris.info(C.DARK_GRAY + "> " + player.getPlayer().getName());
+                }
+            }
+        }
+    }
+
+    @Decree(description = "Test the compression algorithms")
+    public void compression(
+            @Param(description = "base IrisWorld") World world,
+            @Param(description = "raw TectonicPlate File") String path,
+            @Param(description = "Algorithm to Test") String algorithm,
+            @Param(description = "Amount of Tests") int amount) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+
+        File file = new File(path);
+        if (!file.exists()) return;
+
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        if (engine != null) {
+            int height = engine.getTarget().getHeight();
+            VolmitSender sender = sender();
+            new Thread(() -> {
+                try {
+                    DataInputStream raw = new DataInputStream(new FileInputStream(file));
+                    TectonicPlate plate = new TectonicPlate(height, raw);
+                    raw.close();
+
+                    double d1 = 0;
+                    double d2 = 0;
+                    long size = 0;
+                    File folder = new File("tmp");
+                    folder.mkdirs();
+                    for (int i = 0; i < amount; i++) {
+                        File tmp = new File(folder, RandomStringUtils.randomAlphanumeric(10) + "." + algorithm + ".bin");
+                        DataOutputStream dos = createOutput(tmp, algorithm);
+                        long start = System.currentTimeMillis();
+                        plate.write(dos);
+                        dos.close();
+                        d1 += System.currentTimeMillis() - start;
+                        if (size == 0)
+                            size = tmp.length();
+                        start = System.currentTimeMillis();
+                        DataInputStream din = createInput(tmp, algorithm);
+                        new TectonicPlate(height, din);
+                        din.close();
+                        d2 += System.currentTimeMillis() - start;
+                        tmp.delete();
+                    }
+                    IO.delete(folder);
+                    sender.sendMessage(algorithm + " is " + Form.fileSize(size) + " big after compression");
+                    sender.sendMessage(algorithm + " Took " + d2 / amount + "ms to read");
+                    sender.sendMessage(algorithm + " Took " + d1 / amount + "ms to write");
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                }
+            }, "Compression Test").start();
+        } else {
+            Iris.info(C.RED + "Engine is null!");
+        }
+    }
+
+    private DataInputStream createInput(File file, String algorithm) throws Throwable {
+        FileInputStream in = new FileInputStream(file);
+
+        return new DataInputStream(switch (algorithm) {
+            case "gzip" -> new GZIPInputStream(in);
+            case "lz4f" -> new LZ4FrameInputStream(in);
+            case "lz4b" -> new LZ4BlockInputStream(in);
+            default -> throw new IllegalStateException("Unexpected value: " + algorithm);
+        });
+    }
+
+    private DataOutputStream createOutput(File file, String algorithm) throws Throwable {
+        FileOutputStream out = new FileOutputStream(file);
+
+        return new DataOutputStream(switch (algorithm) {
+            case "gzip" -> new GZIPOutputStream(out);
+            case "lz4f" -> new LZ4FrameOutputStream(out);
+            case "lz4b" -> new LZ4BlockOutputStream(out);
+            default -> throw new IllegalStateException("Unexpected value: " + algorithm);
+        });
+    }
+}
+
+

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

@@ -0,0 +1,212 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.engine.object.*;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.decree.specialhandlers.NullableBiomeHandler;
+import com.volmit.iris.util.decree.specialhandlers.NullableRegionHandler;
+import com.volmit.iris.util.format.C;
+import org.bukkit.block.Biome;
+
+import java.awt.*;
+
+
+@Decree(name = "edit", origin = DecreeOrigin.PLAYER, studio = true, description = "Edit something")
+public class CommandEdit implements DecreeExecutor {
+
+    private boolean noStudio() {
+        if (!sender().isPlayer()) {
+            sender().sendMessage(C.RED + "Players only!");
+            return true;
+        }
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
+            sender().sendMessage(C.RED + "No studio world is open!");
+            return true;
+        }
+        if (!engine().isStudio()) {
+            sender().sendMessage(C.RED + "You must be in a studio world!");
+            return true;
+        }
+        return false;
+    }
+
+
+    @Decree(description = "Edit the biome you specified", aliases = {"b"}, origin = DecreeOrigin.PLAYER)
+    public void biome(@Param(contextual = false, description = "The biome to edit", defaultValue = "---", customHandler = NullableBiomeHandler.class) IrisBiome biome) {
+        if (noStudio()) {
+            return;
+        }
+        if (biome == null) {
+            try {
+                IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY() - player().getWorld().getMinHeight(), player().getLocation().getBlockZ());
+                Desktop.getDesktop().open(b.getLoadFile());
+                sender().sendMessage(C.GREEN + "Opening " + b.getTypeName() + " " + b.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+            } catch (Throwable e) {
+                Iris.reportError(e);
+                sender().sendMessage("Non-Iris Biome: " + player().getLocation().getBlock().getBiome().name());
+                if (player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
+                    try {
+                        sender().sendMessage("Data Pack Biome: " + INMS.get().getTrueBiomeBaseKey(player().getLocation()) + " (ID: " + INMS.get().getTrueBiomeBaseId(INMS.get().getTrueBiomeBase(player().getLocation())) + ")");
+                    } catch (Throwable ee) {
+                        Iris.reportError(ee);
+                    }
+                }
+            }
+            return;
+        }
+
+        try {
+            if (biome.getLoadFile() == null) {
+                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
+                return;
+            }
+            Desktop.getDesktop().open(biome.getLoadFile());
+            sender().sendMessage(C.GREEN + "Opening " + biome.getTypeName() + " " + biome.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
+        }
+    }
+
+    @Decree(description = "Edit the region you specified", aliases = {"r"}, origin = DecreeOrigin.PLAYER)
+    public void region(@Param(contextual = false, description = "The region to edit", defaultValue = "---", customHandler = NullableRegionHandler.class) IrisRegion region) {
+        if (noStudio()) {
+            return;
+        }
+        if (region == null) {
+            try {
+                IrisRegion r = engine().getRegion(player().getLocation().getBlockX(), player().getLocation().getBlockZ());
+                Desktop.getDesktop().open(r.getLoadFile());
+                sender().sendMessage(C.GREEN + "Opening " + r.getTypeName() + " " + r.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+            } catch (Throwable e) {
+                sender().sendMessage(C.RED + "Failed to get region.");
+            }
+            return;
+        }
+        try {
+            if (region == null || region.getLoadFile() == null) {
+                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
+                return;
+            }
+            Desktop.getDesktop().open(region.getLoadFile());
+            sender().sendMessage(C.GREEN + "Opening " + region.getTypeName() + " " + region.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
+        }
+    }
+
+    @Decree(description = "Edit the dimension you specified", aliases = {"d"}, origin = DecreeOrigin.PLAYER)
+    public void dimension(@Param(contextual = false, description = "The dimension to edit") IrisDimension dimension) {
+        if (noStudio()) {
+            return;
+        }
+        try {
+            if (dimension == null || dimension.getLoadFile() == null) {
+                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
+                return;
+            }
+            Desktop.getDesktop().open(dimension.getLoadFile());
+            sender().sendMessage(C.GREEN + "Opening " + dimension.getTypeName() + " " + dimension.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
+        }
+    }
+
+    @Decree(description = "Edit the cave file you specified", aliases = {"c"}, origin = DecreeOrigin.PLAYER)
+    public void cave(@Param(contextual = false, description = "The cave to edit") IrisCave cave) {
+        if (noStudio()) {
+            return;
+        }
+        try {
+            if (cave == null || cave.getLoadFile() == null) {
+                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
+                return;
+            }
+            Desktop.getDesktop().open(cave.getLoadFile());
+            sender().sendMessage(C.GREEN + "Opening " + cave.getTypeName() + " " + cave.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
+        }
+    }
+
+    @Decree(description = "Edit the structure file you specified", aliases = {"jigsawstructure", "structure"}, origin = DecreeOrigin.PLAYER)
+    public void jigsaw(@Param(contextual = false, description = "The jigsaw structure to edit") IrisJigsawStructure jigsaw) {
+        if (noStudio()) {
+            return;
+        }
+        try {
+            if (jigsaw == null || jigsaw.getLoadFile() == null) {
+                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
+                return;
+            }
+            Desktop.getDesktop().open(jigsaw.getLoadFile());
+            sender().sendMessage(C.GREEN + "Opening " + jigsaw.getTypeName() + " " + jigsaw.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
+        }
+    }
+
+    @Decree(description = "Edit the pool file you specified", aliases = {"jigsawpool", "pool"}, origin = DecreeOrigin.PLAYER)
+    public void jigsawPool(@Param(contextual = false, description = "The jigsaw pool to edit") IrisJigsawPool pool) {
+        if (noStudio()) {
+            return;
+        }
+        try {
+            if (pool == null || pool.getLoadFile() == null) {
+                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
+                return;
+            }
+            Desktop.getDesktop().open(pool.getLoadFile());
+            sender().sendMessage(C.GREEN + "Opening " + pool.getTypeName() + " " + pool.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
+        }
+    }
+
+    @Decree(description = "Edit the jigsaw piece file you specified", aliases = {"jigsawpiece", "piece"}, origin = DecreeOrigin.PLAYER)
+    public void jigsawPiece(@Param(contextual = false, description = "The jigsaw piece to edit") IrisJigsawPiece piece) {
+        if (noStudio()) {
+            return;
+        }
+        try {
+            if (piece == null || piece.getLoadFile() == null) {
+                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
+                return;
+            }
+            Desktop.getDesktop().open(piece.getLoadFile());
+            sender().sendMessage(C.GREEN + "Opening " + piece.getTypeName() + " " + piece.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
+        }
+    }
+
+}

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

@@ -0,0 +1,117 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisJigsawStructure;
+import com.volmit.iris.engine.object.IrisRegion;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
+import com.volmit.iris.util.format.C;
+
+@Decree(name = "find", origin = DecreeOrigin.PLAYER, description = "Iris Find commands", aliases = "goto")
+public class CommandFind implements DecreeExecutor {
+    @Decree(description = "Find a biome")
+    public void biome(
+            @Param(description = "The biome to look for")
+            IrisBiome biome,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
+    ) {
+        Engine e = engine();
+
+        if (e == null) {
+            sender().sendMessage(C.GOLD + "Not in an Iris World!");
+            return;
+        }
+
+        e.gotoBiome(biome, player(), teleport);
+    }
+
+    @Decree(description = "Find a region")
+    public void region(
+            @Param(description = "The region to look for")
+            IrisRegion region,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
+    ) {
+        Engine e = engine();
+
+        if (e == null) {
+            sender().sendMessage(C.GOLD + "Not in an Iris World!");
+            return;
+        }
+
+        e.gotoRegion(region, player(), teleport);
+    }
+
+    @Decree(description = "Find a structure")
+    public void structure(
+            @Param(description = "The structure to look for")
+            IrisJigsawStructure structure,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
+    ) {
+        Engine e = engine();
+
+        if (e == null) {
+            sender().sendMessage(C.GOLD + "Not in an Iris World!");
+            return;
+        }
+
+        e.gotoJigsaw(structure, player(), teleport);
+    }
+
+    @Decree(description = "Find a point of interest.")
+    public void poi(
+            @Param(description = "The type of PoI to look for.")
+            String type,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
+    ) {
+        Engine e = engine();
+        if (e == null) {
+            sender().sendMessage(C.GOLD + "Not in an Iris World!");
+            return;
+        }
+
+        e.gotoPOI(type, player(), teleport);
+    }
+
+    @Decree(description = "Find an object")
+    public void object(
+            @Param(description = "The object to look for", customHandler = ObjectHandler.class)
+            String object,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
+    ) {
+        Engine e = engine();
+
+        if (e == null) {
+            sender().sendMessage(C.GOLD + "Not in an Iris World!");
+            return;
+        }
+
+        e.gotoObject(object, player(), teleport);
+    }
+}

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

@@ -0,0 +1,650 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.pregenerator.ChunkUpdater;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisBenchmarking;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.engine.platform.BukkitChunkGenerator;
+import com.volmit.iris.engine.platform.DummyChunkGenerator;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.decree.specialhandlers.NullablePlayerHandler;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.J;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.filefilter.IOFileFilter;
+import org.apache.commons.io.filefilter.TrueFileFilter;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.WorldCreator;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import static com.volmit.iris.Iris.service;
+import static com.volmit.iris.core.service.EditSVC.deletingWorld;
+import static com.volmit.iris.core.tools.IrisBenchmarking.inProgress;
+import static org.bukkit.Bukkit.getServer;
+
+@Decree(name = "iris", aliases = {"ir", "irs"}, description = "Basic Command")
+public class CommandIris implements DecreeExecutor {
+    public static boolean worldCreation = false;
+    String WorldEngine;
+    String worldNameToCheck = "YourWorldName";
+    VolmitSender sender = Iris.getSender();
+    private CommandStudio studio;
+    private CommandPregen pregen;
+    private CommandSettings settings;
+    private CommandObject object;
+    private CommandJigsaw jigsaw;
+    private CommandWhat what;
+    private CommandEdit edit;
+    private CommandFind find;
+    private CommandSupport support;
+    private CommandDeveloper developer;
+
+    public static boolean deleteDirectory(File dir) {
+        if (dir.isDirectory()) {
+            File[] children = dir.listFiles();
+            for (int i = 0; i < children.length; i++) {
+                boolean success = deleteDirectory(children[i]);
+                if (!success) {
+                    return false;
+                }
+            }
+        }
+        return dir.delete();
+    }
+
+    @Decree(description = "Create a new world", aliases = {"+", "c"})
+    public void create(
+            @Param(aliases = "world-name", description = "The name of the world to create")
+            String name,
+            @Param(aliases = "dimension", description = "The dimension type to create the world with", defaultValue = "default")
+            IrisDimension type,
+            @Param(description = "The seed to generate the world with", defaultValue = "1337")
+            long seed,
+            @Param(description = "The radius of chunks to generate in headless mode (-1 to disable)", defaultValue = "10", aliases = "radius")
+            int headlessRadius,
+            @Param(description = "If it should convert the dimension to match the vanilla height system.", defaultValue = "false")
+            boolean vanillaheight
+    ) {
+
+        if (name.equals("iris")) {
+            sender().sendMessage(C.RED + "You cannot use the world name \"iris\" for creating worlds as Iris uses this directory for studio worlds.");
+            sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
+            return;
+        }
+        if (name.equals("Benchmark")) {
+            sender().sendMessage(C.RED + "You cannot use the world name \"Benchmark\" for creating worlds as Iris uses this directory for Benchmarking Packs.");
+            sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
+            return;
+        }
+
+        if (new File(Bukkit.getWorldContainer(), name).exists()) {
+            sender().sendMessage(C.RED + "That folder already exists!");
+            return;
+        }
+
+        try {
+            worldCreation = true;
+            IrisToolbelt.createWorld()
+                    .dimension(type.getLoadKey())
+                    .name(name)
+                    .seed(seed)
+                    .sender(sender())
+                    .studio(false)
+                    .headlessRadius(headlessRadius)
+                    .create();
+        } catch (Throwable e) {
+            sender().sendMessage(C.RED + "Exception raised during creation. See the console for more details.");
+            Iris.error("Exception raised during world creation: " + e.getMessage());
+            Iris.reportError(e);
+            worldCreation = false;
+            return;
+        }
+        worldCreation = false;
+        sender().sendMessage(C.GREEN + "Successfully created your world!");
+    }
+
+    @Decree(description = "Teleport to another world", aliases = {"tp"}, sync = true)
+    public void teleport(
+            @Param(description = "World to teleport to")
+            World world,
+            @Param(description = "Player to teleport", defaultValue = "---", customHandler = NullablePlayerHandler.class)
+            Player player
+    ) {
+        if (player == null && sender().isPlayer())
+            player = sender().player();
+
+        final Player target = player;
+        if (target == null) {
+            sender().sendMessage(C.RED + "The specified player does not exist.");
+            return;
+        }
+
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                target.teleport(world.getSpawnLocation());
+                new VolmitSender(target).sendMessage(C.GREEN + "You have been teleported to " + world.getName() + ".");
+            }
+        }.runTask(Iris.instance);
+    }
+
+    @Decree(description = "Print version information")
+    public void version() {
+        sender().sendMessage(C.GREEN + "Iris v" + Iris.instance.getDescription().getVersion() + " by Volmit Software");
+    }
+
+    /*
+    /todo
+    @Decree(description = "Benchmark a pack", origin = DecreeOrigin.CONSOLE)
+    public void packbenchmark(
+            @Param(description = "Dimension to benchmark")
+            IrisDimension type
+    ) throws InterruptedException {
+
+         BenchDimension = type.getLoadKey();
+
+        IrisPackBenchmarking.runBenchmark();
+    } */
+
+    //todo Move to React
+    @Decree(description = "Benchmark your server", origin = DecreeOrigin.CONSOLE)
+    public void serverbenchmark() throws InterruptedException {
+        if (!inProgress) {
+            IrisBenchmarking.runBenchmark();
+        } else {
+            Iris.info(C.RED + "Benchmark already is in progress.");
+        }
+    }
+
+    @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
+    public void height() {
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "" + sender().player().getWorld().getMinHeight() + " to " + sender().player().getWorld().getMaxHeight());
+            sender().sendMessage(C.GREEN + "Total Height: " + (sender().player().getWorld().getMaxHeight() - sender().player().getWorld().getMinHeight()));
+        } else {
+            World mainWorld = getServer().getWorlds().get(0);
+            Iris.info(C.GREEN + "" + mainWorld.getMinHeight() + " to " + mainWorld.getMaxHeight());
+            Iris.info(C.GREEN + "Total Height: " + (mainWorld.getMaxHeight() - mainWorld.getMinHeight()));
+        }
+    }
+
+    @Decree(description = "QOL command to open a overworld studio world.", sync = true)
+    public void so() {
+        sender().sendMessage(C.GREEN + "Opening studio for the \"Overworld\" pack (seed: 1337)");
+        Iris.service(StudioSVC.class).open(sender(), 1337, "overworld");
+    }
+
+    @Decree(description = "Check access of all worlds.", aliases = {"accesslist"})
+    public void worlds() {
+        KList<World> IrisWorlds = new KList<>();
+        KList<World> BukkitWorlds = new KList<>();
+
+        for (World w : Bukkit.getServer().getWorlds()) {
+            try {
+                Engine engine = IrisToolbelt.access(w).getEngine();
+                if (engine != null) {
+                    IrisWorlds.add(w);
+                }
+            } catch (Exception e) {
+                BukkitWorlds.add(w);
+            }
+        }
+
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                sender().sendMessage(C.IRIS + "- " + IrisWorld.getName());
+            }
+            sender().sendMessage(C.GOLD + "Bukkit Worlds: ");
+            for (World BukkitWorld : BukkitWorlds.copy()) {
+                sender().sendMessage(C.GRAY + "- " + BukkitWorld.getName());
+            }
+        } else {
+            Iris.info(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                Iris.info(C.IRIS + "- " + IrisWorld.getName());
+            }
+            Iris.info(C.GOLD + "Bukkit Worlds: ");
+            for (World BukkitWorld : BukkitWorlds.copy()) {
+                Iris.info(C.GRAY + "- " + BukkitWorld.getName());
+            }
+
+        }
+    }
+
+    @Decree(description = "Remove an Iris world", aliases = {"del", "rm", "delete"}, sync = true)
+    public void remove(
+            @Param(description = "The world to remove")
+            World world,
+            @Param(description = "Whether to also remove the folder (if set to false, just does not load the world)", defaultValue = "true")
+            boolean delete
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
+        try {
+            if (IrisToolbelt.removeWorld(world)) {
+                sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
+            } else {
+                sender().sendMessage(C.YELLOW + "Looks like the world was already removed from bukkit.yml");
+            }
+        } catch (IOException e) {
+            sender().sendMessage(C.RED + "Failed to save bukkit.yml because of " + e.getMessage());
+            e.printStackTrace();
+        }
+        IrisToolbelt.evacuate(world, "Deleting world");
+        deletingWorld = true;
+        Bukkit.unloadWorld(world, false);
+        int retries = 12;
+        if (delete) {
+            if (deleteDirectory(world.getWorldFolder())) {
+                sender().sendMessage(C.GREEN + "Successfully removed world folder");
+            } else {
+                while (true) {
+                    if (deleteDirectory(world.getWorldFolder())) {
+                        sender().sendMessage(C.GREEN + "Successfully removed world folder");
+                        break;
+                    }
+                    retries--;
+                    if (retries == 0) {
+                        sender().sendMessage(C.RED + "Failed to remove world folder");
+                        break;
+                    }
+                    J.sleep(3000);
+                }
+            }
+        }
+        deletingWorld = false;
+    }
+
+    @Decree(description = "Updates all chunk in the specified world")
+    public void updater(
+            @Param(description = "World to update chunks at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        ChunkUpdater updater = new ChunkUpdater(world);
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "Updating " + world.getName() + " Total chunks: " + Form.f(updater.getChunks()));
+        } else {
+            Iris.info(C.GREEN + "Updating " + world.getName() + " Total chunks: " + Form.f(updater.getChunks()));
+        }
+        updater.start();
+    }
+
+    @Decree(description = "Set aura spins")
+    public void aura(
+            @Param(description = "The h color value", defaultValue = "-20")
+            int h,
+            @Param(description = "The s color value", defaultValue = "7")
+            int s,
+            @Param(description = "The b color value", defaultValue = "8")
+            int b
+    ) {
+        IrisSettings.get().getGeneral().setSpinh(h);
+        IrisSettings.get().getGeneral().setSpins(s);
+        IrisSettings.get().getGeneral().setSpinb(b);
+        IrisSettings.get().forceSave();
+        sender().sendMessage("<rainbow>Aura Spins updated to " + h + " " + s + " " + b);
+    }
+
+    @Decree(description = "Bitwise calculations")
+    public void bitwise(
+            @Param(description = "The first value to run calculations on")
+            int value1,
+            @Param(description = "The operator: | & ^ ≺≺ ≻≻ ％")
+            String operator,
+            @Param(description = "The second value to run calculations on")
+            int value2
+    ) {
+        Integer v = null;
+        switch (operator) {
+            case "|" -> v = value1 | value2;
+            case "&" -> v = value1 & value2;
+            case "^" -> v = value1 ^ value2;
+            case "%" -> v = value1 % value2;
+            case ">>" -> v = value1 >> value2;
+            case "<<" -> v = value1 << value2;
+        }
+        if (v == null) {
+            sender().sendMessage(C.RED + "The operator you entered: (" + operator + ") is invalid!");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "" + value1 + " " + C.GREEN + operator.replaceAll("<", "≺").replaceAll(">", "≻").replaceAll("%", "％") + " " + C.GREEN + value2 + C.GREEN + " returns " + C.GREEN + v);
+    }
+
+    @Decree(description = "Toggle debug")
+    public void debug(
+            @Param(name = "on", description = "Whether or not debug should be on", defaultValue = "other")
+            Boolean on
+    ) {
+        boolean to = on == null ? !IrisSettings.get().getGeneral().isDebug() : on;
+        IrisSettings.get().getGeneral().setDebug(to);
+        IrisSettings.get().forceSave();
+        sender().sendMessage(C.GREEN + "Set debug to: " + to);
+    }
+
+    @Decree(description = "Download a project.", aliases = "dl")
+    public void download(
+            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
+            String pack,
+            @Param(name = "branch", description = "The branch to download from", defaultValue = "main")
+            String branch,
+            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            boolean trim,
+            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
+            boolean overwrite
+    ) {
+        sender().sendMessage(C.GREEN + "Downloading pack: " + pack + "/" + branch + (trim ? " trimmed" : "") + (overwrite ? " overwriting" : ""));
+        if (pack.equals("overworld")) {
+            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + Iris.OVERWORLD_TAG + "/overworld.zip";
+            Iris.service(StudioSVC.class).downloadRelease(sender(), url, trim, overwrite);
+        } else {
+            Iris.service(StudioSVC.class).downloadSearch(sender(), "IrisDimensions/" + pack + "/" + branch, trim, overwrite);
+        }
+    }
+
+    @Decree(description = "Get metrics for your world", aliases = "measure", origin = DecreeOrigin.PLAYER)
+    public void metrics() {
+        if (!IrisToolbelt.isIrisWorld(world())) {
+            sender().sendMessage(C.RED + "You must be in an Iris world");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Sending metrics...");
+        engine().printMetrics(sender());
+    }
+
+    @Decree(description = "Reload configuration file (this is also done automatically)")
+    public void reload() {
+        IrisSettings.invalidate();
+        IrisSettings.get();
+        sender().sendMessage(C.GREEN + "Hotloaded settings");
+    }
+
+    @Decree(description = "Update the pack of a world (UNSAFE!)", name = "^world", aliases = "update-world")
+    public void updateWorld(
+            @Param(description = "The world to update", contextual = true)
+            World world,
+            @Param(description = "The pack to install into the world", contextual = true, aliases = "dimension")
+            IrisDimension pack,
+            @Param(description = "Make sure to make a backup & read the warnings first!", defaultValue = "false", aliases = "c")
+            boolean confirm,
+            @Param(description = "Should Iris download the pack again for you", defaultValue = "false", name = "fresh-download", aliases = {"fresh", "new"})
+            boolean freshDownload
+    ) {
+        if (!confirm) {
+            sender().sendMessage(new String[]{
+                    C.RED + "You should always make a backup before using this",
+                    C.YELLOW + "Issues caused by this can be, but are not limited to:",
+                    C.YELLOW + " - Broken chunks (cut-offs) between old and new chunks (before & after the update)",
+                    C.YELLOW + " - Regenerated chunks that do not fit in with the old chunks",
+                    C.YELLOW + " - Structures not spawning again when regenerating",
+                    C.YELLOW + " - Caves not lining up",
+                    C.YELLOW + " - Terrain layers not lining up",
+                    C.RED + "Now that you are aware of the risks, and have made a back-up:",
+                    C.RED + "/iris ^world " + world.getName() + " " + pack.getLoadKey() + " confirm=true"
+            });
+            return;
+        }
+
+        File folder = world.getWorldFolder();
+        folder.mkdirs();
+
+        if (freshDownload) {
+            Iris.service(StudioSVC.class).downloadSearch(sender(), pack.getLoadKey(), false, true);
+        }
+
+        Iris.service(StudioSVC.class).installIntoWorld(sender(), pack.getLoadKey(), folder);
+    }
+
+    @Decree(description = "Unload an Iris World", sync = true)
+    public void unload(
+            @Param(description = "The world to unload")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Unloading world: " + world.getName());
+        try {
+            IrisToolbelt.evacuate(world);
+            Bukkit.unloadWorld(world, false);
+            sender().sendMessage(C.GREEN + "World unloaded successfully.");
+        } catch (Exception e) {
+            sender().sendMessage(C.RED + "Failed to unload the world: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Load an Iris World", origin = DecreeOrigin.PLAYER, sync = true, aliases = {"import"})
+    public void load(
+            @Param(description = "The name of the world to load")
+            String world
+    ) {
+
+        FileConfiguration fc = new YamlConfiguration();
+        try {
+            fc.load(new File("bukkit.yml"));
+            ConfigurationSection section = fc.getConfigurationSection("worlds");
+            if (section == null) {
+                return;
+            }
+
+            for (String s : section.getKeys(false)) {
+                try {
+
+                    ConfigurationSection entry = section.getConfigurationSection(s);
+                    if (!entry.contains("backup-generator", true)) {
+                        continue;
+                    }
+
+                    String generator = entry.getString("backup-generator");
+                    if (!generator.startsWith("Iris")) {
+                        continue;
+                    }
+
+                    if (!s.equalsIgnoreCase(world)) {
+                        continue;
+                    }
+
+                    File worldFolder = new File(Bukkit.getWorldContainer().getPath() + "/" + s + "/iris/engine-data/");
+                    IOFileFilter jsonFilter = org.apache.commons.io.filefilter.FileFilterUtils.suffixFileFilter(".json");
+                    Collection<File> files = FileUtils.listFiles(worldFolder, jsonFilter, TrueFileFilter.INSTANCE);
+                    if (files.size() != 1) {
+                        Iris.info(C.DARK_GRAY + "------------------------------------------");
+                        Iris.info(C.RED + "Failed to load " + C.GRAY + s + C.RED + ". No valid engine-data file was found.");
+                        Iris.info(C.DARK_GRAY + "------------------------------------------");
+                        continue;
+                    }
+
+                    for (File file : files) {
+                        int lastDotIndex = file.getName().lastIndexOf(".");
+                        generator = file.getName().substring(0, lastDotIndex);
+                    }
+
+                    Iris.info("2 World: %s | Generator: %s", s, generator);
+
+                    if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
+                        continue;
+                    }
+
+                    Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
+                    new WorldCreator(s)
+                            .generator(getDefaultWorldGenerator(s, generator))
+                            .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                            .createWorld();
+                    Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
+                    break;
+                } catch (Exception e) {
+                    Iris.info(C.DARK_GRAY + "------------------------------------------");
+                    Iris.info(C.RED + "Failed to load " + C.GRAY + s);
+                    Iris.info(C.DARK_GRAY + "------------------------------------------");
+                }
+                sender().sendMessage(C.GOLD + "Failed to find world: " + C.DARK_GRAY + world);
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Evacuate an iris world", origin = DecreeOrigin.PLAYER, sync = true)
+    public void evacuate(
+            @Param(description = "Evacuate the world")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Evacuating world" + world.getName());
+        IrisToolbelt.evacuate(world);
+    }
+
+    boolean doesWorldExist(String worldName) {
+        File worldContainer = Bukkit.getWorldContainer();
+        File worldDirectory = new File(worldContainer, worldName);
+        return worldDirectory.exists() && worldDirectory.isDirectory();
+    }
+
+    private void checkForBukkitWorlds(String world) {
+        FileConfiguration fc = new YamlConfiguration();
+        try {
+            fc.load(new File("bukkit.yml"));
+            ConfigurationSection section = fc.getConfigurationSection("worlds");
+            if (section == null) {
+                return;
+            }
+
+            List<String> worldsToLoad = Collections.singletonList(world);
+
+            for (String s : section.getKeys(false)) {
+                if (!worldsToLoad.contains(s)) {
+                    continue;
+                }
+                ConfigurationSection entry = section.getConfigurationSection(s);
+                if (!entry.contains("generator", true)) {
+                    continue;
+                }
+                String generator = entry.getString("generator");
+                if (generator.startsWith("Iris:")) {
+                    generator = generator.split("\\Q:\\E")[1];
+                } else if (generator.equalsIgnoreCase("Iris")) {
+                    generator = IrisSettings.get().getGenerator().getDefaultWorldType();
+                } else {
+                    continue;
+                }
+                Iris.info("2 World: %s | Generator: %s", s, generator);
+                if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
+                    continue;
+                }
+                Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
+                new WorldCreator(s)
+                        .generator(getDefaultWorldGenerator(s, generator))
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                        .createWorld();
+                Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
+        if (worldName.equals("test")) {
+            try {
+                throw new RuntimeException();
+            } catch (Throwable e) {
+                Iris.info(e.getStackTrace()[1].getClassName());
+                if (e.getStackTrace()[1].getClassName().contains("com.onarandombox.MultiverseCore")) {
+                    Iris.debug("MVC Test detected, Quick! Send them the dummy!");
+                    return new DummyChunkGenerator();
+                }
+            }
+        }
+        IrisDimension dim;
+        if (id == null || id.isEmpty()) {
+            dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
+        } else {
+            dim = IrisData.loadAnyDimension(id);
+        }
+        Iris.debug("Generator ID: " + id + " requested by bukkit/plugin");
+
+        if (dim == null) {
+            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
+
+            service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, true);
+            dim = IrisData.loadAnyDimension(id);
+
+            if (dim == null) {
+                throw new RuntimeException("Can't find dimension " + id + "!");
+            } else {
+                Iris.info("Resolved missing dimension, proceeding with generation.");
+            }
+        }
+        Iris.debug("Assuming IrisDimension: " + dim.getName());
+        IrisWorld w = IrisWorld.builder()
+                .name(worldName)
+                .seed(1337)
+                .environment(dim.getEnvironment())
+                .worldFolder(new File(Bukkit.getWorldContainer(), worldName))
+                .minHeight(dim.getMinHeight())
+                .maxHeight(dim.getMaxHeight())
+                .build();
+        Iris.debug("Generator Config: " + w.toString());
+        File ff = new File(w.worldFolder(), "iris/pack");
+        if (!ff.exists() || ff.listFiles().length == 0) {
+            ff.mkdirs();
+            service(StudioSVC.class).installIntoWorld(sender, dim.getLoadKey(), ff.getParentFile());
+        }
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
+    }
+}

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

@@ -0,0 +1,121 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.edit.JigsawEditor;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.engine.framework.placer.WorldObjectPlacer;
+import com.volmit.iris.engine.jigsaw.PlannedStructure;
+import com.volmit.iris.engine.object.IrisJigsawPiece;
+import com.volmit.iris.engine.object.IrisJigsawStructure;
+import com.volmit.iris.engine.object.IrisObject;
+import com.volmit.iris.engine.object.IrisPosition;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+
+import java.io.File;
+
+@Decree(name = "jigsaw", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris jigsaw commands")
+public class CommandJigsaw implements DecreeExecutor {
+    @Decree(description = "Edit a jigsaw piece")
+    public void edit(
+            @Param(description = "The jigsaw piece to edit")
+            IrisJigsawPiece piece
+    ) {
+        File dest = piece.getLoadFile();
+        new JigsawEditor(player(), piece, IrisData.loadAnyObject(piece.getObject()), dest);
+    }
+
+    @Decree(description = "Place a jigsaw structure")
+    public void place(
+            @Param(description = "The jigsaw structure to place")
+            IrisJigsawStructure structure
+    ) {
+        PrecisionStopwatch p = PrecisionStopwatch.start();
+        try {
+            var world = world();
+            WorldObjectPlacer placer = new WorldObjectPlacer(world);
+            PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation().add(0, world.getMinHeight(), 0)), new RNG());
+            VolmitSender sender = sender();
+            sender.sendMessage(C.GREEN + "Generated " + ps.getPieces().size() + " pieces in " + Form.duration(p.getMilliseconds(), 2));
+            ps.place(placer, failed -> sender.sendMessage(failed ? C.GREEN + "Placed the structure!" : C.RED + "Failed to place the structure!"));
+        } catch (IllegalArgumentException e) {
+            sender().sendMessage(C.RED + "Failed to place the structure: " + e.getMessage());
+        }
+    }
+
+    @Decree(description = "Create a jigsaw piece")
+    public void create(
+            @Param(description = "The name of the jigsaw piece")
+            String piece,
+            @Param(description = "The project to add the jigsaw piece to")
+            String project,
+            @Param(description = "The object to use for this piece", customHandler = ObjectHandler.class)
+            String object
+    ) {
+        IrisObject o = IrisData.loadAnyObject(object);
+
+        if (object == null) {
+            sender().sendMessage(C.RED + "Failed to find existing object");
+            return;
+        }
+
+        File dest = Iris.instance.getDataFile("packs", project, "jigsaw-pieces", piece + ".json");
+        new JigsawEditor(player(), null, o, dest);
+        sender().sendMessage(C.GRAY + "* Right Click blocks to make them connectors");
+        sender().sendMessage(C.GRAY + "* Right Click connectors to orient them");
+        sender().sendMessage(C.GRAY + "* Shift + Right Click connectors to remove them");
+        sender().sendMessage(C.GREEN + "Remember to use /iris jigsaw save");
+    }
+
+    @Decree(description = "Exit the current jigsaw editor")
+    public void exit() {
+        JigsawEditor editor = JigsawEditor.editors.get(player());
+
+        if (editor == null) {
+            sender().sendMessage(C.GOLD + "You don't have any pieces open to exit!");
+            return;
+        }
+
+        editor.exit();
+        sender().sendMessage(C.GREEN + "Exited Jigsaw Editor");
+    }
+
+    @Decree(description = "Save & Exit the current jigsaw editor")
+    public void save() {
+        JigsawEditor editor = JigsawEditor.editors.get(player());
+
+        if (editor == null) {
+            sender().sendMessage(C.GOLD + "You don't have any pieces open to save!");
+            return;
+        }
+
+        editor.close();
+        sender().sendMessage(C.GREEN + "Saved & Exited Jigsaw Editor");
+    }
+}

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

@@ -0,0 +1,117 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.LazyPregenerator;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.IOException;
+
+@Decree(name = "lazypregen", aliases = "lazy", description = "Pregenerate your Iris worlds!")
+public class CommandLazyPregen implements DecreeExecutor {
+    public String worldName;
+
+    @Decree(description = "Pregenerate a world")
+    public void start(
+            @Param(description = "The radius of the pregen in blocks", aliases = "size")
+            int radius,
+            @Param(description = "The world to pregen", contextual = true)
+            World world,
+            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
+            Vector center,
+            @Param(aliases = "maxcpm", description = "Limit the chunks per minute the pregen will generate", defaultValue = "999999999")
+            int cpm,
+            @Param(aliases = "silent", description = "Silent generation", defaultValue = "false")
+            boolean silent
+    ) {
+
+        worldName = world.getName();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File lazyFile = new File(worldDirectory, "lazygen.json");
+        if (lazyFile.exists()) {
+            sender().sendMessage(C.BLUE + "Lazy pregen is already in progress");
+            Iris.info(C.YELLOW + "Lazy pregen is already in progress");
+            return;
+        }
+
+        try {
+            if (sender().isPlayer() && access() == null) {
+                sender().sendMessage(C.RED + "The engine access for this world is null!");
+                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
+            }
+
+            LazyPregenerator.LazyPregenJob pregenJob = LazyPregenerator.LazyPregenJob.builder()
+                    .world(worldName)
+                    .healingPosition(0)
+                    .healing(false)
+                    .chunksPerMinute(cpm)
+                    .radiusBlocks(radius)
+                    .position(0)
+                    .silent(silent)
+                    .build();
+
+            File lazyGenFile = new File(worldDirectory, "lazygen.json");
+            LazyPregenerator pregenerator = new LazyPregenerator(pregenJob, lazyGenFile);
+            pregenerator.start();
+
+            String msg = C.GREEN + "LazyPregen started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
+            sender().sendMessage(msg);
+            Iris.info(msg);
+        } catch (Throwable e) {
+            sender().sendMessage(C.RED + "Epic fail. See console.");
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Stop the active pregeneration task", aliases = "x")
+    public void stop(
+            @Param(aliases = "world", description = "The world to pause")
+            World world
+    ) throws IOException {
+        if (LazyPregenerator.getInstance() != null) {
+            LazyPregenerator.getInstance().shutdownInstance(world);
+            sender().sendMessage(C.LIGHT_PURPLE + "Closed lazygen instance for " + world.getName());
+        } else {
+            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
+        }
+    }
+
+    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
+    public void pause(
+            @Param(aliases = "world", description = "The world to pause")
+            World world
+    ) {
+        if (LazyPregenerator.getInstance() != null) {
+            LazyPregenerator.getInstance().setPausedLazy(world);
+            sender().sendMessage(C.GREEN + "Paused/unpaused Lazy Pregen, now: " + (LazyPregenerator.getInstance().isPausedLazy(world) ? "Paused" : "Running") + ".");
+        } else {
+            sender().sendMessage(C.YELLOW + "No active Lazy Pregen tasks to pause/unpause.");
+
+        }
+    }
+}

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

@@ -0,0 +1,552 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.WorldEditLink;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.service.ObjectSVC;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.service.WandSVC;
+import com.volmit.iris.core.tools.IrisConverter;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.*;
+import com.volmit.iris.util.data.Cuboid;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.math.Direction;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.misc.E;
+import com.volmit.iris.util.scheduling.Queue;
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.TileState;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.IOException;
+import java.text.NumberFormat;
+import java.util.*;
+
+@Decree(name = "object", aliases = "o", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris object manipulation")
+public class CommandObject implements DecreeExecutor {
+
+    private static final Set<Material> skipBlocks = Set.of(E.getOrDefault(Material.class, "GRASS", "SHORT_GRASS"), Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
+            Material.POPPY, Material.DANDELION);
+
+    public static IObjectPlacer createPlacer(World world, Map<Block, BlockData> futureBlockChanges) {
+
+        return new IObjectPlacer() {
+            @Override
+            public int getHighest(int x, int z, IrisData data) {
+                return world.getHighestBlockYAt(x, z);
+            }
+
+            @Override
+            public int getHighest(int x, int z, IrisData data, boolean ignoreFluid) {
+                return world.getHighestBlockYAt(x, z, ignoreFluid ? HeightMap.OCEAN_FLOOR : HeightMap.MOTION_BLOCKING);
+            }
+
+            @Override
+            public void set(int x, int y, int z, BlockData d) {
+                Block block = world.getBlockAt(x, y, z);
+
+                //Prevent blocks being set in or bellow bedrock
+                if (y <= world.getMinHeight() || block.getType() == Material.BEDROCK)
+                    return;
+
+                futureBlockChanges.put(block, block.getBlockData());
+
+                block.setBlockData(d);
+            }
+
+            @Override
+            public BlockData get(int x, int y, int z) {
+                return world.getBlockAt(x, y, z).getBlockData();
+            }
+
+            @Override
+            public boolean isPreventingDecay() {
+                return false;
+            }
+
+            @Override
+            public boolean isCarved(int x, int y, int z) {
+                return false;
+            }
+
+            @Override
+            public boolean isSolid(int x, int y, int z) {
+                return world.getBlockAt(x, y, z).getType().isSolid();
+            }
+
+            @Override
+            public boolean isUnderwater(int x, int z) {
+                return false;
+            }
+
+            @Override
+            public int getFluidHeight() {
+                return 63;
+            }
+
+            @Override
+            public boolean isDebugSmartBore() {
+                return false;
+            }
+
+            @Override
+            public void setTile(int xx, int yy, int zz, TileData tile) {
+                tile.toBukkitTry(world.getBlockAt(xx, yy, zz));
+            }
+
+            @Override
+            public Engine getEngine() {
+                return null;
+            }
+        };
+    }
+
+    @Decree(description = "Check the composition of an object")
+    public void analyze(
+            @Param(description = "The object to analyze", customHandler = ObjectHandler.class)
+            String object
+    ) {
+        IrisObject o = IrisData.loadAnyObject(object);
+        sender().sendMessage("Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD() + "");
+        sender().sendMessage("Blocks Used: " + NumberFormat.getIntegerInstance().format(o.getBlocks().size()));
+
+        Queue<BlockData> queue = o.getBlocks().enqueueValues();
+        Map<Material, Set<BlockData>> unsorted = new HashMap<>();
+        Map<BlockData, Integer> amounts = new HashMap<>();
+        Map<Material, Integer> materials = new HashMap<>();
+        while (queue.hasNext()) {
+            BlockData block = queue.next();
+
+            //unsorted.put(block.getMaterial(), block);
+
+            if (!amounts.containsKey(block)) {
+                amounts.put(block, 1);
+
+
+            } else
+                amounts.put(block, amounts.get(block) + 1);
+
+            if (!materials.containsKey(block.getMaterial())) {
+                materials.put(block.getMaterial(), 1);
+                unsorted.put(block.getMaterial(), new HashSet<>());
+                unsorted.get(block.getMaterial()).add(block);
+            } else {
+                materials.put(block.getMaterial(), materials.get(block.getMaterial()) + 1);
+                unsorted.get(block.getMaterial()).add(block);
+            }
+
+        }
+
+        List<Material> sortedMatsList = amounts.keySet().stream().map(BlockData::getMaterial)
+                .sorted().toList();
+        Set<Material> sortedMats = new TreeSet<>(Comparator.comparingInt(materials::get).reversed());
+        sortedMats.addAll(sortedMatsList);
+        sender().sendMessage("== Blocks in object ==");
+
+        int n = 0;
+        for (Material mat : sortedMats) {
+            int amount = materials.get(mat);
+            List<BlockData> set = new ArrayList<>(unsorted.get(mat));
+            set.sort(Comparator.comparingInt(amounts::get).reversed());
+            BlockData data = set.get(0);
+            int dataAmount = amounts.get(data);
+
+            String string = " - " + mat.toString() + "*" + amount;
+            if (data.getAsString(true).contains("[")) {
+                string = string + " --> [" + data.getAsString(true).split("\\[")[1]
+                        .replaceAll("true", ChatColor.GREEN + "true" + ChatColor.GRAY)
+                        .replaceAll("false", ChatColor.RED + "false" + ChatColor.GRAY) + "*" + dataAmount;
+            }
+
+            sender().sendMessage(string);
+
+            n++;
+
+            if (n >= 10) {
+                sender().sendMessage("  + " + (sortedMats.size() - n) + " other block types");
+                return;
+            }
+        }
+    }
+
+    @Decree(description = "Shrink an object to its minimum size")
+    public void shrink(@Param(description = "The object to shrink", customHandler = ObjectHandler.class) String object) {
+        IrisObject o = IrisData.loadAnyObject(object);
+        sender().sendMessage("Current Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
+        o.shrinkwrap();
+        sender().sendMessage("New Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
+        try {
+            o.write(o.getLoadFile());
+        } catch (IOException e) {
+            sender().sendMessage("Failed to save object " + o.getLoadFile() + ": " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Convert .schem files in the 'convert' folder to .iob files.")
+    public void convert () {
+        try {
+            IrisConverter.convertSchematics(sender());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @Decree(description = "Get a powder that reveals objects", studio = true, aliases = "d")
+    public void dust() {
+        player().getInventory().addItem(WandSVC.createDust());
+        sender().playSound(Sound.AMBIENT_SOUL_SAND_VALLEY_ADDITIONS, 1f, 1.5f);
+    }
+
+    @Decree(description = "Contract a selection based on your looking direction", aliases = "-")
+    public void contract(
+            @Param(description = "The amount to inset by", defaultValue = "1")
+            int amount
+    ) {
+        if (!WandSVC.isHoldingWand(player())) {
+            sender().sendMessage("Hold your wand.");
+            return;
+        }
+
+
+        Location[] b = WandSVC.getCuboid(player());
+        if (b == null) {
+            return;
+        }
+        Location a1 = b[0].clone();
+        Location a2 = b[1].clone();
+        Cuboid cursor = new Cuboid(a1, a2);
+        Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
+        assert d != null;
+        cursor = cursor.expand(d, -amount);
+        b[0] = cursor.getLowerNE();
+        b[1] = cursor.getUpperSW();
+        player().getInventory().setItemInMainHand(WandSVC.createWand(b[0], b[1]));
+        player().updateInventory();
+        sender().playSound(Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 0.55f);
+    }
+
+    @Decree(description = "Set point 1 to look", aliases = "p1")
+    public void position1(
+            @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
+            boolean here
+    ) {
+        if (!WandSVC.isHoldingWand(player())) {
+            sender().sendMessage("Ready your Wand.");
+            return;
+        }
+
+        if (WandSVC.isHoldingWand(player())) {
+            Location[] g = WandSVC.getCuboid(player());
+
+            if (g == null) {
+                return;
+            }
+            if (!here) {
+                // TODO: WARNING HEIGHT
+                g[1] = player().getTargetBlock(null, 256).getLocation().clone();
+            } else {
+                g[1] = player().getLocation().getBlock().getLocation().clone().add(0, -1, 0);
+            }
+            player().setItemInHand(WandSVC.createWand(g[0], g[1]));
+        }
+    }
+
+    @Decree(description = "Set point 2 to look", aliases = "p2")
+    public void position2(
+            @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
+            boolean here
+    ) {
+        if (!WandSVC.isHoldingWand(player())) {
+            sender().sendMessage("Ready your Wand.");
+            return;
+        }
+
+        if (WandSVC.isHoldingIrisWand(player())) {
+            Location[] g = WandSVC.getCuboid(player());
+
+            if (g == null) {
+                return;
+            }
+
+            if (!here) {
+                // TODO: WARNING HEIGHT
+                g[0] = player().getTargetBlock(null, 256).getLocation().clone();
+            } else {
+                g[0] = player().getLocation().getBlock().getLocation().clone().add(0, -1, 0);
+            }
+            player().setItemInHand(WandSVC.createWand(g[0], g[1]));
+        }
+    }
+
+    @Decree(description = "Paste an object", sync = true)
+    public void paste(
+            @Param(description = "The object to paste", customHandler = ObjectHandler.class)
+            String object,
+            @Param(description = "Whether or not to edit the object (need to hold wand)", defaultValue = "false")
+            boolean edit,
+            @Param(description = "The amount of degrees to rotate by", defaultValue = "0")
+            int rotate,
+            @Param(description = "The factor by which to scale the object placement", defaultValue = "1")
+            double scale
+//            ,
+//            @Param(description = "The scale interpolator to use", defaultValue = "none")
+//            IrisObjectPlacementScaleInterpolator interpolator
+    ) {
+        IrisObject o = IrisData.loadAnyObject(object);
+        double maxScale = Double.max(10 - o.getBlocks().size() / 10000d, 1);
+        if (scale > maxScale) {
+            sender().sendMessage(C.YELLOW + "Indicated scale exceeds maximum. Downscaled to maximum: " + maxScale);
+            scale = maxScale;
+        }
+
+        sender().playSound(Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1f, 1.5f);
+
+        IrisObjectPlacement placement = new IrisObjectPlacement();
+        placement.setRotation(IrisObjectRotation.of(0, rotate, 0));
+
+        ItemStack wand = player().getInventory().getItemInMainHand();
+        Location block = player().getTargetBlock(skipBlocks, 256).getLocation().clone().add(0, 1, 0);
+
+        Map<Block, BlockData> futureChanges = new HashMap<>();
+
+        if (scale != 1) {
+            o = o.scaled(scale, IrisObjectPlacementScaleInterpolator.TRICUBIC);
+        }
+
+        o.place(block.getBlockX(), block.getBlockY() + (int) o.getCenter().getY(), block.getBlockZ(), createPlacer(block.getWorld(), futureChanges), placement, new RNG(), null);
+
+        Iris.service(ObjectSVC.class).addChanges(futureChanges);
+
+        if (edit) {
+            ItemStack newWand = WandSVC.createWand(block.clone().subtract(o.getCenter()).add(o.getW() - 1,
+                    o.getH() + o.getCenter().clone().getY() - 1, o.getD() - 1), block.clone().subtract(o.getCenter().clone().setY(0)));
+            if (WandSVC.isWand(wand)) {
+                wand = newWand;
+                player().getInventory().setItemInMainHand(wand);
+                sender().sendMessage("Updated wand for " + "objects/" + o.getLoadKey() + ".iob ");
+            } else {
+                int slot = WandSVC.findWand(player().getInventory());
+                if (slot == -1) {
+                    player().getInventory().addItem(newWand);
+                    sender().sendMessage("Given new wand for " + "objects/" + o.getLoadKey() + ".iob ");
+                } else {
+                    player().getInventory().setItem(slot, newWand);
+                    sender().sendMessage("Updated wand for " + "objects/" + o.getLoadKey() + ".iob ");
+                }
+            }
+        } else {
+            sender().sendMessage(C.IRIS + "Placed " + object);
+        }
+    }
+
+    @Decree(description = "Save an object")
+    public void save(
+            @Param(description = "The dimension to store the object in", contextual = true)
+            IrisDimension dimension,
+            @Param(description = "The file to store it in, can use / for subfolders")
+            String name,
+            @Param(description = "Overwrite existing object files", defaultValue = "false", aliases = "force")
+            boolean overwrite
+    ) {
+        IrisObject o = WandSVC.createSchematic(player());
+
+        if (o == null) {
+            sender().sendMessage(C.YELLOW + "You need to hold your wand!");
+            return;
+        }
+
+        File file = Iris.service(StudioSVC.class).getWorkspaceFile(dimension.getLoadKey(), "objects", name + ".iob");
+
+        if (file.exists() && !overwrite) {
+            sender().sendMessage(C.RED + "File already exists. Set overwrite=true to overwrite it.");
+            return;
+        }
+        try {
+            o.write(file, sender());
+        } catch (IOException e) {
+            sender().sendMessage(C.RED + "Failed to save object because of an IOException: " + e.getMessage());
+            Iris.reportError(e);
+        }
+
+        sender().playSound(Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1f, 1.5f);
+        sender().sendMessage(C.GREEN + "Successfully object to saved: " + dimension.getLoadKey() + "/objects/" + name);
+    }
+
+    @Decree(description = "Shift a selection in your looking direction", aliases = "-")
+    public void shift(
+            @Param(description = "The amount to shift by", defaultValue = "1")
+            int amount
+    ) {
+        if (!WandSVC.isHoldingWand(player())) {
+            sender().sendMessage("Hold your wand.");
+            return;
+        }
+
+        Location[] b = WandSVC.getCuboid(player());
+        Location a1 = b[0].clone();
+        Location a2 = b[1].clone();
+        Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
+        if (d == null) {
+            return; // HOW DID THIS HAPPEN
+        }
+        a1.add(d.toVector().multiply(amount));
+        a2.add(d.toVector().multiply(amount));
+        Cuboid cursor = new Cuboid(a1, a2);
+        b[0] = cursor.getLowerNE();
+        b[1] = cursor.getUpperSW();
+        player().getInventory().setItemInMainHand(WandSVC.createWand(b[0], b[1]));
+        player().updateInventory();
+        sender().playSound(Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 0.55f);
+    }
+
+    @Decree(description = "Undo a number of pastes", aliases = "-")
+    public void undo(
+            @Param(description = "The amount of pastes to undo", defaultValue = "1")
+            int amount
+    ) {
+        ObjectSVC service = Iris.service(ObjectSVC.class);
+        int actualReverts = Math.min(service.getUndos().size(), amount);
+        service.revertChanges(actualReverts);
+        sender().sendMessage(C.BLUE + "Reverted " + actualReverts + C.BLUE + " pastes!");
+    }
+
+    @Decree(description = "Gets an object wand and grabs the current WorldEdit selection.", aliases = "we", origin = DecreeOrigin.PLAYER, studio = true)
+    public void we() {
+        if (!Bukkit.getPluginManager().isPluginEnabled("WorldEdit")) {
+            sender().sendMessage(C.RED + "You can't get a WorldEdit selection without WorldEdit, you know.");
+            return;
+        }
+
+        Cuboid locs = WorldEditLink.getSelection(sender().player());
+
+        if (locs == null) {
+            sender().sendMessage(C.RED + "You don't have a WorldEdit selection in this world.");
+            return;
+        }
+
+        sender().player().getInventory().addItem(WandSVC.createWand(locs.getLowerNE(), locs.getUpperSW()));
+        sender().sendMessage(C.GREEN + "A fresh wand with your current WorldEdit selection on it!");
+    }
+
+    @Decree(description = "Get an object wand", sync = true)
+    public void wand() {
+        player().getInventory().addItem(WandSVC.createWand());
+        sender().playSound(Sound.ITEM_ARMOR_EQUIP_NETHERITE, 1f, 1.5f);
+        sender().sendMessage(C.GREEN + "Poof! Good luck building!");
+    }
+
+    @Decree(name = "x&y", description = "Autoselect up, down & out", sync = true)
+    public void xay() {
+        if (!WandSVC.isHoldingWand(player())) {
+            sender().sendMessage(C.YELLOW + "Hold your wand!");
+            return;
+        }
+
+        Location[] b = WandSVC.getCuboid(player());
+        Location a1 = b[0].clone();
+        Location a2 = b[1].clone();
+        Location a1x = b[0].clone();
+        Location a2x = b[1].clone();
+        Cuboid cursor = new Cuboid(a1, a2);
+        Cuboid cursorx = new Cuboid(a1, a2);
+
+        while (!cursor.containsOnly(Material.AIR)) {
+            a1.add(new org.bukkit.util.Vector(0, 1, 0));
+            a2.add(new org.bukkit.util.Vector(0, 1, 0));
+            cursor = new Cuboid(a1, a2);
+        }
+
+        a1.add(new org.bukkit.util.Vector(0, -1, 0));
+        a2.add(new org.bukkit.util.Vector(0, -1, 0));
+
+        while (!cursorx.containsOnly(Material.AIR)) {
+            a1x.add(new org.bukkit.util.Vector(0, -1, 0));
+            a2x.add(new org.bukkit.util.Vector(0, -1, 0));
+            cursorx = new Cuboid(a1x, a2x);
+        }
+
+        a1x.add(new org.bukkit.util.Vector(0, 1, 0));
+        a2x.add(new Vector(0, 1, 0));
+        b[0] = a1;
+        b[1] = a2x;
+        cursor = new Cuboid(b[0], b[1]);
+        cursor = cursor.contract(Cuboid.CuboidDirection.North);
+        cursor = cursor.contract(Cuboid.CuboidDirection.South);
+        cursor = cursor.contract(Cuboid.CuboidDirection.East);
+        cursor = cursor.contract(Cuboid.CuboidDirection.West);
+        b[0] = cursor.getLowerNE();
+        b[1] = cursor.getUpperSW();
+        player().getInventory().setItemInMainHand(WandSVC.createWand(b[0], b[1]));
+        player().updateInventory();
+        sender().playSound(Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 0.55f);
+        sender().sendMessage(C.GREEN + "Auto-select complete!");
+    }
+
+    @Decree(name = "x+y", description = "Autoselect up & out", sync = true)
+    public void xpy() {
+        if (!WandSVC.isHoldingWand(player())) {
+            sender().sendMessage(C.YELLOW + "Hold your wand!");
+            return;
+        }
+
+        Location[] b = WandSVC.getCuboid(player());
+        b[0].add(new Vector(0, 1, 0));
+        b[1].add(new Vector(0, 1, 0));
+        Location a1 = b[0].clone();
+        Location a2 = b[1].clone();
+        Cuboid cursor = new Cuboid(a1, a2);
+
+        while (!cursor.containsOnly(Material.AIR)) {
+            a1.add(new Vector(0, 1, 0));
+            a2.add(new Vector(0, 1, 0));
+            cursor = new Cuboid(a1, a2);
+        }
+
+        a1.add(new Vector(0, -1, 0));
+        a2.add(new Vector(0, -1, 0));
+        b[0] = a1;
+        a2 = b[1];
+        cursor = new Cuboid(a1, a2);
+        cursor = cursor.contract(Cuboid.CuboidDirection.North);
+        cursor = cursor.contract(Cuboid.CuboidDirection.South);
+        cursor = cursor.contract(Cuboid.CuboidDirection.East);
+        cursor = cursor.contract(Cuboid.CuboidDirection.West);
+        b[0] = cursor.getLowerNE();
+        b[1] = cursor.getUpperSW();
+        player().getInventory().setItemInMainHand(WandSVC.createWand(b[0], b[1]));
+        player().updateInventory();
+        sender().playSound(Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 0.55f);
+        sender().sendMessage(C.GREEN + "Auto-select complete!");
+    }
+}

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

@@ -0,0 +1,111 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.gui.PregeneratorJob;
+import com.volmit.iris.core.pregenerator.PregenTask;
+import com.volmit.iris.core.pregenerator.methods.HeadlessPregenMethod;
+import com.volmit.iris.core.pregenerator.methods.HybridPregenMethod;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.framework.EngineTarget;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.math.Position2;
+import org.bukkit.World;
+import org.bukkit.util.Vector;
+
+import java.awt.*;
+
+@Decree(name = "pregen", aliases = "pregenerate", description = "Pregenerate your Iris worlds!")
+public class CommandPregen implements DecreeExecutor {
+    @Decree(description = "Pregenerate a world")
+    public void start(
+            @Param(description = "The radius of the pregen in blocks", aliases = "size")
+            int radius,
+            @Param(description = "The world to pregen", contextual = true)
+            World world,
+            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
+            Vector center,
+            @Param(aliases = "headless", description = "Toggle headless pregeneration", defaultValue = "true")
+            boolean headless,
+            @Param(aliases = "gui", description = "Enable or disable the Iris GUI.", defaultValue = "true")
+            boolean gui,
+            @Param(aliases = "resetCache", description = "If it should reset the generated region cache", defaultValue = "false")
+            boolean resetCache
+
+    ) {
+        try {
+            if (sender().isPlayer() && access() == null) {
+                sender().sendMessage(C.RED + "The engine access for this world is null!");
+                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
+            }
+            radius = Math.max(radius, 1024);
+            int w = (radius >> 9 + 1) * 2;
+
+           Engine engine = IrisToolbelt.access(world).getEngine();
+           if(!engine.setEngineHeadless()) {
+               Iris.error("Failed to enable headless engine!");
+               return;
+           }
+
+            IrisToolbelt.pregenerate(PregenTask
+                    .builder()
+                    .resetCache(resetCache)
+                    .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
+                    .gui(!GraphicsEnvironment.isHeadless() && gui)
+                    .width(w)
+                    .height(w)
+                    .build(), headless ? new HeadlessPregenMethod(engine) : new HybridPregenMethod(engine.getWorld().realWorld(),
+                    IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())), engine);
+           if (headless) sender().sendMessage("Using the headless Pregenerator.");
+            String msg = C.GREEN + "Pregen started in " + C.GOLD + world.getName() + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
+            sender().sendMessage(msg);
+            Iris.info(msg);
+        } catch (Throwable e) {
+            sender().sendMessage(C.RED + "Epic fail. See console.");
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Stop the active pregeneration task", aliases = "x")
+    public void stop() {
+        if (PregeneratorJob.shutdownInstance()) {
+            Iris.info(C.BLUE + "Finishing up mca region...");
+        } else {
+            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
+        }
+    }
+
+    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
+    public void pause() {
+        if (PregeneratorJob.pauseResume()) {
+            sender().sendMessage(C.GREEN + "Paused/unpaused pregeneration task, now: " + (PregeneratorJob.isPaused() ? "Paused" : "Running") + ".");
+        } else {
+            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to pause/unpause.");
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.util.decree.DecreeExecutor;
+
+public class CommandSettings implements DecreeExecutor {
+
+}

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

@@ -0,0 +1,705 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.gui.NoiseExplorerGUI;
+import com.volmit.iris.core.gui.VisionGUI;
+import com.volmit.iris.core.project.IrisProject;
+import com.volmit.iris.core.service.ConversionSVC;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisNoiseBenchmark;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.*;
+import com.volmit.iris.engine.platform.PlatformChunkGenerator;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.decree.DecreeContext;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.function.Function2;
+import com.volmit.iris.util.json.JSONArray;
+import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.math.Spiraler;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.O;
+import com.volmit.iris.util.scheduling.jobs.QueueJob;
+import io.papermc.lib.PaperLib;
+import org.bukkit.*;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.util.BlockVector;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.attribute.FileTime;
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Supplier;
+
+@Decree(name = "studio", aliases = {"std", "s"}, description = "Studio Commands", studio = true)
+public class CommandStudio implements DecreeExecutor {
+    private CommandFind find;
+    private CommandEdit edit;
+
+    public static String hrf(Duration duration) {
+        return duration.toString().substring(2).replaceAll("(\\d[HMS])(?!$)", "$1 ").toLowerCase();
+    }
+
+    @Decree(description = "Download a project.", aliases = "dl")
+    public void download(
+            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
+            String pack,
+            @Param(name = "branch", description = "The branch to download from", defaultValue = "master")
+            String branch,
+            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            boolean trim,
+            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
+            boolean overwrite
+    ) {
+        new CommandIris().download(pack, branch, trim, overwrite);
+    }
+
+    @Decree(description = "Open a new studio world", aliases = "o", sync = true)
+    public void open(
+            @Param(defaultValue = "default", description = "The dimension to open a studio for", aliases = "dim")
+            IrisDimension dimension,
+            @Param(defaultValue = "1337", description = "The seed to generate the studio with", aliases = "s")
+            long seed) {
+        sender().sendMessage(C.GREEN + "Opening studio for the \"" + dimension.getName() + "\" pack (seed: " + seed + ")");
+        Iris.service(StudioSVC.class).open(sender(), seed, dimension.getLoadKey());
+    }
+
+    @Decree(description = "Open VSCode for a dimension", aliases = {"vsc", "edit"})
+    public void vscode(
+            @Param(defaultValue = "default", description = "The dimension to open VSCode for", aliases = "dim")
+            IrisDimension dimension
+    ) {
+        sender().sendMessage(C.GREEN + "Opening VSCode for the \"" + dimension.getName() + "\" pack");
+        Iris.service(StudioSVC.class).openVSCode(sender(), dimension.getLoadKey());
+    }
+
+    @Decree(description = "Close an open studio project", aliases = {"x", "c"}, sync = true)
+    public void close() {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
+            sender().sendMessage(C.RED + "No open studio projects.");
+            return;
+        }
+
+        Iris.service(StudioSVC.class).close();
+        sender().sendMessage(C.GREEN + "Project Closed.");
+    }
+
+    @Decree(description = "Create a new studio project", aliases = "+", sync = true)
+    public void create(
+            @Param(description = "The name of this new Iris Project.")
+            String name,
+            @Param(description = "Copy the contents of an existing project in your packs folder and use it as a template in this new project.", contextual = true)
+            IrisDimension template) {
+        if (template != null) {
+            Iris.service(StudioSVC.class).create(sender(), name, template.getLoadKey());
+        } else {
+            Iris.service(StudioSVC.class).create(sender(), name);
+        }
+    }
+
+    @Decree(description = "Get the version of a pack")
+    public void version(
+            @Param(defaultValue = "default", description = "The dimension get the version of", aliases = "dim", contextual = true)
+            IrisDimension dimension
+    ) {
+        sender().sendMessage(C.GREEN + "The \"" + dimension.getName() + "\" pack has version: " + dimension.getVersion());
+    }
+
+    @Decree(name = "regen", description = "Regenerate nearby chunks.", aliases = "rg", sync = true, origin = DecreeOrigin.PLAYER)
+    public void regen(
+            @Param(name = "radius", description = "The radius of nearby cunks", defaultValue = "5")
+            int radius
+    ) {
+        if (IrisToolbelt.isIrisWorld(player().getWorld())) {
+            VolmitSender sender = sender();
+            J.a(() -> {
+                DecreeContext.touch(sender);
+                PlatformChunkGenerator plat = IrisToolbelt.access(player().getWorld());
+                Engine engine = plat.getEngine();
+                try {
+                    Chunk cx = player().getLocation().getChunk();
+                    KList<Runnable> js = new KList<>();
+                    BurstExecutor b = MultiBurst.burst.burst();
+                    b.setMulticore(false);
+                    int rad = engine.getMantle().getRealRadius();
+                    for (int i = -(radius + rad); i <= radius + rad; i++) {
+                        for (int j = -(radius + rad); j <= radius + rad; j++) {
+                            engine.getMantle().getMantle().deleteChunk(i + cx.getX(), j + cx.getZ());
+                        }
+                    }
+
+                    for (int i = -radius; i <= radius; i++) {
+                        for (int j = -radius; j <= radius; j++) {
+                            int finalJ = j;
+                            int finalI = i;
+                            b.queue(() -> plat.injectChunkReplacement(player().getWorld(), finalI + cx.getX(), finalJ + cx.getZ(), (f) -> {
+                                synchronized (js) {
+                                    js.add(f);
+                                }
+                            }));
+                        }
+                    }
+
+                    b.complete();
+                    sender().sendMessage(C.GREEN + "Regenerating " + Form.f(js.size()) + " Sections");
+                    QueueJob<Runnable> r = new QueueJob<>() {
+                        final KList<Future<?>> futures = new KList<>();
+
+                        @Override
+                        public void execute(Runnable runnable) {
+                            futures.add(J.sfut(runnable));
+
+                            if (futures.size() > 64) {
+                                while (futures.isNotEmpty()) {
+                                    try {
+                                        futures.remove(0).get();
+                                    } catch (InterruptedException |
+                                             ExecutionException e) {
+                                        e.printStackTrace();
+                                    }
+                                }
+                            }
+                        }
+
+                        @Override
+                        public String getName() {
+                            return "Regenerating";
+                        }
+                    };
+                    r.queue(js);
+                    r.execute(sender());
+                } catch (Throwable e) {
+                    sender().sendMessage("Unable to parse view-distance");
+                }
+            });
+        } else {
+            sender().sendMessage(C.RED + "You must be in an Iris World to use regen!");
+        }
+    }
+
+    @Decree(description = "Convert objects in the \"convert\" folder")
+    public void convert() {
+        Iris.service(ConversionSVC.class).check(sender());
+        //IrisConverter.convertSchematics(sender());
+    }
+
+    @Decree(description = "Execute a script", aliases = "run", origin = DecreeOrigin.PLAYER)
+    public void execute(
+            @Param(description = "The script to run")
+            IrisScript script
+    ) {
+        engine().getExecution().execute(script.getLoadKey());
+    }
+
+    @Decree(description = "Open the noise explorer (External GUI)", aliases = {"nmap", "n"})
+    public void noise() {
+        if (noGUI()) return;
+        sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
+        NoiseExplorerGUI.launch();
+    }
+
+    @Decree(description = "Charges all spawners in the area", aliases = "zzt", origin = DecreeOrigin.PLAYER)
+    public void charge() {
+        if (!IrisToolbelt.isIrisWorld(world())) {
+            sender().sendMessage(C.RED + "You must be in an Iris world to charge spawners!");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Charging spawners!");
+        engine().getWorldManager().chargeEnergy();
+    }
+
+    @Decree(description = "Preview noise gens (External GUI)", aliases = {"generator", "gen"})
+    public void explore(
+            @Param(description = "The generator to explore", contextual = true)
+            IrisGenerator generator,
+            @Param(description = "The seed to generate with", defaultValue = "12345")
+            long seed
+    ) {
+        if (noGUI()) return;
+        sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
+
+        Supplier<Function2<Double, Double, Double>> l = () -> {
+
+            if (generator == null) {
+                return (x, z) -> 0D;
+            }
+
+            return (x, z) -> generator.getHeight(x, z, new RNG(seed).nextParallelRNG(3245).lmax());
+        };
+        NoiseExplorerGUI.launch(l, "Custom Generator");
+    }
+
+    @Decree(description = "Hotload a studio", aliases = {"reload", "h"})
+    public void hotload() {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
+            sender().sendMessage(C.RED + "No studio world open!");
+            return;
+        }
+        var provider = Iris.service(StudioSVC.class).getActiveProject().getActiveProvider();
+        provider.getEngine().hotload();
+    }
+
+    @Decree(description = "Show loot if a chest were right here", origin = DecreeOrigin.PLAYER, sync = true)
+    public void loot(
+            @Param(description = "Fast insertion of items in virtual inventory (may cause performance drop)", defaultValue = "false")
+            boolean fast,
+            @Param(description = "Whether or not to append to the inventory currently open (if false, clears opened inventory)", defaultValue = "true")
+            boolean add
+    ) {
+        if (noStudio()) return;
+
+        KList<IrisLootTable> tables = engine().getLootTables(RNG.r, player().getLocation().getBlock());
+        Inventory inv = Bukkit.createInventory(null, 27 * 2);
+
+        try {
+            engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.RED + "Cannot add items to virtual inventory because of: " + e.getMessage());
+            return;
+        }
+
+
+        O<Integer> ta = new O<>();
+        ta.set(-1);
+
+        ta.set(Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, () ->
+        {
+            if (!player().getOpenInventory().getType().equals(InventoryType.CHEST)) {
+                Bukkit.getScheduler().cancelTask(ta.get());
+                sender().sendMessage(C.GREEN + "Opened inventory!");
+                return;
+            }
+
+            if (!add) {
+                inv.clear();
+            }
+
+            engine().addItems(true, inv, new RNG(RNG.r.imax()), tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
+        }, 0, fast ? 5 : 35));
+
+        sender().sendMessage(C.GREEN + "Opening inventory now!");
+        player().openInventory(inv);
+    }
+
+
+    @Decree(description = "Get all structures in a radius of chunks", aliases = "dist", origin = DecreeOrigin.PLAYER)
+    public void distances(@Param(description = "The radius in chunks") int radius) {
+        var engine = engine();
+        if (engine == null) {
+            sender().sendMessage(C.RED + "Only works in an Iris world!");
+            return;
+        }
+        var sender = sender();
+        int d = radius * 2;
+        KMap<String, KList<Position2>> data = new KMap<>();
+        var multiBurst = new MultiBurst("Distance Sampler", Thread.MIN_PRIORITY);
+        var executor = multiBurst.burst(radius * radius);
+
+        sender.sendMessage(C.GRAY + "Generating data...");
+        var loc = player().getLocation();
+        int totalTasks = d * d;
+        AtomicInteger completedTasks = new AtomicInteger(0);
+        int c = J.ar(() -> {
+            sender.sendProgress((double) completedTasks.get() / totalTasks, "Finding structures");
+        }, 0);
+
+        new Spiraler(d, d, (x, z) -> executor.queue(() -> {
+            var struct = engine.getStructureAt(x, z);
+            if (struct != null) {
+                data.computeIfAbsent(struct.getLoadKey(), (k) -> new KList<>()).add(new Position2(x, z));
+            }
+            completedTasks.incrementAndGet();
+        })).setOffset(loc.getBlockX(), loc.getBlockZ()).drain();
+
+        executor.complete();
+        multiBurst.close();
+        J.car(c);
+
+        for (var key : data.keySet()) {
+            var list = data.get(key);
+            KList<Long> distances = new KList<>(list.size() - 1);
+            for (int i = 0; i < list.size(); i++) {
+                var pos = list.get(i);
+                double dist = Integer.MAX_VALUE;
+                for (var p : list) {
+                    if (p.equals(pos)) continue;
+                    dist = Math.min(dist, Math.sqrt(Math.pow(pos.getX() - p.getX(), 2) + Math.pow(pos.getZ() - p.getZ(), 2)));
+                }
+                if (dist == Integer.MAX_VALUE) continue;
+                distances.add(Math.round(dist * 16));
+            }
+            long[] array = new long[distances.size()];
+            for (int i = 0; i < distances.size(); i++) {
+                array[i] = distances.get(i);
+            }
+            Arrays.sort(array);
+            long min = array.length > 0 ? array[0] : 0;
+            long max = array.length > 0 ? array[array.length - 1] : 0;
+            long sum = Arrays.stream(array).sum();
+            long avg = array.length > 0 ? Math.round(sum / (double) array.length) : 0;
+            String msg = "%s: %s => min: %s/max: %s -> avg: %s".formatted(key, list.size(), min, max, avg);
+            sender.sendMessage(msg);
+        }
+        if (data.isEmpty()) {
+            sender.sendMessage(C.RED + "No data found!");
+        } else {
+            sender.sendMessage(C.GREEN + "Done!");
+        }
+    }
+
+
+    @Decree(description = "Render a world map (External GUI)", aliases = "render")
+    public void map() {
+        if (noGUI()) return;
+        if (noStudio()) return;
+        VisionGUI.launch(IrisToolbelt.access(player().getWorld()).getEngine(), 0);
+        sender().sendMessage(C.GREEN + "Opening map!");
+    }
+
+    @Decree(description = "Package a dimension into a compressed format", aliases = "package")
+    public void pkg(
+            @Param(name = "dimension", description = "The dimension pack to compress", contextual = true, defaultValue = "default")
+            IrisDimension dimension,
+            @Param(name = "obfuscate", description = "Whether or not to obfuscate the pack", defaultValue = "false")
+            boolean obfuscate,
+            @Param(name = "minify", description = "Whether or not to minify the pack", defaultValue = "true")
+            boolean minify
+    ) {
+        Iris.service(StudioSVC.class).compilePackage(sender(), dimension.getLoadKey(), obfuscate, minify);
+    }
+
+    @Decree(description = "Profiles the performance of a dimension", origin = DecreeOrigin.PLAYER)
+    public void profile(
+            @Param(description = "The dimension to profile", contextual = true, defaultValue = "default")
+            IrisDimension dimension
+    ) {
+        IrisNoiseBenchmark noiseBenchmark = new IrisNoiseBenchmark(dimension, sender());
+        noiseBenchmark.runAll();
+    }
+
+    @Decree(description = "Spawn an Iris entity", aliases = "summon", origin = DecreeOrigin.PLAYER)
+    public void spawn(
+            @Param(description = "The entity to spawn")
+            IrisEntity entity,
+            @Param(description = "The location to spawn the entity at", contextual = true)
+            Vector location
+    ) {
+        if (!IrisToolbelt.isIrisWorld(player().getWorld())) {
+            sender().sendMessage(C.RED + "You have to be in an Iris world to spawn entities properly. Trying to spawn the best we can do.");
+        }
+        entity.spawn(engine(), new Location(world(), location.getX(), location.getY(), location.getZ()));
+    }
+
+    @Decree(description = "Teleport to the active studio world", aliases = "stp", origin = DecreeOrigin.PLAYER, sync = true)
+    public void tpstudio() {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
+            sender().sendMessage(C.RED + "No studio world is open!");
+            return;
+        }
+
+        if (IrisToolbelt.isIrisWorld(world()) && engine().isStudio()) {
+            sender().sendMessage(C.RED + "You are already in a studio world!");
+            return;
+        }
+
+        sender().sendMessage(C.GREEN + "Sending you to the studio world!");
+        player().teleport(Iris.service(StudioSVC.class).getActiveProject().getActiveProvider().getTarget().getWorld().spawnLocation());
+        player().setGameMode(GameMode.SPECTATOR);
+    }
+
+    @Decree(description = "Update your dimension projects VSCode workspace")
+    public void update(
+            @Param(description = "The dimension to update the workspace of", contextual = true, defaultValue = "default")
+            IrisDimension dimension
+    ) {
+        sender().sendMessage(C.GOLD + "Updating Code Workspace for " + dimension.getName() + "...");
+        if (new IrisProject(dimension.getLoader().getDataFolder()).updateWorkspace()) {
+            sender().sendMessage(C.GREEN + "Updated Code Workspace for " + dimension.getName());
+        } else {
+            sender().sendMessage(C.RED + "Invalid project: " + dimension.getName() + ". Try deleting the code-workspace file and try again.");
+        }
+    }
+
+    @Decree(aliases = "find-objects", description = "Get information about nearby structures")
+    public void objects() {
+        if (!IrisToolbelt.isIrisWorld(player().getWorld())) {
+            sender().sendMessage(C.RED + "You must be in an Iris world");
+            return;
+        }
+
+        World world = player().getWorld();
+
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage("You must be in an iris world.");
+            return;
+        }
+        KList<Chunk> chunks = new KList<>();
+        int bx = player().getLocation().getChunk().getX();
+        int bz = player().getLocation().getChunk().getZ();
+
+        try {
+            Location l = player().getTargetBlockExact(48, FluidCollisionMode.NEVER).getLocation();
+
+            int cx = l.getChunk().getX();
+            int cz = l.getChunk().getZ();
+            new Spiraler(3, 3, (x, z) -> chunks.addIfMissing(world.getChunkAt(x + cx, z + cz))).drain();
+        } catch (Throwable e) {
+            Iris.reportError(e);
+        }
+
+        new Spiraler(3, 3, (x, z) -> chunks.addIfMissing(world.getChunkAt(x + bx, z + bz))).drain();
+        sender().sendMessage("Capturing IGenData from " + chunks.size() + " nearby chunks.");
+        try {
+            File ff = Iris.instance.getDataFile("reports/" + M.ms() + ".txt");
+            PrintWriter pw = new PrintWriter(ff);
+            pw.println("=== Iris Chunk Report ===");
+            pw.println("== General Info ==");
+            pw.println("Iris Version: " + Iris.instance.getDescription().getVersion());
+            pw.println("Bukkit Version: " + Bukkit.getBukkitVersion());
+            pw.println("MC Version: " + Bukkit.getVersion());
+            pw.println("PaperSpigot: " + (PaperLib.isPaper() ? "Yup!" : "Nope!"));
+            pw.println("Report Captured At: " + new Date());
+            pw.println("Chunks: (" + chunks.size() + "): ");
+
+            for (Chunk i : chunks) {
+                pw.println("- [" + i.getX() + ", " + i.getZ() + "]");
+            }
+
+            int regions = 0;
+            long size = 0;
+            String age = "No idea...";
+
+            try {
+                for (File i : Objects.requireNonNull(new File(world.getWorldFolder(), "region").listFiles())) {
+                    if (i.isFile()) {
+                        size += i.length();
+                    }
+                }
+            } catch (Throwable e) {
+                Iris.reportError(e);
+            }
+
+            try {
+                FileTime creationTime = (FileTime) Files.getAttribute(world.getWorldFolder().toPath(), "creationTime");
+                age = hrf(Duration.of(M.ms() - creationTime.toMillis(), ChronoUnit.MILLIS));
+            } catch (IOException e) {
+                Iris.reportError(e);
+            }
+
+            KList<String> biomes = new KList<>();
+            KList<String> caveBiomes = new KList<>();
+            KMap<String, KMap<String, KList<String>>> objects = new KMap<>();
+
+            for (Chunk i : chunks) {
+                for (int j = 0; j < 16; j += 3) {
+
+                    for (int k = 0; k < 16; k += 3) {
+
+                        assert engine() != null;
+                        IrisBiome bb = engine().getSurfaceBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
+                        IrisBiome bxf = engine().getCaveBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
+                        biomes.addIfMissing(bb.getName() + " [" + Form.capitalize(bb.getInferredType().name().toLowerCase()) + "] " + " (" + bb.getLoadFile().getName() + ")");
+                        caveBiomes.addIfMissing(bxf.getName() + " (" + bxf.getLoadFile().getName() + ")");
+                        exportObjects(bb, pw, engine(), objects);
+                        exportObjects(bxf, pw, engine(), objects);
+                    }
+                }
+            }
+
+            regions = Objects.requireNonNull(new File(world.getWorldFolder().getPath() + "/region").list()).length;
+
+            pw.println();
+            pw.println("== World Info ==");
+            pw.println("World Name: " + world.getName());
+            pw.println("Age: " + age);
+            pw.println("Folder: " + world.getWorldFolder().getPath());
+            pw.println("Regions: " + Form.f(regions));
+            pw.println("Chunks: max. " + Form.f(regions * 32 * 32));
+            pw.println("World Size: min. " + Form.fileSize(size));
+            pw.println();
+            pw.println("== Biome Info ==");
+            pw.println("Found " + biomes.size() + " Biome(s): ");
+
+            for (String i : biomes) {
+                pw.println("- " + i);
+            }
+            pw.println();
+
+            pw.println("== Object Info ==");
+
+            for (String i : objects.k()) {
+                pw.println("- " + i);
+
+                for (String j : objects.get(i).k()) {
+                    pw.println("  @ " + j);
+
+                    for (String k : objects.get(i).get(j)) {
+                        pw.println("    * " + k);
+                    }
+                }
+            }
+
+            pw.println();
+            pw.close();
+
+            sender().sendMessage("Reported to: " + ff.getPath());
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+            Iris.reportError(e);
+        }
+    }
+
+    private void exportObjects(IrisBiome bb, PrintWriter pw, Engine g, KMap<String, KMap<String, KList<String>>> objects) {
+        String n1 = bb.getName() + " [" + Form.capitalize(bb.getInferredType().name().toLowerCase()) + "] " + " (" + bb.getLoadFile().getName() + ")";
+        int m = 0;
+        KSet<String> stop = new KSet<>();
+        for (IrisObjectPlacement f : bb.getObjects()) {
+            m++;
+            String n2 = "Placement #" + m + " (" + f.getPlace().size() + " possible objects)";
+
+            for (String i : f.getPlace()) {
+                String nn3 = i + ": [ERROR] Failed to find object!";
+
+                try {
+                    if (stop.contains(i)) {
+                        continue;
+                    }
+
+                    File ff = g.getData().getObjectLoader().findFile(i);
+                    BlockVector sz = IrisObject.sampleSize(ff);
+                    nn3 = i + ": size=[" + sz.getBlockX() + "," + sz.getBlockY() + "," + sz.getBlockZ() + "] location=[" + ff.getPath() + "]";
+                    stop.add(i);
+                } catch (Throwable e) {
+                    Iris.reportError(e);
+                }
+
+                String n3 = nn3;
+                objects.computeIfAbsent(n1, (k1) -> new KMap<>())
+                        .computeIfAbsent(n2, (k) -> new KList<>()).addIfMissing(n3);
+            }
+        }
+    }
+
+    /**
+     * @return true if server GUIs are not enabled
+     */
+    private boolean noGUI() {
+        if (!IrisSettings.get().getGui().isUseServerLaunchedGuis()) {
+            sender().sendMessage(C.RED + "You must have server launched GUIs enabled in the settings!");
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @return true if no studio is open or the player is not in one
+     */
+    private boolean noStudio() {
+        if (!sender().isPlayer()) {
+            sender().sendMessage(C.RED + "Players only!");
+            return true;
+        }
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
+            sender().sendMessage(C.RED + "No studio world is open!");
+            return true;
+        }
+        if (!engine().isStudio()) {
+            sender().sendMessage(C.RED + "You must be in a studio world!");
+            return true;
+        }
+        return false;
+    }
+
+
+    public void files(File clean, KList<File> files) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
+                files(i, files);
+            }
+        } else if (clean.getName().endsWith(".json")) {
+            try {
+                files.add(clean);
+            } catch (Throwable e) {
+                Iris.reportError(e);
+                Iris.error("Failed to beautify " + clean.getAbsolutePath() + " You may have errors in your json!");
+            }
+        }
+    }
+
+    private void fixBlocks(JSONObject obj) {
+        for (String i : obj.keySet()) {
+            Object o = obj.get(i);
+
+            if (i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
+                obj.put(i, "minecraft:" + o);
+            }
+
+            if (o instanceof JSONObject) {
+                fixBlocks((JSONObject) o);
+            } else if (o instanceof JSONArray) {
+                fixBlocks((JSONArray) o);
+            }
+        }
+    }
+
+    private void fixBlocks(JSONArray obj) {
+        for (int i = 0; i < obj.length(); i++) {
+            Object o = obj.get(i);
+
+            if (o instanceof JSONObject) {
+                fixBlocks((JSONObject) o);
+            } else if (o instanceof JSONArray) {
+                fixBlocks((JSONArray) o);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.misc.Hastebin;
+
+@Decree(name = "Support", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"support"})
+public class CommandSupport implements DecreeExecutor {
+
+    @Decree(description = "report")
+    public void report() {
+        try {
+            if (sender().isPlayer())
+                sender().sendMessage(C.GOLD + "Creating report..");
+            if (!sender().isPlayer()) Iris.info(C.GOLD + "Creating report..");
+            Hastebin.enviornment(sender());
+
+        } catch (Exception e) {
+            Iris.info(C.RED + "Something went wrong: ");
+            e.printStackTrace();
+        }
+    }
+
+
+}
+
+

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

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

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

@@ -0,0 +1,106 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.ChunkUpdater;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import org.bukkit.World;
+
+@Decree(name = "updater", origin = DecreeOrigin.BOTH, description = "Iris World Updater")
+public class CommandUpdater implements DecreeExecutor {
+    private ChunkUpdater chunkUpdater;
+
+    @Decree(description = "Updates all chunk in the specified world")
+    public void start(
+            @Param(description = "World to update chunks at", contextual = true)
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        chunkUpdater = new ChunkUpdater(world);
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "Updating " + world.getName() + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
+        } else {
+            Iris.info(C.GREEN + "Updating " + world.getName() + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
+        }
+        chunkUpdater.start();
+    }
+
+    @Decree(description = "Pause the updater")
+    public void pause(
+            @Param(description = "World to pause the Updater at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        if (chunkUpdater == null) {
+            sender().sendMessage(C.GOLD + "You cant pause something that doesnt exist?");
+            return;
+        }
+        boolean status = chunkUpdater.pause();
+        if (sender().isPlayer()) {
+            if (status) {
+                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
+            } else {
+                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
+            }
+        } else {
+            if (status) {
+                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
+            } else {
+                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
+            }
+        }
+    }
+
+    @Decree(description = "Stops the updater")
+    public void stop(
+            @Param(description = "World to stop the Updater at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        if (chunkUpdater == null) {
+            sender().sendMessage(C.GOLD + "You cant stop something that doesnt exist?");
+            return;
+        }
+        if (sender().isPlayer()) {
+            sender().sendMessage("Stopping Updater for: " + C.GRAY + world.getName());
+        } else {
+            Iris.info("Stopping Updater for: " + C.GRAY + world.getName());
+        }
+        chunkUpdater.stop();
+    }
+
+}
+
+

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

@@ -0,0 +1,166 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.edit.BlockSignal;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisRegion;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.matter.MatterMarker;
+import com.volmit.iris.util.scheduling.J;
+import org.bukkit.Chunk;
+import org.bukkit.FluidCollisionMode;
+import org.bukkit.Material;
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Decree(name = "what", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris What?")
+public class CommandWhat implements DecreeExecutor {
+    @Decree(description = "What is in my hand?", origin = DecreeOrigin.PLAYER)
+    public void hand() {
+        try {
+            BlockData bd = player().getInventory().getItemInMainHand().getType().createBlockData();
+            if (!bd.getMaterial().equals(Material.AIR)) {
+                sender().sendMessage("Material: " + C.GREEN + bd.getMaterial().name());
+                sender().sendMessage("Full: " + C.WHITE + bd.getAsString(true));
+            } else {
+                sender().sendMessage("Please hold a block/item");
+            }
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Material bd = player().getInventory().getItemInMainHand().getType();
+            if (!bd.equals(Material.AIR)) {
+                sender().sendMessage("Material: " + C.GREEN + bd.name());
+            } else {
+                sender().sendMessage("Please hold a block/item");
+            }
+        }
+    }
+
+    @Decree(description = "What biome am i in?", origin = DecreeOrigin.PLAYER)
+    public void biome() {
+        try {
+            IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY() - player().getWorld().getMinHeight(), player().getLocation().getBlockZ());
+            sender().sendMessage("IBiome: " + b.getLoadKey() + " (" + b.getDerivative().name() + ")");
+
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage("Non-Iris Biome: " + player().getLocation().getBlock().getBiome().name());
+
+            if (player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
+                try {
+                    sender().sendMessage("Data Pack Biome: " + INMS.get().getTrueBiomeBaseKey(player().getLocation()) + " (ID: " + INMS.get().getTrueBiomeBaseId(INMS.get().getTrueBiomeBase(player().getLocation())) + ")");
+                } catch (Throwable ee) {
+                    Iris.reportError(ee);
+                }
+            }
+        }
+    }
+
+    @Decree(description = "What region am i in?", origin = DecreeOrigin.PLAYER)
+    public void region() {
+        try {
+            IrisRegion r = engine().getRegion(player().getLocation());
+            sender().sendMessage("IRegion: " + r.getLoadKey() + " (" + r.getName() + ")");
+
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.IRIS + "Iris worlds only.");
+        }
+    }
+
+    @Decree(description = "What block am i looking at?", origin = DecreeOrigin.PLAYER)
+    public void block() {
+        BlockData bd;
+        try {
+            bd = player().getTargetBlockExact(128, FluidCollisionMode.NEVER).getBlockData();
+        } catch (NullPointerException e) {
+            Iris.reportError(e);
+            sender().sendMessage("Please look at any block, not at the sky");
+            bd = null;
+        }
+
+        if (bd != null) {
+            sender().sendMessage("Material: " + C.GREEN + bd.getMaterial().name());
+            sender().sendMessage("Full: " + C.WHITE + bd.getAsString(true));
+
+            if (B.isStorage(bd)) {
+                sender().sendMessage(C.YELLOW + "* Storage Block (Loot Capable)");
+            }
+
+            if (B.isLit(bd)) {
+                sender().sendMessage(C.YELLOW + "* Lit Block (Light Capable)");
+            }
+
+            if (B.isFoliage(bd)) {
+                sender().sendMessage(C.YELLOW + "* Foliage Block");
+            }
+
+            if (B.isDecorant(bd)) {
+                sender().sendMessage(C.YELLOW + "* Decorant Block");
+            }
+
+            if (B.isFluid(bd)) {
+                sender().sendMessage(C.YELLOW + "* Fluid Block");
+            }
+
+            if (B.isFoliagePlantable(bd)) {
+                sender().sendMessage(C.YELLOW + "* Plantable Foliage Block");
+            }
+
+            if (B.isSolid(bd)) {
+                sender().sendMessage(C.YELLOW + "* Solid Block");
+            }
+        }
+    }
+
+    @Decree(description = "Show markers in chunk", origin = DecreeOrigin.PLAYER)
+    public void markers(@Param(description = "Marker name such as cave_floor or cave_ceiling") String marker) {
+        Chunk c = player().getLocation().getChunk();
+
+        if (IrisToolbelt.isIrisWorld(c.getWorld())) {
+            int m = 1;
+            AtomicInteger v = new AtomicInteger(0);
+
+            for (int xxx = c.getX() - 4; xxx <= c.getX() + 4; xxx++) {
+                for (int zzz = c.getZ() - 4; zzz <= c.getZ() + 4; zzz++) {
+                    IrisToolbelt.access(c.getWorld()).getEngine().getMantle().findMarkers(xxx, zzz, new MatterMarker(marker))
+                            .convert((i) -> i.toLocation(c.getWorld())).forEach((i) -> {
+                                J.s(() -> BlockSignal.of(i.getBlock(), 100));
+                                v.incrementAndGet();
+                            });
+                }
+            }
+
+            sender().sendMessage("Found " + v.get() + " Nearby Markers (" + marker + ")");
+        } else {
+            sender().sendMessage(C.IRIS + "Iris worlds only.");
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.edit;
+
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
+
+import java.io.Closeable;
+
+public interface BlockEditor extends Closeable {
+    long last();
+
+    void set(int x, int y, int z, BlockData d);
+
+    BlockData get(int x, int y, int z);
+
+    void setBiome(int x, int z, Biome b);
+
+    void setBiome(int x, int y, int z, Biome b);
+
+    @Override
+    void close();
+
+    Biome getBiome(int x, int y, int z);
+
+    Biome getBiome(int x, int z);
+}

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

@@ -0,0 +1,107 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.edit;
+
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.SR;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@SuppressWarnings("InstantiationOfUtilityClass")
+public class BlockSignal {
+    public static final AtomicInteger active = new AtomicInteger(0);
+
+    public BlockSignal(Block block, int ticks) {
+        active.incrementAndGet();
+        Location tg = block.getLocation().clone().add(0.5, 0, 0.5);
+        FallingBlock e = block.getWorld().spawnFallingBlock(tg, block.getBlockData());
+        e.setGravity(false);
+        e.setInvulnerable(true);
+        e.setGlowing(true);
+        e.setDropItem(false);
+        e.setHurtEntities(false);
+        e.setSilent(true);
+        e.setTicksLived(1);
+        e.setVelocity(new Vector(0, 0, 0));
+        J.s(() -> {
+            e.remove();
+            active.decrementAndGet();
+            BlockData type = block.getBlockData();
+            MultiBurst.burst.lazy(() -> {
+                for (Player i : block.getWorld().getPlayers()) {
+                    i.sendBlockChange(block.getLocation(), block.getBlockData());
+                }
+            });
+        }, ticks);
+    }
+
+    public static void of(Block block, int ticks) {
+        new BlockSignal(block, ticks);
+    }
+
+    public static void of(Block block) {
+        of(block, 100);
+    }
+
+    public static Runnable forever(Block block) {
+        Location tg = block.getLocation().clone().add(0.5, 0, 0.5).clone();
+        FallingBlock e = block.getWorld().spawnFallingBlock(tg.clone(), block.getBlockData());
+        e.setGravity(false);
+        e.setInvulnerable(true);
+        e.setGlowing(true);
+        e.teleport(tg.clone());
+        e.setDropItem(false);
+        e.setHurtEntities(false);
+        e.setSilent(true);
+        e.setTicksLived(1);
+        e.setVelocity(new Vector(0, 0, 0));
+
+        new SR(20) {
+            @Override
+            public void run() {
+                if (e.isDead()) {
+                    cancel();
+                    return;
+                }
+
+                e.setTicksLived(1);
+                e.teleport(tg.clone());
+                e.setVelocity(new Vector(0, 0, 0));
+            }
+        };
+
+        return () -> {
+            e.remove();
+            BlockData type = block.getBlockData();
+
+            MultiBurst.burst.lazy(() -> {
+                for (Player i : block.getWorld().getPlayers()) {
+                    i.sendBlockChange(block.getLocation(), block.getBlockData());
+                }
+            });
+        };
+    }
+}

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

@@ -0,0 +1,75 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.edit;
+
+import com.volmit.iris.util.math.M;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
+
+@SuppressWarnings("ClassCanBeRecord")
+public class BukkitBlockEditor implements BlockEditor {
+    private final World world;
+
+    public BukkitBlockEditor(World world) {
+        this.world = world;
+    }
+
+    @Override
+    public void set(int x, int y, int z, BlockData d) {
+        world.getBlockAt(x, y, z).setBlockData(d, false);
+    }
+
+    @Override
+    public BlockData get(int x, int y, int z) {
+        return world.getBlockAt(x, y, z).getBlockData();
+    }
+
+    @Override
+    public void close() {
+
+    }
+
+    @Override
+    public long last() {
+        return M.ms();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public void setBiome(int x, int z, Biome b) {
+        world.setBiome(x, z, b);
+    }
+
+    @Override
+    public void setBiome(int x, int y, int z, Biome b) {
+        world.setBiome(x, y, z, b);
+    }
+
+    @Override
+    public Biome getBiome(int x, int y, int z) {
+        return world.getBiome(x, y, z);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public Biome getBiome(int x, int z) {
+        return world.getBiome(x, z);
+    }
+}

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

@@ -0,0 +1,127 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.edit;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.math.BlockPosition;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.J;
+import lombok.Data;
+import org.bukkit.Sound;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+
+@SuppressWarnings("ALL")
+@Data
+public class DustRevealer {
+    private final Engine engine;
+    private final World world;
+    private final BlockPosition block;
+    private final String key;
+    private final KList<BlockPosition> hits;
+
+    public DustRevealer(Engine engine, World world, BlockPosition block, String key, KList<BlockPosition> hits) {
+        this.engine = engine;
+        this.world = world;
+        this.block = block;
+        this.key = key;
+        this.hits = hits;
+
+        J.s(() -> {
+            new BlockSignal(world.getBlockAt(block.getX(), block.getY(), block.getZ()), 10);
+            if (M.r(0.25)) {
+                world.playSound(block.toBlock(world).getLocation(), Sound.BLOCK_AMETHYST_BLOCK_CHIME, 1f, RNG.r.f(0.2f, 2f));
+            }
+            J.a(() -> {
+                while (BlockSignal.active.get() > 128) {
+                    J.sleep(5);
+                }
+
+                try {
+                    is(new BlockPosition(block.getX() + 1, block.getY(), block.getZ()));
+                    is(new BlockPosition(block.getX() - 1, block.getY(), block.getZ()));
+                    is(new BlockPosition(block.getX(), block.getY() + 1, block.getZ()));
+                    is(new BlockPosition(block.getX(), block.getY() - 1, block.getZ()));
+                    is(new BlockPosition(block.getX(), block.getY(), block.getZ() + 1));
+                    is(new BlockPosition(block.getX(), block.getY(), block.getZ() - 1));
+                    is(new BlockPosition(block.getX() + 1, block.getY(), block.getZ() + 1));
+                    is(new BlockPosition(block.getX() + 1, block.getY(), block.getZ() - 1));
+                    is(new BlockPosition(block.getX() - 1, block.getY(), block.getZ() + 1));
+                    is(new BlockPosition(block.getX() - 1, block.getY(), block.getZ() - 1));
+                    is(new BlockPosition(block.getX() + 1, block.getY() + 1, block.getZ()));
+                    is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ()));
+                    is(new BlockPosition(block.getX() - 1, block.getY() + 1, block.getZ()));
+                    is(new BlockPosition(block.getX() - 1, block.getY() - 1, block.getZ()));
+                    is(new BlockPosition(block.getX(), block.getY() + 1, block.getZ() - 1));
+                    is(new BlockPosition(block.getX(), block.getY() + 1, block.getZ() + 1));
+                    is(new BlockPosition(block.getX(), block.getY() - 1, block.getZ() - 1));
+                    is(new BlockPosition(block.getX(), block.getY() - 1, block.getZ() + 1));
+                    is(new BlockPosition(block.getX() - 1, block.getY() + 1, block.getZ() - 1));
+                    is(new BlockPosition(block.getX() - 1, block.getY() + 1, block.getZ() + 1));
+                    is(new BlockPosition(block.getX() - 1, block.getY() - 1, block.getZ() - 1));
+                    is(new BlockPosition(block.getX() - 1, block.getY() - 1, block.getZ() + 1));
+                    is(new BlockPosition(block.getX() + 1, block.getY() + 1, block.getZ() - 1));
+                    is(new BlockPosition(block.getX() + 1, block.getY() + 1, block.getZ() + 1));
+                    is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ() - 1));
+                    is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ() + 1));
+                } catch (Throwable e) {
+                    Iris.reportError(e);
+                    e.printStackTrace();
+                }
+            });
+        }, RNG.r.i(2, 8));
+    }
+
+    public static void spawn(Block block, VolmitSender sender) {
+        World world = block.getWorld();
+        Engine access = IrisToolbelt.access(world).getEngine();
+
+        if (access != null) {
+            String a = access.getObjectPlacementKey(block.getX(), block.getY() - block.getWorld().getMinHeight(), block.getZ());
+            if (a != null) {
+                world.playSound(block.getLocation(), Sound.ITEM_LODESTONE_COMPASS_LOCK, 1f, 0.1f);
+
+                sender.sendMessage("Found object " + a);
+                J.a(() -> {
+                    new DustRevealer(access, world, new BlockPosition(block.getX(), block.getY(), block.getZ()), a, new KList<>());
+                });
+            }
+        }
+    }
+
+    private boolean is(BlockPosition a) {
+        int betterY = a.getY() - world.getMinHeight();
+        if (isValidTry(a) && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()) != null && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()).equals(key)) {
+            hits.add(a);
+            new DustRevealer(engine, world, a, key, hits);
+            return true;
+        }
+
+        return false;
+    }
+
+    private boolean isValidTry(BlockPosition b) {
+        return !hits.contains(b);
+    }
+}

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

@@ -0,0 +1,253 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.edit;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.service.WandSVC;
+import com.volmit.iris.engine.object.*;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.Cuboid;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+public class JigsawEditor implements Listener {
+    public static final KMap<Player, JigsawEditor> editors = new KMap<>();
+    private final Player player;
+    private final IrisObject object;
+    private final File targetSaveLocation;
+    private final IrisJigsawPiece piece;
+    private final Location origin;
+    private final Cuboid cuboid;
+    private final int ticker;
+    private final KMap<IrisPosition, Runnable> falling = new KMap<>();
+    private final ChronoLatch cl = new ChronoLatch(100);
+    private Location target;
+
+    public JigsawEditor(Player player, IrisJigsawPiece piece, IrisObject object, File saveLocation) {
+        if (editors.containsKey(player)) {
+            editors.get(player).close();
+        }
+
+        editors.put(player, this);
+        if (object == null) {
+            throw new RuntimeException("Object is null! " + piece.getObject());
+        }
+        this.object = object;
+        this.player = player;
+        origin = player.getLocation().clone().add(0, 7, 0);
+        target = origin;
+        this.targetSaveLocation = saveLocation;
+        this.piece = piece == null ? new IrisJigsawPiece() : piece;
+        this.piece.setObject(object.getLoadKey());
+        cuboid = new Cuboid(origin.clone(), origin.clone().add(object.getW() - 1, object.getH() - 1, object.getD() - 1));
+        ticker = J.sr(this::onTick, 0);
+        J.s(() -> object.placeCenterY(origin));
+        Iris.instance.registerListener(this);
+    }
+
+    @EventHandler
+    public void on(PlayerMoveEvent e) {
+        if (e.getPlayer().equals(player)) {
+            try {
+                target = player.getTargetBlockExact(7).getLocation();
+            } catch (Throwable ex) {
+                Iris.reportError(ex);
+                target = player.getLocation();
+                return;
+            }
+
+            if (cuboid.contains(target)) {
+                for (IrisPosition i : falling.k()) {
+                    Location at = toLocation(i);
+
+                    if (at.equals(target)) {
+                        falling.remove(i).run();
+                    }
+                }
+            }
+        }
+    }
+
+    public Location toLocation(IrisPosition i) {
+        return origin.clone()
+                .add(new Vector(i.getX(), i.getY(), i.getZ()))
+                .add(object.getCenter())
+                .getBlock()
+                .getLocation();
+    }
+
+    public IrisPosition toPosition(Location l) {
+        return new IrisPosition(l.clone().getBlock().getLocation()
+                .subtract(origin.clone())
+                .subtract(object.getCenter())
+                .add(1, 1, 1)
+                .toVector());
+    }
+
+    @EventHandler
+    public void on(PlayerInteractEvent e) {
+        if (e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
+            if (e.getClickedBlock() != null && cuboid.contains(e.getClickedBlock().getLocation()) && e.getPlayer().equals(player)) {
+                IrisPosition pos = toPosition(e.getClickedBlock().getLocation());
+                IrisJigsawPieceConnector connector = null;
+                for (IrisJigsawPieceConnector i : piece.getConnectors()) {
+                    if (i.getPosition().equals(pos)) {
+                        connector = i;
+                        break;
+                    }
+                }
+
+                if (!player.isSneaking() && connector == null) {
+                    connector = new IrisJigsawPieceConnector();
+                    connector.setDirection(IrisDirection.getDirection(e.getBlockFace()));
+                    connector.setPosition(pos);
+                    piece.getConnectors().add(connector);
+                    player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_ADD_ITEM, 1f, 1f);
+                } else if (player.isSneaking() && connector != null) {
+                    piece.getConnectors().remove(connector);
+                    player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_REMOVE_ITEM, 1f, 1f);
+                } else if (connector != null && !player.isSneaking()) {
+                    connector.setDirection(IrisDirection.getDirection(e.getBlockFace()));
+                    player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 1f);
+                }
+            }
+        }
+    }
+
+    private void removeKey(JSONObject o, String... path) {
+        if (path.length == 1) {
+            o.remove(path[0]);
+            return;
+        }
+
+        List<String> s = new java.util.ArrayList<>(List.of(path));
+        s.remove(0);
+        removeKey(o.getJSONObject(path[0]), s.toArray(new String[0]));
+    }
+
+    private List<JSONObject> getObjectsInArray(JSONObject a) { // This gets all the objects in an array that are connectors
+        KList<JSONObject> o = new KList<>();
+
+        for (int i = 0; i < a.getJSONArray("connectors").length(); i++) {
+            o.add(a.getJSONArray("connectors").getJSONObject(i));
+        }
+
+        return o;
+    }
+
+    public void close() {
+        exit();
+        try {
+            JSONObject j = new JSONObject(new Gson().toJson(piece));
+            // Remove sub-key
+            removeKey(j, "placementOptions", "translateCenter"); // should work
+            J.attempt(() -> j.getJSONObject("placementOptions").remove("translateCenter")); // otherwise
+
+            // remove root key
+            removeKey(j, "placementOptions"); // should work
+            j.remove("placementOptions"); // otherwise
+
+            // Remove key in all objects in array
+            for (JSONObject i : getObjectsInArray(j)) {
+                removeKey(i, "rotateConnector");
+            }
+
+            IO.writeAll(targetSaveLocation, j.toString(4));
+        } catch (IOException e) {
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+    }
+
+    public void exit() {
+        J.car(ticker);
+        Iris.instance.unregisterListener(this);
+        try {
+            J.sfut(() -> {
+                object.unplaceCenterY(origin);
+                falling.v().forEach(Runnable::run);
+            }).get();
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+        }
+        editors.remove(player);
+    }
+
+    public void onTick() {
+        if (cl.flip()) {
+            Iris.service(WandSVC.class).draw(cuboid, player);
+
+            f:
+            for (IrisPosition i : falling.k()) {
+                for (IrisJigsawPieceConnector j : piece.getConnectors()) {
+                    if (j.getPosition().equals(i)) {
+                        continue f;
+                    }
+                }
+
+                falling.remove(i).run();
+            }
+
+            for (IrisJigsawPieceConnector i : piece.getConnectors()) {
+                IrisPosition pos = i.getPosition();
+                Location at = toLocation(pos);
+
+                Vector dir = i.getDirection().toVector().clone();
+
+
+                for (int ix = 0; ix < RNG.r.i(1, 3); ix++) {
+                    at.getWorld().spawnParticle(Particle.SOUL_FIRE_FLAME, at.clone().getBlock().getLocation().add(0.25, 0.25, 0.25).add(RNG.r.d(0.5), RNG.r.d(0.5), RNG.r.d(0.5)), 0, dir.getX(), dir.getY(), dir.getZ(), 0.092 + RNG.r.d(-0.03, 0.08));
+                }
+
+                if (at.getBlock().getLocation().equals(target)) {
+                    continue;
+                }
+
+                if (!falling.containsKey(pos)) {
+                    if (at.getBlock().getType().isAir()) {
+                        at.getBlock().setType(Material.STONE);
+                    }
+
+                    falling.put(pos, BlockSignal.forever(at.getBlock()));
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.events;
+
+import com.volmit.iris.engine.framework.Engine;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+@AllArgsConstructor
+public class IrisEngineEvent extends Event {
+    private static final HandlerList handlers = new HandlerList();
+    private Engine engine;
+
+    public IrisEngineEvent() {
+        super(true);
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+}

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

@@ -0,0 +1,39 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.events;
+
+import com.volmit.iris.engine.framework.Engine;
+import org.bukkit.event.HandlerList;
+
+public class IrisEngineHotloadEvent extends IrisEngineEvent {
+    private static final HandlerList handlers = new HandlerList();
+
+    public IrisEngineHotloadEvent(Engine engine) {
+        super(engine);
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+}

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

@@ -0,0 +1,338 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.events.IrisEngineHotloadEvent;
+import com.volmit.iris.engine.object.NoiseStyle;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.function.Function2;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.math.RollingSequence;
+import com.volmit.iris.util.noise.CNG;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Supplier;
+
+public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, Listener {
+
+    private static final long serialVersionUID = 2094606939770332040L;
+
+    static JComboBox<String> combo;
+    @SuppressWarnings("CanBeFinal")
+    static boolean hd = false;
+    static double ascale = 10;
+    static double oxp = 0;
+    static double ozp = 0;
+    static double mxx = 0;
+    static double mzz = 0;
+    @SuppressWarnings("CanBeFinal")
+    static boolean down = false;
+    @SuppressWarnings("CanBeFinal")
+    RollingSequence r = new RollingSequence(20);
+    @SuppressWarnings("CanBeFinal")
+    boolean colorMode = IrisSettings.get().getGui().colorMode;
+    double scale = 1;
+    CNG cng = NoiseStyle.STATIC.create(new RNG(RNG.r.nextLong()));
+    @SuppressWarnings("CanBeFinal")
+    MultiBurst gx = MultiBurst.burst;
+    ReentrantLock l = new ReentrantLock();
+    BufferedImage img;
+    int w = 0;
+    int h = 0;
+    Function2<Double, Double, Double> generator;
+    Supplier<Function2<Double, Double, Double>> loader;
+    double ox = 0; //Offset X
+    double oz = 0; //Offset Y
+    double mx = 0;
+    double mz = 0;
+    double lx = Double.MAX_VALUE; //MouseX
+    double lz = Double.MAX_VALUE; //MouseY
+    double t;
+    double tz;
+
+    public NoiseExplorerGUI() {
+        Iris.instance.registerListener(this);
+        addMouseWheelListener(this);
+        addMouseMotionListener(new MouseMotionListener() {
+            @Override
+            public void mouseMoved(MouseEvent e) {
+                Point cp = e.getPoint();
+
+                lx = (cp.getX());
+                lz = (cp.getY());
+                mx = lx;
+                mz = lz;
+            }
+
+            @Override
+            public void mouseDragged(MouseEvent e) {
+                Point cp = e.getPoint();
+                ox += (lx - cp.getX()) * scale;
+                oz += (lz - cp.getY()) * scale;
+                lx = cp.getX();
+                lz = cp.getY();
+            }
+        });
+    }
+
+    private static void createAndShowGUI(Supplier<Function2<Double, Double, Double>> loader, String genName) {
+        JFrame frame = new JFrame("Noise Explorer: " + genName);
+        NoiseExplorerGUI nv = new NoiseExplorerGUI();
+        frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+        JLayeredPane pane = new JLayeredPane();
+        nv.setSize(new Dimension(1440, 820));
+        pane.add(nv, 1, 0);
+        nv.loader = loader;
+        nv.generator = loader.get();
+        frame.add(pane);
+        File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
+
+        if (file != null) {
+            try {
+                frame.setIconImage(ImageIO.read(file));
+            } catch (IOException e) {
+                Iris.reportError(e);
+            }
+        }
+        frame.setSize(1440, 820);
+        frame.setVisible(true);
+    }
+
+    private static void createAndShowGUI() {
+        JFrame frame = new JFrame("Noise Explorer");
+        NoiseExplorerGUI nv = new NoiseExplorerGUI();
+        frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+        KList<String> li = new KList<>(NoiseStyle.values()).toStringList().sort();
+        combo = new JComboBox<>(li.toArray(new String[0]));
+        combo.setSelectedItem("STATIC");
+        combo.setFocusable(false);
+        combo.addActionListener(e -> {
+            @SuppressWarnings("unchecked")
+            String b = (String) (((JComboBox<String>) e.getSource()).getSelectedItem());
+            NoiseStyle s = NoiseStyle.valueOf(b);
+            nv.cng = s.create(RNG.r.nextParallelRNG(RNG.r.imax()));
+        });
+
+        combo.setSize(500, 30);
+        JLayeredPane pane = new JLayeredPane();
+        nv.setSize(new Dimension(1440, 820));
+        pane.add(nv, 1, 0);
+        pane.add(combo, 2, 0);
+        frame.add(pane);
+        File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
+
+        if (file != null) {
+            try {
+                frame.setIconImage(ImageIO.read(file));
+            } catch (IOException e) {
+                Iris.reportError(e);
+            }
+        }
+        frame.setSize(1440, 820);
+        frame.setVisible(true);
+        frame.addWindowListener(new java.awt.event.WindowAdapter() {
+            @Override
+            public void windowClosing(java.awt.event.WindowEvent windowEvent) {
+                Iris.instance.unregisterListener(nv);
+            }
+        });
+    }
+
+    public static void launch(Supplier<Function2<Double, Double, Double>> gen, String genName) {
+        EventQueue.invokeLater(() -> createAndShowGUI(gen, genName));
+    }
+
+    public static void launch() {
+        EventQueue.invokeLater(NoiseExplorerGUI::createAndShowGUI);
+    }
+
+    @EventHandler
+    public void on(IrisEngineHotloadEvent e) {
+        if (generator != null)
+            generator = loader.get();
+    }
+
+    public void mouseWheelMoved(MouseWheelEvent e) {
+
+        int notches = e.getWheelRotation();
+        if (e.isControlDown()) {
+            t = t + ((0.0025 * t) * notches);
+            return;
+        }
+
+        scale = scale + ((0.044 * scale) * notches);
+        scale = Math.max(scale, 0.00001);
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        if (scale < ascale) {
+            ascale -= Math.abs(scale - ascale) * 0.16;
+        }
+
+        if (scale > ascale) {
+            ascale += Math.abs(ascale - scale) * 0.16;
+        }
+
+        if (t < tz) {
+            tz -= Math.abs(t - tz) * 0.29;
+        }
+
+        if (t > tz) {
+            tz += Math.abs(tz - t) * 0.29;
+        }
+
+        if (ox < oxp) {
+            oxp -= Math.abs(ox - oxp) * 0.16;
+        }
+
+        if (ox > oxp) {
+            oxp += Math.abs(oxp - ox) * 0.16;
+        }
+
+        if (oz < ozp) {
+            ozp -= Math.abs(oz - ozp) * 0.16;
+        }
+
+        if (oz > ozp) {
+            ozp += Math.abs(ozp - oz) * 0.16;
+        }
+
+        if (mx < mxx) {
+            mxx -= Math.abs(mx - mxx) * 0.16;
+        }
+
+        if (mx > mxx) {
+            mxx += Math.abs(mxx - mx) * 0.16;
+        }
+
+        if (mz < mzz) {
+            mzz -= Math.abs(mz - mzz) * 0.16;
+        }
+
+        if (mz > mzz) {
+            mzz += Math.abs(mzz - mz) * 0.16;
+        }
+
+        PrecisionStopwatch p = PrecisionStopwatch.start();
+        int accuracy = hd ? 1 : M.clip((r.getAverage() / 12D), 2D, 128D).intValue();
+        accuracy = down ? accuracy * 4 : accuracy;
+        int v = 1000;
+
+        if (g instanceof Graphics2D gg) {
+
+            if (getParent().getWidth() != w || getParent().getHeight() != h) {
+                w = getParent().getWidth();
+                h = getParent().getHeight();
+                img = null;
+            }
+
+            if (img == null) {
+                img = new BufferedImage(w / accuracy, h / accuracy, BufferedImage.TYPE_INT_RGB);
+            }
+
+            BurstExecutor e = gx.burst(w);
+
+            for (int x = 0; x < w / accuracy; x++) {
+                int xx = x;
+
+                int finalAccuracy = accuracy;
+                e.queue(() -> {
+                    for (int z = 0; z < h / finalAccuracy; z++) {
+                        double n = generator != null ? generator.apply(((xx * finalAccuracy) * ascale) + oxp, ((z * finalAccuracy) * ascale) + ozp) : cng.noise(((xx * finalAccuracy) * ascale) + oxp, ((z * finalAccuracy) * ascale) + ozp);
+                        n = n > 1 ? 1 : n < 0 ? 0 : n;
+
+                        try {
+                            //Color color = colorMode ? Color.getHSBColor((float) (n), 1f - (float) (n * n * n * n * n * n), 1f - (float) n) : Color.getHSBColor(0f, 0f, (float) n);
+                            //Color color = colorMode ? Color.getHSBColor((float) (n), (float) (n * n * n * n * n * n), (float) n) : Color.getHSBColor(0f, 0f, (float) n);
+                            Color color = colorMode ? Color.getHSBColor((float) n, (float) (n * n * n * n * n * n), (float) n) : Color.getHSBColor(0f, 0f, (float) n);
+
+                            int rgb = color.getRGB();
+                            img.setRGB(xx, z, rgb);
+                        } catch (Throwable ignored) {
+                        }
+                    }
+                });
+            }
+
+            e.complete();
+            gg.drawImage(img, 0, 0, getParent().getWidth() * accuracy, getParent().getHeight() * accuracy, (img, infoflags, x, y, width, height) -> true);
+        }
+
+        p.end();
+
+        t += 1D;
+        r.put(p.getMilliseconds());
+
+        if (!isVisible()) {
+            return;
+        }
+
+        if (!getParent().isVisible()) {
+            return;
+        }
+
+        if (!getParent().getParent().isVisible()) {
+            return;
+        }
+
+        EventQueue.invokeLater(() ->
+        {
+            J.sleep((long) Math.max(0, 32 - r.getAverage()));
+            repaint();
+        });
+    }
+
+    static class HandScrollListener extends MouseAdapter {
+        private static final Point pp = new Point();
+
+        @Override
+        public void mouseDragged(MouseEvent e) {
+            JViewport vport = (JViewport) e.getSource();
+            JComponent label = (JComponent) vport.getView();
+            Point cp = e.getPoint();
+            Point vp = vport.getViewPosition();
+            vp.translate(pp.x - cp.x, pp.y - cp.y);
+            label.scrollRectToVisible(new Rectangle(vp, vport.getSize()));
+
+            pp.setLocation(cp);
+        }
+
+        @Override
+        public void mousePressed(MouseEvent e) {
+            pp.setLocation(e.getPoint());
+        }
+    }
+}

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

@@ -0,0 +1,458 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.pregenerator.IrisPregenerator;
+import com.volmit.iris.core.pregenerator.PregenListener;
+import com.volmit.iris.core.pregenerator.PregenTask;
+import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.format.MemoryMonitor;
+import com.volmit.iris.util.function.Consumer2;
+import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.awt.image.BufferedImage;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Consumer;
+
+public class PregeneratorJob implements PregenListener {
+    private static final Color COLOR_EXISTS = parseColor("#4d7d5b");
+    private static final Color COLOR_BLACK = parseColor("#4d7d5b");
+    private static final Color COLOR_MANTLE = parseColor("#3c2773");
+    private static final Color COLOR_GENERATING = parseColor("#66967f");
+    private static final Color COLOR_NETWORK = parseColor("#a863c2");
+    private static final Color COLOR_NETWORK_GENERATING = parseColor("#836b8c");
+    private static final Color COLOR_GENERATED = parseColor("#65c295");
+    private static final Color COLOR_CLEANED = parseColor("#34eb93");
+    public static PregeneratorJob instance;
+    private final MemoryMonitor monitor;
+    private final PregenTask task;
+    private final boolean saving;
+    private final KList<Consumer<Double>> onProgress = new KList<>();
+    private final KList<Runnable> whenDone = new KList<>();
+    private final IrisPregenerator pregenerator;
+    private final Position2 min;
+    private final Position2 max;
+    private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
+    private final Engine engine;
+    private JFrame frame;
+    private PregenRenderer renderer;
+    private int rgc = 0;
+    private String[] info;
+
+    public PregeneratorJob(PregenTask task, PregeneratorMethod method, Engine engine) {
+        this.engine = engine;
+        instance = this;
+        monitor = new MemoryMonitor(50);
+        saving = false;
+        info = new String[]{"Initializing..."};
+        this.task = task;
+        this.pregenerator = new IrisPregenerator(task, method, this);
+        max = new Position2(0, 0);
+        min = new Position2(0, 0);
+        task.iterateRegions((xx, zz) -> {
+            min.setX(Math.min(xx << 5, min.getX()));
+            min.setZ(Math.min(zz << 5, min.getZ()));
+            max.setX(Math.max((xx << 5) + 31, max.getX()));
+            max.setZ(Math.max((zz << 5) + 31, max.getZ()));
+        });
+
+        if (IrisSettings.get().getGui().isUseServerLaunchedGuis() && task.isGui()) {
+            open();
+        }
+
+        var t = new Thread(() -> {
+            J.sleep(1000);
+            this.pregenerator.start();
+        }, "Iris Pregenerator");
+        t.setPriority(Thread.MIN_PRIORITY);
+        t.start();
+    }
+
+
+    public static boolean shutdownInstance() {
+        if (instance == null) {
+            return false;
+        }
+
+        J.a(() -> instance.pregenerator.close());
+        return true;
+    }
+
+    public static PregeneratorJob getInstance() {
+        return instance;
+    }
+
+    public static boolean pauseResume() {
+        if (instance == null) {
+            return false;
+        }
+
+        if (isPaused()) {
+            instance.pregenerator.resume();
+        } else {
+            instance.pregenerator.pause();
+        }
+        return true;
+    }
+
+    public static boolean isPaused() {
+        if (instance == null) {
+            return true;
+        }
+
+        return instance.paused();
+    }
+
+    private static Color parseColor(String c) {
+        String v = (c.startsWith("#") ? c : "#" + c).trim();
+        try {
+            return Color.decode(v);
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.error("Error Parsing 'color', (" + c + ")");
+        }
+
+        return Color.RED;
+    }
+
+    public Mantle getMantle() {
+        return pregenerator.getMantle();
+    }
+
+    public PregeneratorJob onProgress(Consumer<Double> c) {
+        onProgress.add(c);
+        return this;
+    }
+
+    public PregeneratorJob whenDone(Runnable r) {
+        whenDone.add(r);
+        return this;
+    }
+
+    public void drawRegion(int x, int z, Color color) {
+        J.a(() -> PregenTask.iterateRegion(x, z, (xx, zz) -> {
+            draw(xx, zz, color);
+            J.sleep(3);
+        }));
+    }
+
+    public void draw(int x, int z, Color color) {
+        try {
+            if (renderer != null && frame != null && frame.isVisible()) {
+                renderer.func.accept(new Position2(x, z), color);
+            }
+        } catch (Throwable ignored) {
+            Iris.error("Failed to draw pregen");
+        }
+    }
+
+    public void stop() {
+        J.a(() -> {
+            pregenerator.close();
+            close();
+            instance = null;
+        });
+    }
+
+    public void close() {
+        J.a(() -> {
+            try {
+                monitor.close();
+                J.sleep(3000);
+                frame.setVisible(false);
+            } catch (Throwable ignored) {
+                Iris.error("Error closing pregen gui");
+            }
+        });
+    }
+
+    public void open() {
+        J.a(() -> {
+            try {
+                frame = new JFrame("Pregen View");
+                renderer = new PregenRenderer();
+                frame.addKeyListener(renderer);
+                renderer.l = new ReentrantLock();
+                renderer.frame = frame;
+                renderer.job = this;
+                renderer.func = (c, b) -> {
+                    renderer.l.lock();
+                    renderer.order.add(() -> renderer.draw(c, b, renderer.bg));
+                    renderer.l.unlock();
+                };
+                frame.add(renderer);
+                frame.setSize(1000, 1000);
+                frame.setVisible(true);
+            } catch (Throwable ignored) {
+                Iris.error("Error opening pregen gui");
+            }
+        });
+    }
+
+    @Override
+    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
+        info = new String[]{
+                (paused() ? "PAUSED" : (saving ? "Saving... " : "Generating")) + " " + Form.f(generated) + " of " + Form.f(totalChunks) + " (" + Form.pc(percent, 0) + " Complete)",
+                "Speed: " + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
+                Form.duration(eta, 2) + " Remaining " + " (" + Form.duration(elapsed, 2) + " Elapsed)",
+                "Generation Method: " + method,
+                "Memory: " + Form.memSize(monitor.getUsedBytes(), 2) + " (" + Form.pc(monitor.getUsagePercent(), 0) + ") Pressure: " + Form.memSize(monitor.getPressure(), 0) + "/s",
+
+        };
+
+        for (Consumer<Double> i : onProgress) {
+            i.accept(percent);
+        }
+    }
+
+    @Override
+    public void onChunkGenerating(int x, int z) {
+        draw(x, z, COLOR_GENERATING);
+    }
+
+    @Override
+    public void onChunkGenerated(int x, int z) {
+        if (engine != null) {
+            draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
+            return;
+        }
+
+        draw(x, z, COLOR_GENERATED);
+    }
+
+    @Override
+    public void onRegionGenerated(int x, int z) {
+        shouldGc();
+        rgc++;
+
+        // Each region is 32x32 chunks
+        for (int chunkOffsetX = 0; chunkOffsetX < 32; chunkOffsetX++) {
+            for (int chunkOffsetZ = 0; chunkOffsetZ < 32; chunkOffsetZ++) {
+                // Calculate actual chunk coordinates
+                int chunkX = (x << 5) + chunkOffsetX;
+                int chunkZ = (z << 5) + chunkOffsetZ;
+
+                if (engine != null) {
+                    // Calculate the center block of the chunk
+                    int centerBlockX = (chunkX << 4) + 8;
+                    int centerBlockZ = (chunkZ << 4) + 8;
+
+                    // Draw the chunk
+                    draw(chunkX, chunkZ, engine.draw(centerBlockX, centerBlockZ));
+                } else {
+                    // If engine is null, use the default color
+                    draw(chunkX, chunkZ, COLOR_GENERATED);
+                }
+            }
+        }
+    }
+
+    private void shouldGc() {
+        if (cl.flip() && rgc > 16) {
+            System.gc();
+        }
+    }
+
+    @Override
+    public void onRegionGenerating(int x, int z) {
+
+    }
+
+    @Override
+    public void onChunkCleaned(int x, int z) {
+        //draw(x, z, COLOR_CLEANED);
+    }
+
+    @Override
+    public void onRegionSkipped(int x, int z) {
+
+    }
+
+    @Override
+    public void onNetworkStarted(int x, int z) {
+        drawRegion(x, z, COLOR_NETWORK);
+    }
+
+    @Override
+    public void onNetworkFailed(int x, int z) {
+
+    }
+
+    @Override
+    public void onNetworkReclaim(int revert) {
+
+    }
+
+    @Override
+    public void onNetworkGeneratedChunk(int x, int z) {
+        draw(x, z, COLOR_NETWORK_GENERATING);
+    }
+
+    @Override
+    public void onNetworkDownloaded(int x, int z) {
+        drawRegion(x, z, COLOR_NETWORK);
+    }
+
+    @Override
+    public void onClose() {
+        close();
+        instance = null;
+        whenDone.forEach(Runnable::run);
+    }
+
+    @Override
+    public void onSaving() {
+
+    }
+
+    @Override
+    public void onChunkExistsInRegionGen(int x, int z) {
+        if (engine != null) {
+            draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
+            return;
+        }
+
+        draw(x, z, COLOR_EXISTS);
+    }
+
+    private Position2 getMax() {
+        return max;
+    }
+
+    private Position2 getMin() {
+        return min;
+    }
+
+    private boolean paused() {
+        return pregenerator.paused();
+    }
+
+    private String[] getProgress() {
+        return info;
+    }
+
+    public static class PregenRenderer extends JPanel implements KeyListener {
+        private static final long serialVersionUID = 2094606939770332040L;
+        private final KList<Runnable> order = new KList<>();
+        private final int res = 512;
+        private final BufferedImage image = new BufferedImage(res, res, BufferedImage.TYPE_INT_RGB);
+        Graphics2D bg;
+        private PregeneratorJob job;
+        private ReentrantLock l;
+        private Consumer2<Position2, Color> func;
+        private JFrame frame;
+
+        public PregenRenderer() {
+
+        }
+
+        public void paint(int x, int z, Color c) {
+            func.accept(new Position2(x, z), c);
+        }
+
+        @Override
+        public void paint(Graphics gx) {
+            Graphics2D g = (Graphics2D) gx;
+            bg = (Graphics2D) image.getGraphics();
+            l.lock();
+
+            while (order.isNotEmpty()) {
+                try {
+                    order.pop().run();
+                } catch (Throwable e) {
+                    Iris.reportError(e);
+
+                }
+            }
+
+            l.unlock();
+            g.drawImage(image, 0, 0, getParent().getWidth(), getParent().getHeight(), (img, infoflags, x, y, width, height) -> true);
+            g.setColor(Color.WHITE);
+            g.setFont(new Font("Hevetica", Font.BOLD, 13));
+            String[] prog = job.getProgress();
+            int h = g.getFontMetrics().getHeight() + 5;
+            int hh = 20;
+
+            if (job.paused()) {
+                g.drawString("PAUSED", 20, hh += h);
+
+                g.drawString("Press P to Resume", 20, hh += h);
+            } else {
+                for (String i : prog) {
+                    g.drawString(i, 20, hh += h);
+                }
+
+                g.drawString("Press P to Pause", 20, hh += h);
+            }
+
+            J.sleep(IrisSettings.get().getGui().isMaximumPregenGuiFPS() ? 4 : 250);
+            repaint();
+        }
+
+        private void draw(Position2 p, Color c, Graphics2D bg) {
+            double pw = M.lerpInverse(job.getMin().getX(), job.getMax().getX(), p.getX());
+            double ph = M.lerpInverse(job.getMin().getZ(), job.getMax().getZ(), p.getZ());
+            double pwa = M.lerpInverse(job.getMin().getX(), job.getMax().getX(), p.getX() + 1);
+            double pha = M.lerpInverse(job.getMin().getZ(), job.getMax().getZ(), p.getZ() + 1);
+            int x = (int) M.lerp(0, res, pw);
+            int z = (int) M.lerp(0, res, ph);
+            int xa = (int) M.lerp(0, res, pwa);
+            int za = (int) M.lerp(0, res, pha);
+            bg.setColor(c);
+            bg.fillRect(x, z, xa - x, za - z);
+        }
+
+        @Override
+        public void keyTyped(KeyEvent e) {
+
+        }
+
+        @Override
+        public void keyPressed(KeyEvent e) {
+
+        }
+
+        @Override
+        public void keyReleased(KeyEvent e) {
+            if (e.getKeyCode() == KeyEvent.VK_P) {
+                PregeneratorJob.pauseResume();
+            }
+        }
+
+        public void close() {
+            frame.setVisible(false);
+        }
+    }
+}

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

@@ -0,0 +1,844 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.gui.components.IrisRenderer;
+import com.volmit.iris.core.gui.components.RenderType;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.IrisComplex;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisRegion;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.math.BlockPosition;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RollingSequence;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.O;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import org.bukkit.Location;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import javax.swing.event.MouseInputListener;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.BiFunction;
+
+public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener, MouseMotionListener, MouseInputListener {
+    private static final long serialVersionUID = 2094606939770332040L;
+    private final KList<LivingEntity> lastEntities = new KList<>();
+    private final KMap<String, Long> notifications = new KMap<>();
+    private final ChronoLatch centities = new ChronoLatch(1000);
+    private final RollingSequence rs = new RollingSequence(512);
+    private final O<Integer> m = new O<>();
+    private final KMap<BlockPosition, BufferedImage> positions = new KMap<>();
+    private final KMap<BlockPosition, BufferedImage> fastpositions = new KMap<>();
+    private final KSet<BlockPosition> working = new KSet<>();
+    private final KSet<BlockPosition> workingfast = new KSet<>();
+    double tfps = 240D;
+    int ltc = 3;
+    private RenderType currentType = RenderType.BIOME;
+    private boolean help = true;
+    private boolean helpIgnored = false;
+    private boolean shift = false;
+    private Player player = null;
+    private boolean debug = false;
+    private boolean control = false;
+    private boolean eco = false;
+    private boolean lowtile = false;
+    private boolean follow = false;
+    private boolean alt = false;
+    private boolean dragging = false;
+    private IrisRenderer renderer;
+    private IrisWorld world;
+    private double velocity = 0;
+    private int lowq = 12;
+    private double scale = 128;
+    private double mscale = 4D;
+    private int w = 0;
+    private int h = 0;
+    private double lx = 0;
+    private double lz = 0;
+    private double ox = 0;
+    private double oz = 0;
+    private double hx = 0;
+    private double hz = 0;
+    private double oxp = 0;
+    private double ozp = 0;
+    private Engine engine;
+    private int tid = 0;
+    private final ExecutorService e = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(), r -> {
+        tid++;
+        Thread t = new Thread(r);
+        t.setName("Iris HD Renderer " + tid);
+        t.setPriority(Thread.MIN_PRIORITY);
+        t.setUncaughtExceptionHandler((et, e) ->
+        {
+            Iris.info("Exception encountered in " + et.getName());
+            e.printStackTrace();
+        });
+
+        return t;
+    });
+
+    private final ExecutorService eh = Executors.newFixedThreadPool(ltc, r -> {
+        tid++;
+        Thread t = new Thread(r);
+        t.setName("Iris Renderer " + tid);
+        t.setPriority(Thread.NORM_PRIORITY);
+        t.setUncaughtExceptionHandler((et, e) ->
+        {
+            Iris.info("Exception encountered in " + et.getName());
+            e.printStackTrace();
+        });
+
+        return t;
+    });
+    private BufferedImage texture;
+
+    public VisionGUI(JFrame frame) {
+        m.set(8);
+        rs.put(1);
+        addMouseWheelListener(this);
+        addMouseMotionListener(this);
+        addMouseListener(this);
+        frame.addKeyListener(this);
+        J.a(() -> {
+            J.sleep(10000);
+
+            if (!helpIgnored && help) {
+                help = false;
+            }
+        });
+        frame.addWindowListener(new java.awt.event.WindowAdapter() {
+            @Override
+            public void windowClosing(java.awt.event.WindowEvent windowEvent) {
+                e.shutdown();
+                eh.shutdown();
+            }
+        });
+    }
+
+    private static void createAndShowGUI(Engine r, int s, IrisWorld world) {
+        JFrame frame = new JFrame("Vision");
+        VisionGUI nv = new VisionGUI(frame);
+        nv.world = world;
+        nv.engine = r;
+        nv.renderer = new IrisRenderer(r);
+        frame.add(nv);
+        frame.setSize(1440, 820);
+        frame.setVisible(true);
+        File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
+
+        if (file != null) {
+            try {
+                nv.texture = ImageIO.read(file);
+                frame.setIconImage(ImageIO.read(file));
+            } catch (IOException e) {
+                Iris.reportError(e);
+
+            }
+        }
+    }
+
+    public static void launch(Engine g, int i) {
+        J.a(() ->
+                createAndShowGUI(g, i, g.getWorld()));
+    }
+
+    public boolean updateEngine() {
+        if (engine.isClosed()) {
+            if (world.hasRealWorld()) {
+                try {
+                    engine = IrisToolbelt.access(world.realWorld()).getEngine();
+                    return !engine.isClosed();
+                } catch (Throwable e) {
+
+                }
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void mouseMoved(MouseEvent e) {
+        Point cp = e.getPoint();
+        lx = (cp.getX());
+        lz = (cp.getY());
+    }
+
+    @Override
+    public void mouseDragged(MouseEvent e) {
+        dragging = true;
+        Point cp = e.getPoint();
+        ox += (lx - cp.getX()) * scale;
+        oz += (lz - cp.getY()) * scale;
+        lx = cp.getX();
+        lz = cp.getY();
+    }
+
+    public int getColor(double wx, double wz) {
+        BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
+
+        switch (currentType) {
+            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
+                    colorFunction = (x, z) -> engine.getComplex().getTrueBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case BIOME_LAND ->
+                    colorFunction = (x, z) -> engine.getComplex().getLandBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case BIOME_SEA ->
+                    colorFunction = (x, z) -> engine.getComplex().getSeaBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case REGION ->
+                    colorFunction = (x, z) -> engine.getComplex().getRegionStream().get(x, z).getColor(engine.getComplex(), currentType).getRGB();
+            case CAVE_LAND ->
+                    colorFunction = (x, z) -> engine.getComplex().getCaveBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case HEIGHT ->
+                    colorFunction = (x, z) -> Color.getHSBColor(engine.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
+        }
+
+        return colorFunction.apply(wx, wz);
+    }
+
+    public void notify(String s) {
+        notifications.put(s, M.ms() + 2500);
+    }
+
+    @Override
+    public void keyTyped(KeyEvent e) {
+
+    }
+
+    @Override
+    public void keyPressed(KeyEvent e) {
+        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
+            shift = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
+            control = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
+            debug = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
+            help = true;
+            helpIgnored = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_ALT) {
+            alt = true;
+        }
+    }
+
+    @Override
+    public void keyReleased(KeyEvent e) {
+        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
+            debug = false;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
+            shift = false;
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
+            control = false;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
+            help = false;
+            helpIgnored = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_ALT) {
+            alt = false;
+        }
+
+        // Pushes
+        if (e.getKeyCode() == KeyEvent.VK_F) {
+            follow = !follow;
+
+            if (player != null && follow) {
+                notify("Following " + player.getName() + ". Press F to disable");
+            } else if (follow) {
+                notify("Can't follow, no one is in the world");
+                follow = false;
+            } else {
+                notify("Follow Off");
+            }
+
+            return;
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_R) {
+            dump();
+            notify("Refreshing Chunks");
+            return;
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_P) {
+            lowtile = !lowtile;
+            dump();
+            notify("Rendering " + (lowtile ? "Low" : "High") + " Quality Tiles");
+            return;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_E) {
+            eco = !eco;
+            dump();
+            notify("Using " + (eco ? "60" : "Uncapped") + " FPS Limit");
+            return;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_EQUALS) {
+            mscale = mscale + ((0.044 * mscale) * -3);
+            mscale = Math.max(mscale, 0.00001);
+            dump();
+            return;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_MINUS) {
+            mscale = mscale + ((0.044 * mscale) * 3);
+            mscale = Math.max(mscale, 0.00001);
+            dump();
+            return;
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_BACK_SLASH) {
+            mscale = 1D;
+            dump();
+            notify("Zoom Reset");
+            return;
+        }
+
+        int currentMode = currentType.ordinal();
+
+        for (RenderType i : RenderType.values()) {
+            if (e.getKeyChar() == String.valueOf(i.ordinal() + 1).charAt(0)) {
+                if (i.ordinal() != currentMode) {
+                    currentType = i;
+                    dump();
+                    notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
+                    return;
+                }
+            }
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_M) {
+            currentType = RenderType.values()[(currentMode + 1) % RenderType.values().length];
+            notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
+            dump();
+        }
+    }
+
+    private void dump() {
+        positions.clear();
+        fastpositions.clear();
+    }
+
+    public BufferedImage getTile(KSet<BlockPosition> fg, int div, int x, int z, O<Integer> m) {
+        BlockPosition key = new BlockPosition((int) mscale, Math.floorDiv(x, div), Math.floorDiv(z, div));
+        fg.add(key);
+
+        if (positions.containsKey(key)) {
+            return positions.get(key);
+        }
+
+        if (fastpositions.containsKey(key)) {
+            if (!working.contains(key) && working.size() < 9) {
+                m.set(m.get() - 1);
+
+                if (m.get() >= 0 && velocity < 50) {
+                    working.add(key);
+                    double mk = mscale;
+                    double mkd = scale;
+                    e.submit(() ->
+                    {
+                        PrecisionStopwatch ps = PrecisionStopwatch.start();
+                        BufferedImage b = renderer.render(x * mscale, z * mscale, div * mscale, div / (lowtile ? 3 : 1), currentType);
+                        rs.put(ps.getMilliseconds());
+                        working.remove(key);
+
+                        if (mk == mscale && mkd == scale) {
+                            positions.put(key, b);
+                        }
+                    });
+                }
+            }
+
+            return fastpositions.get(key);
+        }
+
+        if (workingfast.contains(key) || workingfast.size() > Runtime.getRuntime().availableProcessors()) {
+            return null;
+        }
+
+        workingfast.add(key);
+        double mk = mscale;
+        double mkd = scale;
+        eh.submit(() ->
+        {
+            PrecisionStopwatch ps = PrecisionStopwatch.start();
+            BufferedImage b = renderer.render(x * mscale, z * mscale, div * mscale, div / lowq, currentType);
+            rs.put(ps.getMilliseconds());
+            workingfast.remove(key);
+
+            if (mk == mscale && mkd == scale) {
+                fastpositions.put(key, b);
+            }
+        });
+        return null;
+    }
+
+    private double getWorldX(double screenX) {
+        //return (mscale * screenX) + ((oxp / scale) * mscale);
+        return (mscale * screenX) + ((oxp / scale) * mscale);
+    }
+
+    private double getWorldZ(double screenZ) {
+        return (mscale * screenZ) + ((ozp / scale) * mscale);
+    }
+
+    private double getScreenX(double x) {
+        return (x / mscale) - ((oxp / scale));
+    }
+
+    private double getScreenZ(double z) {
+        return (z / mscale) - ((ozp / scale));
+    }
+
+    @Override
+    public void paint(Graphics gx) {
+
+        if (engine.isClosed()) {
+            EventQueue.invokeLater(() -> {
+                try {
+                    setVisible(false);
+                } catch (Throwable e) {
+
+                }
+            });
+
+            return;
+        }
+
+        if (updateEngine()) {
+            dump();
+        }
+
+        if (ox < oxp) {
+            velocity = Math.abs(ox - oxp) * 0.36;
+            oxp -= velocity;
+        }
+
+        if (ox > oxp) {
+            velocity = Math.abs(oxp - ox) * 0.36;
+            oxp += velocity;
+        }
+
+        if (oz < ozp) {
+            velocity = Math.abs(oz - ozp) * 0.36;
+            ozp -= velocity;
+        }
+
+        if (oz > ozp) {
+            velocity = Math.abs(ozp - oz) * 0.36;
+            ozp += velocity;
+        }
+
+        if (lx < hx) {
+            hx -= Math.abs(lx - hx) * 0.36;
+        }
+
+        if (lx > hx) {
+            hx += Math.abs(hx - lx) * 0.36;
+        }
+
+        if (lz < hz) {
+            hz -= Math.abs(lz - hz) * 0.36;
+        }
+
+        if (lz > hz) {
+            hz += Math.abs(hz - lz) * 0.36;
+        }
+
+        if (centities.flip()) {
+            J.s(() -> {
+                synchronized (lastEntities) {
+                    lastEntities.clear();
+                    lastEntities.addAll(world.getEntitiesByClass(LivingEntity.class));
+                }
+            });
+        }
+        lowq = Math.max(Math.min((int) M.lerp(8, 28, velocity / 1000D), 28), 8);
+        PrecisionStopwatch p = PrecisionStopwatch.start();
+        Graphics2D g = (Graphics2D) gx;
+        w = getWidth();
+        h = getHeight();
+        double vscale = scale;
+        scale = w / 12D;
+
+        if (scale != vscale) {
+            positions.clear();
+        }
+
+        KSet<BlockPosition> gg = new KSet<>();
+        int iscale = (int) scale;
+        g.setColor(Color.white);
+        g.clearRect(0, 0, w, h);
+        int posX = (int) oxp;
+        int posZ = (int) ozp;
+        m.set(3);
+
+        for (int r = 0; r < Math.max(w, h); r += iscale) {
+            for (int i = -iscale; i < w + iscale; i += iscale) {
+                for (int j = -iscale; j < h + iscale; j += iscale) {
+                    int a = i - (w / 2);
+                    int b = j - (h / 2);
+                    if (a * a + b * b <= r * r) {
+                        BufferedImage t = getTile(gg, iscale, Math.floorDiv((posX / iscale) + i, iscale) * iscale, Math.floorDiv((posZ / iscale) + j, iscale) * iscale, m);
+
+                        if (t != null) {
+                            g.drawImage(t, i - ((posX / iscale) % (iscale)), j - ((posZ / iscale) % (iscale)), iscale, iscale, (img, infoflags, x, y, width, height) -> true);
+                        }
+                    }
+                }
+            }
+        }
+
+        p.end();
+
+        for (BlockPosition i : positions.k()) {
+            if (!gg.contains(i)) {
+                positions.remove(i);
+            }
+        }
+
+        hanleFollow();
+        renderOverlays(g);
+
+        if (!isVisible()) {
+            return;
+        }
+
+        if (!getParent().isVisible()) {
+            return;
+        }
+
+        if (!getParent().getParent().isVisible()) {
+            return;
+        }
+
+        J.a(() ->
+        {
+            J.sleep(eco ? 15 : 1);
+            repaint();
+        });
+    }
+
+    private void hanleFollow() {
+        if (follow && player != null) {
+            animateTo(player.getLocation().getX(), player.getLocation().getZ());
+        }
+    }
+
+    private void renderOverlays(Graphics2D g) {
+        renderPlayer(g);
+
+        if (help) {
+            renderOverlayHelp(g);
+        } else if (debug) {
+            renderOverlayDebug(g);
+        }
+
+        renderOverlayLegend(g);
+
+        renderHoverOverlay(g, shift);
+        if (!notifications.isEmpty()) {
+            renderNotification(g);
+        }
+    }
+
+    private void renderOverlayLegend(Graphics2D g) {
+        KList<String> l = new KList<>();
+        l.add("Zoom: " + Form.pc(mscale, 0));
+        l.add("Blocks: " + Form.f((int) mscale * w) + " by " + Form.f((int) mscale * h));
+        l.add("BPP: " + Form.f(mscale, 1));
+        l.add("Render Mode: " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
+
+        drawCardBR(g, l);
+    }
+
+    private void renderNotification(Graphics2D g) {
+        drawCardCB(g, notifications.k());
+
+        for (String i : notifications.k()) {
+            if (M.ms() > notifications.get(i)) {
+                notifications.remove(i);
+            }
+        }
+    }
+
+    private void renderPlayer(Graphics2D g) {
+        Player b = null;
+
+        for (Player i : world.getPlayers()) {
+            b = i;
+            renderPosition(g, i.getLocation().getX(), i.getLocation().getZ());
+        }
+
+        synchronized (lastEntities) {
+            double dist = Double.MAX_VALUE;
+            LivingEntity h = null;
+
+            for (LivingEntity i : lastEntities) {
+                if (i instanceof Player) {
+                    continue;
+                }
+
+                renderMobPosition(g, i, i.getLocation().getX(), i.getLocation().getZ());
+                if (shift) {
+                    double d = i.getLocation().distanceSquared(new Location(i.getWorld(), getWorldX(hx), i.getLocation().getY(), getWorldZ(hz)));
+
+                    if (d < dist) {
+                        dist = d;
+                        h = i;
+                    }
+                }
+            }
+
+            if (h != null && shift) {
+                g.setColor(Color.red);
+                g.fillRoundRect((int) getScreenX(h.getLocation().getX()) - 10, (int) getScreenZ(h.getLocation().getZ()) - 10, 20, 20, 20, 20);
+                KList<String> k = new KList<>();
+                k.add(Form.capitalizeWords(h.getType().name().toLowerCase(Locale.ROOT).replaceAll("\\Q_\\E", " ")) + h.getEntityId());
+
+                k.add("Pos: " + h.getLocation().getBlockX() + ", " + h.getLocation().getBlockY() + ", " + h.getLocation().getBlockZ());
+                k.add("UUID: " + h.getUniqueId());
+                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue());
+
+                drawCardTR(g, k);
+            }
+        }
+
+        player = b;
+    }
+
+    private void animateTo(double wx, double wz) {
+        double cx = getWorldX(getWidth() / 2);
+        double cz = getWorldZ(getHeight() / 2);
+        ox += (wx - cx);
+        oz += (wz - cz);
+    }
+
+    private void renderPosition(Graphics2D g, double x, double z) {
+        if (texture != null) {
+            g.drawImage(texture, (int) getScreenX(x), (int) getScreenZ(z), 66, 66, (img, infoflags, xx, xy, width, height) -> true);
+        } else {
+            g.setColor(Color.darkGray);
+            g.fillRoundRect((int) getScreenX(x) - 15, (int) getScreenZ(z) - 15, 30, 30, 15, 15);
+            g.setColor(Color.cyan.darker().darker());
+            g.fillRoundRect((int) getScreenX(x) - 10, (int) getScreenZ(z) - 10, 20, 20, 10, 10);
+        }
+    }
+
+    private void renderMobPosition(Graphics2D g, LivingEntity e, double x, double z) {
+        g.setColor(Color.red.darker().darker());
+        g.fillRoundRect((int) getScreenX(x) - 2, (int) getScreenZ(z) - 2, 4, 4, 4, 4);
+    }
+
+    private void renderHoverOverlay(Graphics2D g, boolean detailed) {
+        IrisBiome biome = engine.getComplex().getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz));
+        IrisRegion region = engine.getComplex().getRegionStream().get(getWorldX(hx), getWorldZ(hz));
+        KList<String> l = new KList<>();
+        l.add("Biome: " + biome.getName());
+        l.add("Region: " + region.getName() + "(" + region.getLoadKey() + ")");
+        l.add("Block " + (int) getWorldX(hx) + ", " + (int) getWorldZ(hz));
+        if (detailed) {
+            l.add("Chunk " + ((int) getWorldX(hx) >> 4) + ", " + ((int) getWorldZ(hz) >> 4));
+            l.add("Region " + (((int) getWorldX(hx) >> 4) >> 5) + ", " + (((int) getWorldZ(hz) >> 4) >> 5));
+            l.add("Key: " + biome.getLoadKey());
+            l.add("File: " + biome.getLoadFile());
+        }
+
+        drawCardAt((float) hx, (float) hz, 0, 0, g, l);
+    }
+
+    private void renderOverlayDebug(Graphics2D g) {
+        KList<String> l = new KList<>();
+        l.add("Velocity: " + (int) velocity);
+        l.add("Center Pos: " + Form.f((int) getWorldX(getWidth() / 2)) + ", " + Form.f((int) getWorldZ(getHeight() / 2)));
+        drawCardBL(g, l);
+    }
+
+    private void renderOverlayHelp(Graphics2D g) {
+        KList<String> l = new KList<>();
+        l.add("/ to show this help screen");
+        l.add("R to repaint the screen");
+        l.add("F to follow first player");
+        l.add("+/- to Change Zoom");
+        l.add("\\ to reset zoom to 1");
+        l.add("M to cycle render modes");
+        l.add("P to toggle Tile Quality Mode");
+        l.add("E to toggle Eco FPS Mode");
+
+        int ff = 0;
+        for (RenderType i : RenderType.values()) {
+            ff++;
+            l.add(ff + " to view " + Form.capitalizeWords(i.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
+        }
+
+        l.add("Shift for additional biome details (at cursor)");
+        l.add("CTRL + Click to teleport to location");
+        l.add("ALT + Click to open biome in VSCode");
+        drawCardTL(g, l);
+    }
+
+    private void drawCardTL(Graphics2D g, KList<String> text) {
+        drawCardAt(0, 0, 0, 0, g, text);
+    }
+
+    private void drawCardBR(Graphics2D g, KList<String> text) {
+        drawCardAt(getWidth(), getHeight(), 1, 1, g, text);
+    }
+
+    private void drawCardBL(Graphics2D g, KList<String> text) {
+        drawCardAt(0, getHeight(), 0, 1, g, text);
+    }
+
+    private void drawCardTR(Graphics2D g, KList<String> text) {
+        drawCardAt(getWidth(), 0, 1, 0, g, text);
+    }
+
+    private void open() {
+        IrisComplex complex = engine.getComplex();
+        File r = null;
+        switch (currentType) {
+            case BIOME, LAYER_LOAD, DECORATOR_LOAD, OBJECT_LOAD, HEIGHT ->
+                    r = complex.getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+            case BIOME_LAND -> r = complex.getLandBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+            case BIOME_SEA -> r = complex.getSeaBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+            case REGION -> r = complex.getRegionStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+            case CAVE_LAND -> r = complex.getCaveBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+        }
+
+        notify("Opening " + r.getPath() + " in VSCode");
+    }
+
+    private void teleport() {
+        J.s(() -> {
+            if (player != null) {
+                int xx = (int) getWorldX(hx);
+                int zz = (int) getWorldZ(hz);
+                int h = engine.getComplex().getRoundedHeighteightStream().get(xx, zz);
+                player.teleport(new Location(player.getWorld(), xx, h, zz));
+                notify("Teleporting to " + xx + ", " + h + ", " + zz);
+            } else {
+                notify("No player in world, can't teleport.");
+            }
+        });
+    }
+
+    private void drawCardCB(Graphics2D g, KList<String> text) {
+        drawCardAt(getWidth() / 2, getHeight(), 0.5, 1, g, text);
+    }
+
+    private void drawCardCT(Graphics2D g, KList<String> text) {
+        drawCardAt(getWidth() / 2, 0, 0.5, 0, g, text);
+    }
+
+    private void drawCardAt(float x, float y, double pushX, double pushZ, Graphics2D g, KList<String> text) {
+        g.setFont(new Font("Hevetica", Font.BOLD, 16));
+        int h = 0;
+        int w = 0;
+
+        for (String i : text) {
+            h += g.getFontMetrics().getHeight();
+            w = Math.max(w, g.getFontMetrics().stringWidth(i));
+        }
+
+        w += 28;
+        h += 14;
+
+        int cw = (int) ((w + 26) * pushX);
+        int ch = (int) ((h + 26) * pushZ);
+
+        g.setColor(Color.darkGray);
+        g.fillRect((int) x + 7 + 2 - cw, (int) y + 12 + 2 - ch, w + 7, h); // Shadow
+        g.setColor(Color.gray);
+        g.fillRect((int) x + 7 + 1 - cw, (int) y + 12 + 1 - ch, w + 7, h); // Shadow
+        g.setColor(Color.white);
+        g.fillRect((int) x + 7 - cw, (int) y + 12 - ch, w + 7, h);
+
+        g.setColor(Color.black);
+        int m = 0;
+        for (String i : text) {
+            g.drawString(i, x + 14 - cw, y + 14 - ch + (++m * g.getFontMetrics().getHeight()));
+        }
+    }
+
+    public void mouseWheelMoved(MouseWheelEvent e) {
+        int notches = e.getWheelRotation();
+        if (e.isControlDown()) {
+            return;
+        }
+
+        //Iris.info("Blocks/Pixel: " + (mscale) + ", Blocks Wide: " + (w * mscale));
+        positions.clear();
+        fastpositions.clear();
+        mscale = mscale + ((0.25 * mscale) * notches);
+        mscale = Math.max(mscale, 0.00001);
+    }
+
+    @Override
+    public void mouseClicked(MouseEvent e) {
+        if (control) {
+            teleport();
+        } else if (alt) {
+            open();
+        }
+    }
+
+    @Override
+    public void mousePressed(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mouseReleased(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mouseEntered(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mouseExited(MouseEvent e) {
+
+    }
+}

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

@@ -0,0 +1,85 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui.components;
+
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisBiomeGeneratorLink;
+import com.volmit.iris.util.interpolation.IrisInterpolation;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.function.BiFunction;
+
+public class IrisRenderer {
+    private final Engine renderer;
+
+    public IrisRenderer(Engine renderer) {
+        this.renderer = renderer;
+    }
+
+    public BufferedImage render(double sx, double sz, double size, int resolution, RenderType currentType) {
+        BufferedImage image = new BufferedImage(resolution, resolution, BufferedImage.TYPE_INT_RGB);
+        BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
+
+        switch (currentType) {
+            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
+                    colorFunction = (x, z) -> renderer.getComplex().getTrueBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case BIOME_LAND ->
+                    colorFunction = (x, z) -> renderer.getComplex().getLandBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case BIOME_SEA ->
+                    colorFunction = (x, z) -> renderer.getComplex().getSeaBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case REGION ->
+                    colorFunction = (x, z) -> renderer.getComplex().getRegionStream().get(x, z).getColor(renderer.getComplex(), currentType).getRGB();
+            case CAVE_LAND ->
+                    colorFunction = (x, z) -> renderer.getComplex().getCaveBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case HEIGHT ->
+                    colorFunction = (x, z) -> Color.getHSBColor(renderer.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
+            case CONTINENT -> colorFunction = (x, z) -> {
+                IrisBiome b = renderer.getBiome((int) Math.round(x), renderer.getMaxHeight() - 1, (int) Math.round(z));
+                IrisBiomeGeneratorLink g = b.getGenerators().get(0);
+                Color c;
+                if (g.getMax(renderer) <= 0) {
+                    // Max is below water level, so it is most likely an ocean biome
+                    c = Color.BLUE;
+                } else if (g.getMin(renderer) < 0) {
+                    // Min is below water level, but max is not, so it is most likely a shore biome
+                    c = Color.YELLOW;
+                } else {
+                    // Both min and max are above water level, so it is most likely a land biome
+                    c = Color.GREEN;
+                }
+                return c.getRGB();
+            };
+        }
+
+        double x, z;
+        int i, j;
+        for (i = 0; i < resolution; i++) {
+            x = IrisInterpolation.lerp(sx, sx + size, (double) i / (double) (resolution));
+
+            for (j = 0; j < resolution; j++) {
+                z = IrisInterpolation.lerp(sz, sz + size, (double) j / (double) (resolution));
+                image.setRGB(i, j, colorFunction.apply(x, z));
+            }
+        }
+
+        return image;
+    }
+}

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

@@ -0,0 +1,23 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui.components;
+
+public enum RenderType {
+    BIOME, BIOME_LAND, BIOME_SEA, REGION, CAVE_LAND, HEIGHT, OBJECT_LOAD, DECORATOR_LOAD, CONTINENT, LAYER_LOAD
+}

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

@@ -0,0 +1,26 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui.components;
+
+import java.awt.*;
+
+@FunctionalInterface
+public interface Renderer {
+    Color draw(double x, double z);
+}

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

@@ -0,0 +1,31 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui.components;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.awt.image.BufferedImage;
+
+@Builder
+@Data
+public class TileRender {
+    private BufferedImage image;
+    private int quality;
+}

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

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

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

@@ -0,0 +1,91 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.reflect.WrappedField;
+import com.willfp.ecoitems.items.EcoItem;
+import com.willfp.ecoitems.items.EcoItems;
+import org.bukkit.NamespacedKey;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.MissingResourceException;
+
+public class EcoItemsDataProvider extends ExternalDataProvider {
+    private WrappedField<EcoItem, ItemStack> itemStack;
+    private WrappedField<EcoItem, NamespacedKey> id;
+
+    public EcoItemsDataProvider() {
+        super("EcoItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up EcoItems Link...");
+        itemStack = new WrappedField<>(EcoItem.class, "_itemStack");
+        if (this.itemStack.hasFailed()) {
+            Iris.error("Failed to set up EcoItems Link: Unable to fetch ItemStack field!");
+        }
+        id = new WrappedField<>(EcoItem.class, "id");
+        if (this.id.hasFailed()) {
+            Iris.error("Failed to set up EcoItems Link: Unable to fetch id field!");
+        }
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+        EcoItem item = EcoItems.INSTANCE.getByID(itemId.key());
+        if (item == null)
+            throw new MissingResourceException("Failed to find Item!", itemId.namespace(), itemId.key());
+        return itemStack.get(item).clone();
+    }
+
+    @Override
+    public Identifier[] getBlockTypes() {
+        return new Identifier[0];
+    }
+
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> names = new KList<>();
+        for (EcoItem item : EcoItems.INSTANCE.values()) {
+            try {
+                Identifier key = Identifier.fromNamespacedKey(id.get(item));
+                if (getItemStack(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier id, boolean isItem) {
+        return id.namespace().equalsIgnoreCase("ecoitems") && isItem;
+    }
+}

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

@@ -0,0 +1,77 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.ssomar.score.api.executableitems.ExecutableItemsAPI;
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.MissingResourceException;
+import java.util.Optional;
+
+public class ExecutableItemsDataProvider extends ExternalDataProvider {
+    public ExecutableItemsDataProvider() {
+        super("ExecutableItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up ExecutableItems Link...");
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+        return ExecutableItemsAPI.getExecutableItemsManager().getExecutableItem(itemId.key())
+                .map(item -> item.buildItem(1, Optional.empty()))
+                .orElseThrow(() -> new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key()));
+    }
+
+    @Override
+    public Identifier[] getBlockTypes() {
+        return new Identifier[0];
+    }
+
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> names = new KList<>();
+        for (String name : ExecutableItemsAPI.getExecutableItemsManager().getExecutableItemIdsList()) {
+            try {
+                Identifier key = new Identifier("executable_items", name);
+                if (getItemStack(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier key, boolean isItem) {
+        return key.namespace().equalsIgnoreCase("executable_items") && isItem;
+    }
+}

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

@@ -0,0 +1,69 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KMap;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+import java.util.MissingResourceException;
+
+@RequiredArgsConstructor
+public abstract class ExternalDataProvider {
+
+    @Getter
+    private final String pluginId;
+
+    public Plugin getPlugin() {
+        return Bukkit.getPluginManager().getPlugin(pluginId);
+    }
+
+    public boolean isReady() {
+        return getPlugin() != null && getPlugin().isEnabled();
+    }
+
+    public abstract void init();
+
+    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+        return getBlockData(blockId, new KMap<>());
+    }
+
+    public abstract BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException;
+
+    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+        return getItemStack(itemId, new KMap<>());
+    }
+
+    public abstract ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException;
+
+    public void processUpdate(Engine engine, Block block, Identifier blockId) {
+    }
+
+    public abstract Identifier[] getBlockTypes();
+
+    public abstract Identifier[] getItemTypes();
+
+    public abstract boolean isValidProvider(Identifier id, boolean isItem);
+}

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

@@ -0,0 +1,157 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.service.ExternalDataSVC;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.reflect.WrappedField;
+import com.volmit.iris.util.reflect.WrappedReturningMethod;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.type.Leaves;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.function.Supplier;
+
+public class HMCLeavesDataProvider extends ExternalDataProvider {
+    private Object apiInstance;
+    private WrappedReturningMethod<Object, Material> worldBlockType;
+    private WrappedReturningMethod<Object, Boolean> setCustomBlock;
+    private Map<String, Object> blockDataMap = Map.of();
+    private Map<String, Supplier<ItemStack>> itemDataField = Map.of();
+
+    public HMCLeavesDataProvider() {
+        super("HMCLeaves");
+    }
+
+    @Override
+    public String getPluginId() {
+        return "HMCLeaves";
+    }
+
+    @Override
+    public void init() {
+        try {
+            worldBlockType = new WrappedReturningMethod<>((Class<Object>) Class.forName("io.github.fisher2911.hmcleaves.data.BlockData"), "worldBlockType");
+            apiInstance = getApiInstance(Class.forName("io.github.fisher2911.hmcleaves.api.HMCLeavesAPI"));
+            setCustomBlock = new WrappedReturningMethod<>((Class<Object>) apiInstance.getClass(), "setCustomBlock", Location.class, String.class, boolean.class);
+            Object config = getLeavesConfig(apiInstance.getClass());
+            blockDataMap = getMap(config, "blockDataMap");
+            itemDataField = getMap(config, "itemSupplierMap");
+        } catch (Throwable e) {
+            Iris.error("Failed to initialize HMCLeavesDataProvider: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+        Object o = blockDataMap.get(blockId.key());
+        if (o == null)
+            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        Material material = worldBlockType.invoke(o, new Object[0]);
+        if (material == null)
+            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        BlockData blockData = Bukkit.createBlockData(material);
+        if (IrisSettings.get().getGenerator().preventLeafDecay && blockData instanceof Leaves leaves)
+            leaves.setPersistent(true);
+        return new IrisCustomData(blockData, ExternalDataSVC.buildState(blockId, state));
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+        if (!itemDataField.containsKey(itemId.key()))
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        return itemDataField.get(itemId.key()).get();
+    }
+
+    @Override
+    public void processUpdate(Engine engine, Block block, Identifier blockId) {
+        var pair = ExternalDataSVC.parseState(blockId);
+        blockId = pair.getA();
+        Boolean result = setCustomBlock.invoke(apiInstance, new Object[]{block.getLocation(), blockId.key(), false});
+        if (result == null || !result)
+            Iris.warn("Failed to set custom block! " + blockId.key() + " " + block.getX() + " " + block.getY() + " " + block.getZ());
+        else if (IrisSettings.get().getGenerator().preventLeafDecay) {
+            BlockData blockData = block.getBlockData();
+            if (blockData instanceof Leaves leaves)
+                leaves.setPersistent(true);
+        }
+    }
+
+    @Override
+    public Identifier[] getBlockTypes() {
+        KList<Identifier> names = new KList<>();
+        for (String name : blockDataMap.keySet()) {
+            try {
+                Identifier key = new Identifier("hmcleaves", name);
+                if (getBlockData(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> names = new KList<>();
+        for (String name : itemDataField.keySet()) {
+            try {
+                Identifier key = new Identifier("hmcleaves", name);
+                if (getItemStack(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier id, boolean isItem) {
+        return (isItem ? itemDataField.keySet() : blockDataMap.keySet()).contains(id.key());
+    }
+
+    private <C, T> Map<String, T> getMap(C config, String name) {
+        WrappedField<C, Map<String, T>> field = new WrappedField<>((Class<C>) config.getClass(), name);
+        return field.get(config);
+    }
+
+    private <A> A getApiInstance(Class<A> apiClass) {
+        WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
+        return instance.invoke();
+    }
+
+    private <A, C> C getLeavesConfig(Class<A> apiClass) {
+        WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
+        WrappedField<A, C> config = new WrappedField<>(apiClass, "config");
+        return config.get(instance.invoke());
+    }
+}

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

@@ -0,0 +1,55 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import org.bukkit.NamespacedKey;
+
+public record Identifier(String namespace, String key) {
+
+    private static final String DEFAULT_NAMESPACE = "minecraft";
+
+    public static Identifier fromNamespacedKey(NamespacedKey key) {
+        return new Identifier(key.getNamespace(), key.getKey());
+    }
+
+    public static Identifier fromString(String id) {
+        String[] strings = id.split(":", 2);
+        if (strings.length == 1) {
+            return new Identifier(DEFAULT_NAMESPACE, strings[0]);
+        } else {
+            return new Identifier(strings[0], strings[1]);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return namespace + ":" + key;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Identifier i) {
+            return i.namespace().equals(this.namespace) && i.key().equals(this.key);
+        } else if (obj instanceof NamespacedKey i) {
+            return i.getNamespace().equals(this.namespace) && i.getKey().equals(this.key);
+        } else {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,116 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.platform.PlatformChunkGenerator;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+
+// See/update https://app.gitbook.com/@volmitsoftware/s/iris/compatability/papi/
+public class IrisPapiExpansion extends PlaceholderExpansion {
+    @Override
+    public @NotNull String getIdentifier() {
+        return "iris";
+    }
+
+    @Override
+    public @NotNull String getAuthor() {
+        return "Volmit Software";
+    }
+
+    @Override
+    public @NotNull String getVersion() {
+        return Iris.instance.getDescription().getVersion();
+    }
+
+    @Override
+    public boolean persist() {
+        return true;
+    }
+
+    @Override
+    public String onRequest(OfflinePlayer player, String p) {
+        Location l = null;
+        PlatformChunkGenerator a = null;
+
+        if (player.isOnline() && player.getPlayer() != null) {
+            l = player.getPlayer().getLocation().add(0, 2, 0);
+            a = IrisToolbelt.access(l.getWorld());
+        }
+
+        if (p.equalsIgnoreCase("biome_name")) {
+            if (a != null) {
+                return getBiome(a, l).getName();
+            }
+        } else if (p.equalsIgnoreCase("biome_id")) {
+            if (a != null) {
+                return getBiome(a, l).getLoadKey();
+            }
+        } else if (p.equalsIgnoreCase("biome_file")) {
+            if (a != null) {
+                return getBiome(a, l).getLoadFile().getPath();
+            }
+        } else if (p.equalsIgnoreCase("region_name")) {
+            if (a != null) {
+                return a.getEngine().getRegion(l).getName();
+            }
+        } else if (p.equalsIgnoreCase("region_id")) {
+            if (a != null) {
+                return a.getEngine().getRegion(l).getLoadKey();
+            }
+        } else if (p.equalsIgnoreCase("region_file")) {
+            if (a != null) {
+                return a.getEngine().getRegion(l).getLoadFile().getPath();
+            }
+        } else if (p.equalsIgnoreCase("terrain_slope")) {
+            if (a != null) {
+                return (a.getEngine())
+                        .getComplex().getSlopeStream()
+                        .get(l.getX(), l.getZ()) + "";
+            }
+        } else if (p.equalsIgnoreCase("terrain_height")) {
+            if (a != null) {
+                return Math.round(a.getEngine().getHeight(l.getBlockX(), l.getBlockZ())) + "";
+            }
+        } else if (p.equalsIgnoreCase("world_mode")) {
+            if (a != null) {
+                return a.isStudio() ? "Studio" : "Production";
+            }
+        } else if (p.equalsIgnoreCase("world_seed")) {
+            if (a != null) {
+                return a.getEngine().getSeedManager().getSeed() + "";
+            }
+        } else if (p.equalsIgnoreCase("world_speed")) {
+            if (a != null) {
+                return a.getEngine().getGeneratedPerSecond() + "/s";
+            }
+        }
+
+        return null;
+    }
+
+    private IrisBiome getBiome(PlatformChunkGenerator a, Location l) {
+        return a.getEngine().getBiome(l.getBlockX(), l.getBlockY() - l.getWorld().getMinHeight(), l.getBlockZ());
+    }
+}

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

@@ -0,0 +1,89 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import dev.lone.itemsadder.api.CustomBlock;
+import dev.lone.itemsadder.api.CustomStack;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.MissingResourceException;
+
+public class ItemAdderDataProvider extends ExternalDataProvider {
+
+    private KList<String> itemNamespaces, blockNamespaces;
+
+    public ItemAdderDataProvider() {
+        super("ItemsAdder");
+    }
+
+    @Override
+    public void init() {
+        this.itemNamespaces = new KList<>();
+        this.blockNamespaces = new KList<>();
+
+        for (Identifier i : getItemTypes()) {
+            itemNamespaces.addIfMissing(i.namespace());
+        }
+        for (Identifier i : getBlockTypes()) {
+            blockNamespaces.addIfMissing(i.namespace());
+            Iris.info("Found ItemAdder Block: " + i);
+        }
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+        return CustomBlock.getBaseBlockData(blockId.toString());
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+        CustomStack stack = CustomStack.getInstance(itemId.toString());
+        if (stack == null) {
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        }
+        return stack.getItemStack();
+    }
+
+    @Override
+    public Identifier[] getBlockTypes() {
+        KList<Identifier> keys = new KList<>();
+        for (String s : CustomBlock.getNamespacedIdsInRegistry()) {
+            keys.add(Identifier.fromString(s));
+        }
+        return keys.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> keys = new KList<>();
+        for (String s : CustomStack.getNamespacedIdsInRegistry()) {
+            keys.add(Identifier.fromString(s));
+        }
+        return keys.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier id, boolean isItem) {
+        return isItem ? this.itemNamespaces.contains(id.namespace()) : this.blockNamespaces.contains(id.namespace());
+    }
+}

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

@@ -0,0 +1,155 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.scheduling.J;
+import net.Indyuce.mmoitems.MMOItems;
+import net.Indyuce.mmoitems.api.ItemTier;
+import net.Indyuce.mmoitems.api.Type;
+import net.Indyuce.mmoitems.api.block.CustomBlock;
+import org.bukkit.Bukkit;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.MissingResourceException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class MMOItemsDataProvider extends ExternalDataProvider {
+
+    public MMOItemsDataProvider() {
+        super("MMOItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up MMOItems Link...");
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+        int id = -1;
+        try {
+            id = Integer.parseInt(blockId.key());
+        } catch (NumberFormatException ignored) {
+        }
+        CustomBlock block = api().getCustomBlocks().getBlock(id);
+        if (block == null)
+            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        return block.getState().getBlockData();
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+        String[] parts = itemId.namespace().split("_", 2);
+        if (parts.length != 2)
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        CompletableFuture<ItemStack> future = new CompletableFuture<>();
+        Runnable run = () -> {
+            try {
+                var type = api().getTypes().get(parts[1]);
+                int level = -1;
+                ItemTier tier = null;
+
+                if (customNbt != null) {
+                    level = (int) customNbt.getOrDefault("level", -1);
+                    tier = api().getTiers().get(String.valueOf(customNbt.get("tier")));
+                }
+
+                ItemStack itemStack;
+                if (type == null) {
+                    future.complete(null);
+                    return;
+                }
+
+                if (level != -1 && tier != null) {
+                    itemStack = api().getItem(type, itemId.key(), level, tier);
+                } else {
+                    itemStack = api().getItem(type, itemId.key());
+                }
+                future.complete(itemStack);
+            } catch (Throwable e) {
+                future.completeExceptionally(e);
+            }
+        };
+        if (Bukkit.isPrimaryThread()) run.run();
+        else J.s(run);
+        ItemStack item = null;
+        try {
+            item = future.get();
+        } catch (InterruptedException | ExecutionException ignored) {
+        }
+        if (item == null)
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        return item;
+    }
+
+    @Override
+    public Identifier[] getBlockTypes() {
+        KList<Identifier> names = new KList<>();
+        for (Integer id : api().getCustomBlocks().getBlockIds()) {
+            try {
+                Identifier key = new Identifier("mmoitems", String.valueOf(id));
+                if (getBlockData(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> names = new KList<>();
+        Runnable run = () -> {
+            for (Type type : api().getTypes().getAll()) {
+                for (String name : api().getTemplates().getTemplateNames(type)) {
+                    try {
+                        Identifier key = new Identifier("mmoitems_" + type.getId(), name);
+                        if (getItemStack(key) != null)
+                            names.add(key);
+                    } catch (MissingResourceException ignored) {
+                    }
+                }
+            }
+        };
+        if (Bukkit.isPrimaryThread()) run.run();
+        else {
+            try {
+                J.sfut(run).get();
+            } catch (InterruptedException | ExecutionException e) {
+                Iris.error("Failed getting MMOItems item types!");
+                Iris.reportError(e);
+            }
+        }
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier id, boolean isItem) {
+        return isItem ? id.namespace().split("_", 2).length == 2 : id.namespace().equals("mmoitems");
+    }
+
+    private MMOItems api() {
+        return MMOItems.plugin;
+    }
+}

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

@@ -0,0 +1,143 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.util.collection.KMap;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.WorldType;
+import org.bukkit.plugin.Plugin;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+public class MultiverseCoreLink {
+    private final KMap<String, String> worldNameTypes = new KMap<>();
+
+    public MultiverseCoreLink() {
+
+    }
+
+    public boolean addWorld(String worldName, IrisDimension dim, String seed) {
+        if (!isSupported()) {
+            return false;
+        }
+
+        try {
+            Plugin p = getMultiverse();
+            Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
+            Method m = mvWorldManager.getClass().getDeclaredMethod("addWorld",
+
+                    String.class, World.Environment.class, String.class, WorldType.class, Boolean.class, String.class, boolean.class);
+            boolean b = (boolean) m.invoke(mvWorldManager, worldName, dim.getEnvironment(), seed, WorldType.NORMAL, false, "Iris", false);
+            saveConfig();
+            return b;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+
+        return false;
+    }
+
+    @SuppressWarnings("unchecked")
+    public Map<String, ?> getList() {
+        try {
+            Plugin p = getMultiverse();
+            Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
+            Field f = mvWorldManager.getClass().getDeclaredField("worldsFromTheConfig");
+            f.setAccessible(true);
+            return (Map<String, ?>) f.get(mvWorldManager);
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public void removeFromConfig(World world) {
+        if (!isSupported()) {
+            return;
+        }
+
+        getList().remove(world.getName());
+        saveConfig();
+    }
+
+    public void removeFromConfig(String world) {
+        if (!isSupported()) {
+            return;
+        }
+
+        getList().remove(world);
+        saveConfig();
+    }
+
+    public void saveConfig() {
+        try {
+            Plugin p = getMultiverse();
+            Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
+            mvWorldManager.getClass().getDeclaredMethod("saveWorldsConfig").invoke(mvWorldManager);
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+    }
+
+    public void assignWorldType(String worldName, String type) {
+        worldNameTypes.put(worldName, type);
+    }
+
+    public String getWorldNameType(String worldName, String defaultType) {
+        try {
+            String t = worldNameTypes.get(worldName);
+            return t == null ? defaultType : t;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            return defaultType;
+        }
+    }
+
+    public boolean isSupported() {
+        return getMultiverse() != null;
+    }
+
+    public Plugin getMultiverse() {
+
+        return Bukkit.getPluginManager().getPlugin("Multiverse-Core");
+    }
+
+    public String envName(World.Environment environment) {
+        if (environment == null) {
+            return "normal";
+        }
+
+        return switch (environment) {
+            case NORMAL -> "normal";
+            case NETHER -> "nether";
+            case THE_END -> "end";
+            default -> environment.toString().toLowerCase();
+        };
+
+    }
+}

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

@@ -0,0 +1,59 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import io.lumine.mythic.bukkit.MythicBukkit;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.plugin.Plugin;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+
+public class MythicMobsLink {
+
+    public MythicMobsLink() {
+
+    }
+
+    public boolean isEnabled() {
+        return getPlugin() != null;
+    }
+
+    public Plugin getPlugin() {
+        return Bukkit.getPluginManager().getPlugin("MythicMobs");
+    }
+
+    /**
+     * Spawn a mythic mob at this location
+     *
+     * @param mob      The mob
+     * @param location The location
+     * @return The mob, or null if it can't be spawned
+     */
+    public @Nullable
+    Entity spawnMob(String mob, Location location) {
+        return isEnabled() ? MythicBukkit.inst().getMobManager().spawnMob(mob, location).getEntity().getBukkitEntity() : null;
+    }
+
+    public Collection<String> getMythicMobTypes() {
+        return isEnabled() ? MythicBukkit.inst().getMobManager().getMobNames() : null;
+    }
+}

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

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

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

@@ -0,0 +1,75 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.engine.data.cache.AtomicCache;
+import com.volmit.iris.util.data.Cuboid;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.InvocationTargetException;
+
+public class WorldEditLink {
+    private static final AtomicCache<Boolean> active = new AtomicCache<>();
+
+    public static Cuboid getSelection(Player p) {
+        if (!hasWorldEdit())
+            return null;
+
+        try {
+            Object instance = Class.forName("com.sk89q.worldedit.WorldEdit").getDeclaredMethod("getInstance").invoke(null);
+            Object sessionManager = instance.getClass().getDeclaredMethod("getSessionManager").invoke(instance);
+            Class<?> bukkitAdapter = Class.forName("com.sk89q.worldedit.bukkit.BukkitAdapter");
+            Object world = bukkitAdapter.getDeclaredMethod("adapt", World.class).invoke(null, p.getWorld());
+            Object player = bukkitAdapter.getDeclaredMethod("adapt", Player.class).invoke(null, p);
+            Object localSession = sessionManager.getClass().getDeclaredMethod("getIfPresent", Class.forName("com.sk89q.worldedit.session.SessionOwner")).invoke(sessionManager, player);
+            if (localSession == null) return null;
+
+            Object region = null;
+            try {
+                region = localSession.getClass().getDeclaredMethod("getSelection", Class.forName("com.sk89q.worldedit.world.World")).invoke(localSession, world);
+            } catch (InvocationTargetException ignored) {
+            }
+            if (region == null) return null;
+
+            Object min = region.getClass().getDeclaredMethod("getMinimumPoint").invoke(region);
+            Object max = region.getClass().getDeclaredMethod("getMaximumPoint").invoke(region);
+            return new Cuboid(p.getWorld(),
+                    (int) min.getClass().getDeclaredMethod("x").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("y").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("z").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("x").invoke(max),
+                    (int) min.getClass().getDeclaredMethod("y").invoke(max),
+                    (int) min.getClass().getDeclaredMethod("z").invoke(max)
+            );
+        } catch (Throwable e) {
+            Iris.error("Could not get selection");
+            e.printStackTrace();
+            active.reset();
+            active.aquire(() -> false);
+        }
+        return null;
+    }
+
+    public static boolean hasWorldEdit() {
+        return active.aquire(() -> Bukkit.getPluginManager().isPluginEnabled("WorldEdit"));
+    }
+}

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

@@ -0,0 +1,166 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.loader;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.engine.object.IrisImage;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.data.KCache;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.util.Set;
+
+public class ImageResourceLoader extends ResourceLoader<IrisImage> {
+    public ImageResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
+        super(root, idm, folderName, resourceTypeName, IrisImage.class);
+        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getObjectLoaderCacheSize());
+    }
+
+    public boolean supportsSchemas() {
+        return false;
+    }
+
+    public long getSize() {
+        return loadCache.getSize();
+    }
+
+    public long getTotalStorage() {
+        return getSize();
+    }
+
+    protected IrisImage loadFile(File j, String name) {
+        try {
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            BufferedImage bu = ImageIO.read(j);
+            IrisImage img = new IrisImage(bu);
+            img.setLoadFile(j);
+            img.setLoader(manager);
+            img.setLoadKey(name);
+            logLoad(j, img);
+            tlt.addAndGet(p.getMilliseconds());
+            return img;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+    void getPNGFiles(File directory, Set<String> m) {
+        for (File file : directory.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".png")) {
+                m.add(file.getName().replaceAll("\\Q.png\\E", ""));
+            } else if (file.isDirectory()) {
+                getPNGFiles(file, m);
+            }
+        }
+    }
+
+
+    public String[] getPossibleKeys() {
+        if (possibleKeys != null) {
+            return possibleKeys;
+        }
+
+        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+        KSet<String> m = new KSet<>();
+
+
+        for (File i : getFolders()) {
+            getPNGFiles(i, m);
+        }
+
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".png")) {
+//                    m.add(j.getName().replaceAll("\\Q.png\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".png")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.png\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".png")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.png\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+
+        KList<String> v = new KList<>(m);
+        possibleKeys = v.toArray(new String[0]);
+        return possibleKeys;
+    }
+
+    public File findFile(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return j;
+                }
+            }
+
+            File file = new File(i, name + ".png");
+
+            if (file.exists()) {
+                return file;
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisImage load(String name) {
+        return load(name, true);
+    }
+
+    private IrisImage loadRaw(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return loadFile(j, name);
+                }
+            }
+
+            File file = new File(i, name + ".png");
+
+            if (file.exists()) {
+                return loadFile(file, name);
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisImage load(String name, boolean warn) {
+        return loadCache.get(name);
+    }
+}

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

@@ -0,0 +1,501 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.loader;
+
+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.Iris;
+import com.volmit.iris.engine.data.cache.AtomicCache;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.*;
+import com.volmit.iris.engine.object.annotations.Snippet;
+import com.volmit.iris.engine.object.matter.IrisMatterObject;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.context.IrisContext;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import lombok.Data;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Objects;
+import java.util.function.Function;
+
+@Data
+public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
+    private static final KMap<File, IrisData> dataLoaders = new KMap<>();
+    private final File dataFolder;
+    private final int id;
+    private boolean closed = false;
+    private ResourceLoader<IrisBiome> biomeLoader;
+    private ResourceLoader<IrisLootTable> lootLoader;
+    private ResourceLoader<IrisRegion> regionLoader;
+    private ResourceLoader<IrisDimension> dimensionLoader;
+    private ResourceLoader<IrisGenerator> generatorLoader;
+    private ResourceLoader<IrisJigsawPiece> jigsawPieceLoader;
+    private ResourceLoader<IrisJigsawPool> jigsawPoolLoader;
+    private ResourceLoader<IrisJigsawStructure> jigsawStructureLoader;
+    private ResourceLoader<IrisEntity> entityLoader;
+    private ResourceLoader<IrisMarker> markerLoader;
+    private ResourceLoader<IrisSpawner> spawnerLoader;
+    private ResourceLoader<IrisMod> modLoader;
+    private ResourceLoader<IrisBlockData> blockLoader;
+    private ResourceLoader<IrisExpression> expressionLoader;
+    private ResourceLoader<IrisObject> objectLoader;
+    private ResourceLoader<IrisMatterObject> matterLoader;
+    private ResourceLoader<IrisImage> imageLoader;
+    private ResourceLoader<IrisScript> scriptLoader;
+    private ResourceLoader<IrisCave> caveLoader;
+    private ResourceLoader<IrisRavine> ravineLoader;
+    private ResourceLoader<IrisMatterObject> matterObjectLoader;
+    private KMap<String, KList<String>> possibleSnippets;
+    private Gson gson;
+    private Gson snippetLoader;
+    private GsonBuilder builder;
+    private KMap<Class<? extends IrisRegistrant>, ResourceLoader<? extends IrisRegistrant>> loaders = new KMap<>();
+    private Engine engine;
+
+    private IrisData(File dataFolder) {
+        this.engine = null;
+        this.dataFolder = dataFolder;
+        this.id = RNG.r.imax();
+        hotloaded();
+    }
+
+    public static IrisData get(File dataFolder) {
+        return dataLoaders.computeIfAbsent(dataFolder, IrisData::new);
+    }
+
+    public static void dereference() {
+        dataLoaders.v().forEach(IrisData::cleanupEngine);
+    }
+
+    public static int cacheSize() {
+        int m = 0;
+        for (IrisData i : dataLoaders.values()) {
+            for (ResourceLoader<?> j : i.getLoaders().values()) {
+                m += j.getLoadCache().getSize();
+            }
+        }
+
+        return m;
+    }
+
+    private static void printData(ResourceLoader<?> rl) {
+        Iris.warn("  " + rl.getResourceTypeName() + " @ /" + rl.getFolderName() + ": Cache=" + rl.getLoadCache().getSize() + " Folders=" + rl.getFolders().size());
+    }
+
+    public static IrisObject loadAnyObject(String key) {
+        return loadAny(key, (dm) -> dm.getObjectLoader().load(key, false));
+    }
+
+    public static IrisMatterObject loadAnyMatter(String key) {
+        return loadAny(key, (dm) -> dm.getMatterLoader().load(key, false));
+    }
+
+    public static IrisBiome loadAnyBiome(String key) {
+        return loadAny(key, (dm) -> dm.getBiomeLoader().load(key, false));
+    }
+
+    public static IrisExpression loadAnyExpression(String key) {
+        return loadAny(key, (dm) -> dm.getExpressionLoader().load(key, false));
+    }
+
+    public static IrisMod loadAnyMod(String key) {
+        return loadAny(key, (dm) -> dm.getModLoader().load(key, false));
+    }
+
+    public static IrisJigsawPiece loadAnyJigsawPiece(String key) {
+        return loadAny(key, (dm) -> dm.getJigsawPieceLoader().load(key, false));
+    }
+
+    public static IrisJigsawPool loadAnyJigsawPool(String key) {
+        return loadAny(key, (dm) -> dm.getJigsawPoolLoader().load(key, false));
+    }
+
+    public static IrisEntity loadAnyEntity(String key) {
+        return loadAny(key, (dm) -> dm.getEntityLoader().load(key, false));
+    }
+
+    public static IrisLootTable loadAnyLootTable(String key) {
+        return loadAny(key, (dm) -> dm.getLootLoader().load(key, false));
+    }
+
+    public static IrisBlockData loadAnyBlock(String key) {
+        return loadAny(key, (dm) -> dm.getBlockLoader().load(key, false));
+    }
+
+    public static IrisSpawner loadAnySpaner(String key) {
+        return loadAny(key, (dm) -> dm.getSpawnerLoader().load(key, false));
+    }
+
+    public static IrisScript loadAnyScript(String key) {
+        return loadAny(key, (dm) -> dm.getScriptLoader().load(key, false));
+    }
+
+    public static IrisRavine loadAnyRavine(String key) {
+        return loadAny(key, (dm) -> dm.getRavineLoader().load(key, false));
+    }
+
+    public static IrisRegion loadAnyRegion(String key) {
+        return loadAny(key, (dm) -> dm.getRegionLoader().load(key, false));
+    }
+
+    public static IrisMarker loadAnyMarker(String key) {
+        return loadAny(key, (dm) -> dm.getMarkerLoader().load(key, false));
+    }
+
+    public static IrisCave loadAnyCave(String key) {
+        return loadAny(key, (dm) -> dm.getCaveLoader().load(key, false));
+    }
+
+    public static IrisImage loadAnyImage(String key) {
+        return loadAny(key, (dm) -> dm.getImageLoader().load(key, false));
+    }
+
+    public static IrisDimension loadAnyDimension(String key) {
+        return loadAny(key, (dm) -> dm.getDimensionLoader().load(key, false));
+    }
+
+    public static IrisJigsawStructure loadAnyJigsawStructure(String key) {
+        return loadAny(key, (dm) -> dm.getJigsawStructureLoader().load(key, false));
+    }
+
+    public static IrisGenerator loadAnyGenerator(String key) {
+        return loadAny(key, (dm) -> dm.getGeneratorLoader().load(key, false));
+    }
+
+    public static <T extends IrisRegistrant> T loadAny(String key, Function<IrisData, T> v) {
+        try {
+            for (File i : Objects.requireNonNull(Iris.instance.getDataFolder("packs").listFiles())) {
+                if (i.isDirectory()) {
+                    IrisData dm = get(i);
+                    T t = v.apply(dm);
+
+                    if (t != null) {
+                        return t;
+                    }
+                }
+            }
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public ResourceLoader<?> getTypedLoaderFor(File f) {
+        String[] k = f.getPath().split("\\Q" + File.separator + "\\E");
+
+        for (String i : k) {
+            for (ResourceLoader<?> j : loaders.values()) {
+                if (j.getFolderName().equals(i)) {
+                    return j;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public void cleanupEngine() {
+        if (engine != null && engine.isClosed()) {
+            engine = null;
+            Iris.debug("Dereferenced Data<Engine> " + getId() + " " + getDataFolder());
+        }
+    }
+
+    public void preprocessObject(IrisRegistrant t) {
+        try {
+            IrisContext ctx = IrisContext.get();
+            Engine engine = this.engine;
+
+            if (engine == null && ctx != null && ctx.getEngine() != null) {
+                engine = ctx.getEngine();
+            }
+
+            if (engine == null && t.getPreprocessors().isNotEmpty()) {
+                Iris.error("Failed to preprocess object " + t.getLoadKey() + " because there is no engine context here. (See stack below)");
+                try {
+                    throw new RuntimeException();
+                } catch (Throwable ex) {
+                    ex.printStackTrace();
+                }
+            }
+
+            if (engine != null && t.getPreprocessors().isNotEmpty()) {
+                synchronized (this) {
+                    engine.getExecution().getAPI().setPreprocessorObject(t);
+
+                    for (String i : t.getPreprocessors()) {
+                        engine.getExecution().execute(i);
+                        Iris.debug("Loader<" + C.GREEN + t.getTypeName() + C.LIGHT_PURPLE + "> iprocess " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in <rainbow>" + i);
+                    }
+                }
+            }
+        } catch (Throwable e) {
+            Iris.error("Failed to preprocess object!");
+            e.printStackTrace();
+        }
+    }
+
+    public void close() {
+        closed = true;
+        dump();
+    }
+
+    public IrisData copy() {
+        return IrisData.get(dataFolder);
+    }
+
+    private <T extends IrisRegistrant> ResourceLoader<T> registerLoader(Class<T> registrant) {
+        try {
+            IrisRegistrant rr = registrant.getConstructor().newInstance();
+            ResourceLoader<T> r = null;
+            if (registrant.equals(IrisObject.class)) {
+                r = (ResourceLoader<T>) new ObjectResourceLoader(dataFolder, this, rr.getFolderName(),
+                        rr.getTypeName());
+            } else if (registrant.equals(IrisMatterObject.class)) {
+                r = (ResourceLoader<T>) new MatterObjectResourceLoader(dataFolder, this, rr.getFolderName(),
+                        rr.getTypeName());
+            } else if (registrant.equals(IrisScript.class)) {
+                r = (ResourceLoader<T>) new ScriptResourceLoader(dataFolder, this, rr.getFolderName(),
+                        rr.getTypeName());
+            } else if (registrant.equals(IrisImage.class)) {
+                r = (ResourceLoader<T>) new ImageResourceLoader(dataFolder, this, rr.getFolderName(),
+                        rr.getTypeName());
+            } else {
+                J.attempt(() -> registrant.getConstructor().newInstance().registerTypeAdapters(builder));
+                r = new ResourceLoader<>(dataFolder, this, rr.getFolderName(), rr.getTypeName(), registrant);
+            }
+
+            loaders.put(registrant, r);
+
+            return r;
+        } catch (Throwable e) {
+            e.printStackTrace();
+            Iris.error("Failed to create loader! " + registrant.getCanonicalName());
+        }
+
+        return null;
+    }
+
+    public synchronized void hotloaded() {
+        possibleSnippets = new KMap<>();
+        builder = new GsonBuilder()
+                .addDeserializationExclusionStrategy(this)
+                .addSerializationExclusionStrategy(this)
+                .setLenient()
+                .registerTypeAdapterFactory(this)
+                .setPrettyPrinting();
+        loaders.clear();
+        File packs = dataFolder;
+        packs.mkdirs();
+        this.lootLoader = registerLoader(IrisLootTable.class);
+        this.spawnerLoader = registerLoader(IrisSpawner.class);
+        this.entityLoader = registerLoader(IrisEntity.class);
+        this.regionLoader = registerLoader(IrisRegion.class);
+        this.biomeLoader = registerLoader(IrisBiome.class);
+        this.modLoader = registerLoader(IrisMod.class);
+        this.dimensionLoader = registerLoader(IrisDimension.class);
+        this.jigsawPoolLoader = registerLoader(IrisJigsawPool.class);
+        this.jigsawStructureLoader = registerLoader(IrisJigsawStructure.class);
+        this.jigsawPieceLoader = registerLoader(IrisJigsawPiece.class);
+        this.generatorLoader = registerLoader(IrisGenerator.class);
+        this.caveLoader = registerLoader(IrisCave.class);
+        this.markerLoader = registerLoader(IrisMarker.class);
+        this.ravineLoader = registerLoader(IrisRavine.class);
+        this.blockLoader = registerLoader(IrisBlockData.class);
+        this.expressionLoader = registerLoader(IrisExpression.class);
+        this.objectLoader = registerLoader(IrisObject.class);
+        this.imageLoader = registerLoader(IrisImage.class);
+        this.scriptLoader = registerLoader(IrisScript.class);
+        this.matterObjectLoader = registerLoader(IrisMatterObject.class);
+        gson = builder.create();
+    }
+
+    public void dump() {
+        for (ResourceLoader<?> i : loaders.values()) {
+            i.clearCache();
+        }
+    }
+
+    public void clearLists() {
+        for (ResourceLoader<?> i : loaders.values()) {
+            i.clearList();
+        }
+    }
+
+    public String toLoadKey(File f) {
+        if (f.getPath().startsWith(getDataFolder().getPath())) {
+            String[] full = f.getPath().split("\\Q" + File.separator + "\\E");
+            String[] df = getDataFolder().getPath().split("\\Q" + File.separator + "\\E");
+            StringBuilder g = new StringBuilder();
+            boolean m = true;
+            for (int i = 0; i < full.length; i++) {
+                if (i >= df.length) {
+                    if (m) {
+                        m = false;
+                        continue;
+                    }
+
+                    g.append("/").append(full[i]);
+                }
+            }
+
+            return g.substring(1).split("\\Q.\\E")[0];
+        } else {
+            Iris.error("Forign file from loader " + f.getPath() + " (loader realm: " + getDataFolder().getPath() + ")");
+        }
+
+        Iris.error("Failed to load " + f.getPath() + " (loader realm: " + getDataFolder().getPath() + ")");
+
+        return null;
+    }
+
+    @Override
+    public boolean shouldSkipField(FieldAttributes f) {
+        return false;
+    }
+
+    @Override
+    public boolean shouldSkipClass(Class<?> c) {
+        if (c.equals(AtomicCache.class)) {
+            return true;
+        } else return c.equals(ChronoLatch.class);
+    }
+
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+        if (!typeToken.getRawType().isAnnotationPresent(Snippet.class)) {
+            return null;
+        }
+
+        String snippetType = typeToken.getRawType().getDeclaredAnnotation(Snippet.class).value();
+
+        return new TypeAdapter<>() {
+            @Override
+            public void write(JsonWriter jsonWriter, T t) throws IOException {
+                gson.getDelegateAdapter(IrisData.this, typeToken).write(jsonWriter, t);
+            }
+
+            @Override
+            public T read(JsonReader reader) throws IOException {
+                TypeAdapter<T> adapter = gson.getDelegateAdapter(IrisData.this, typeToken);
+
+                if (reader.peek().equals(JsonToken.STRING)) {
+                    String r = reader.nextString();
+
+                    if (r.startsWith("snippet/" + snippetType + "/")) {
+                        File f = new File(getDataFolder(), r + ".json");
+
+                        if (f.exists()) {
+                            try {
+                                JsonReader snippetReader = new JsonReader(new FileReader(f));
+                                return adapter.read(snippetReader);
+                            } catch (Throwable e) {
+                                Iris.error("Couldn't read snippet " + r + " in " + reader.getPath() + " (" + e.getMessage() + ")");
+                            }
+                        } else {
+                            Iris.error("Couldn't find snippet " + r + " in " + reader.getPath());
+                        }
+                    }
+
+                    return null;
+                }
+
+                try {
+                    return adapter.read(reader);
+                } catch (Throwable e) {
+                    Iris.error("Failed to read " + typeToken.getRawType().getCanonicalName() + "... faking objects a little to load the file at least.");
+                    try {
+                        return (T) typeToken.getRawType().getConstructor().newInstance();
+                    } catch (Throwable ignored) {
+
+                    }
+                }
+                return null;
+            }
+        };
+    }
+
+    public KList<String> getPossibleSnippets(String f) {
+        return possibleSnippets.computeIfAbsent(f, (k) -> {
+            KList<String> l = new KList<>();
+
+            File snippetFolder = new File(getDataFolder(), "snippet/" + f);
+
+            if (snippetFolder.exists() && snippetFolder.isDirectory()) {
+                for (File i : snippetFolder.listFiles()) {
+                    l.add("snippet/" + f + "/" + i.getName().split("\\Q.\\E")[0]);
+                }
+            }
+
+            return l;
+        });
+    }
+
+    public boolean isClosed() {
+        return closed;
+    }
+
+    public void savePrefetch(Engine engine) {
+        BurstExecutor b = MultiBurst.burst.burst(loaders.size());
+
+        for (ResourceLoader<?> i : loaders.values()) {
+            b.queue(() -> {
+                try {
+                    i.saveFirstAccess(engine);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+
+        b.complete();
+        Iris.info("Saved Prefetch Cache to speed up future world startups");
+    }
+
+    public void loadPrefetch(Engine engine) {
+        BurstExecutor b = MultiBurst.burst.burst(loaders.size());
+
+        for (ResourceLoader<?> i : loaders.values()) {
+            b.queue(() -> {
+                try {
+                    i.loadFirstAccess(engine);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+
+        b.complete();
+        Iris.info("Loaded Prefetch Cache to reduce generation disk use.");
+    }
+}

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

@@ -0,0 +1,67 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.loader;
+
+import com.google.gson.GsonBuilder;
+import com.volmit.iris.Iris;
+import com.volmit.iris.engine.object.IrisScript;
+import com.volmit.iris.engine.object.annotations.ArrayType;
+import com.volmit.iris.engine.object.annotations.Desc;
+import com.volmit.iris.engine.object.annotations.RegistryListResource;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.plugin.VolmitSender;
+import lombok.Data;
+
+import java.awt.*;
+import java.io.File;
+
+@Data
+public abstract class IrisRegistrant {
+    @Desc("Preprocess this object in-memory when it's loaded, run scripts using the variable 'Iris.getPreprocessorObject()' and modify properties about this object before it's used.")
+    @RegistryListResource(IrisScript.class)
+    @ArrayType(min = 1, type = String.class)
+    private KList<String> preprocessors = new KList<>();
+
+    private transient IrisData loader;
+
+    private transient String loadKey;
+
+    private transient File loadFile;
+
+    public abstract String getFolderName();
+
+    public abstract String getTypeName();
+
+    public void registerTypeAdapters(GsonBuilder builder) {
+
+    }
+
+    public File openInVSCode() {
+        try {
+            Desktop.getDesktop().open(getLoadFile());
+        } catch (Throwable e) {
+            Iris.reportError(e);
+        }
+
+        return getLoadFile();
+    }
+
+    public abstract void scanForErrors(JSONObject p, VolmitSender sender);
+}

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

@@ -0,0 +1,176 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.loader;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.engine.object.matter.IrisMatterObject;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.data.KCache;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+
+import java.io.File;
+
+public class MatterObjectResourceLoader extends ResourceLoader<IrisMatterObject> {
+    private String[] possibleKeys;
+
+    public MatterObjectResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
+        super(root, idm, folderName, resourceTypeName, IrisMatterObject.class);
+        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getObjectLoaderCacheSize());
+    }
+
+    public boolean supportsSchemas() {
+        return false;
+    }
+
+    public long getSize() {
+        return loadCache.getSize();
+    }
+
+    public long getTotalStorage() {
+        return getSize();
+    }
+
+    protected IrisMatterObject loadFile(File j, String name) {
+        try {
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            IrisMatterObject t = IrisMatterObject.from(j);
+            t.setLoadKey(name);
+            t.setLoader(manager);
+            t.setLoadFile(j);
+            logLoad(j, t);
+            tlt.addAndGet(p.getMilliseconds());
+            return t;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+    private void findMatFiles(File dir, KSet<String> m) {
+        for (File file : dir.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".mat")) {
+                m.add(file.getName().replaceAll("\\Q.mat\\E", ""));
+            } else if (file.isDirectory()) {
+                findMatFiles(file, m);
+            }
+        }
+    }
+
+    public String[] getPossibleKeys() {
+        if (possibleKeys != null) {
+            return possibleKeys;
+        }
+
+        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+        KSet<String> m = new KSet<>();
+
+        for (File folder : getFolders()) {
+            findMatFiles(folder, m);
+        }
+
+        KList<String> v = new KList<>(m);
+        possibleKeys = v.toArray(new String[0]);
+        return possibleKeys;
+    }
+
+
+//    public String[] getPossibleKeys() {
+//        if (possibleKeys != null) {
+//            return possibleKeys;
+//        }
+//
+//        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+//        KSet<String> m = new KSet<>();
+//
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".mat")) {
+//                    m.add(j.getName().replaceAll("\\Q.mat\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".mat")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.mat\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".mat")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.mat\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        KList<String> v = new KList<>(m);
+//        possibleKeys = v.toArray(new String[0]);
+//        return possibleKeys;
+//    }
+
+    public File findFile(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return j;
+                }
+            }
+
+            File file = new File(i, name + ".mat");
+
+            if (file.exists()) {
+                return file;
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisMatterObject load(String name) {
+        return load(name, true);
+    }
+
+    private IrisMatterObject loadRaw(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return loadFile(j, name);
+                }
+            }
+
+            File file = new File(i, name + ".mat");
+
+            if (file.exists()) {
+                return loadFile(file, name);
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisMatterObject load(String name, boolean warn) {
+        return loadCache.get(name);
+    }
+}

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

@@ -0,0 +1,140 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.loader;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.engine.object.IrisObject;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.data.KCache;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+
+import java.io.File;
+
+public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
+    public ObjectResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
+        super(root, idm, folderName, resourceTypeName, IrisObject.class);
+        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getObjectLoaderCacheSize());
+    }
+
+    public boolean supportsSchemas() {
+        return false;
+    }
+
+    public long getSize() {
+        return loadCache.getSize();
+    }
+
+    public long getTotalStorage() {
+        return getSize();
+    }
+
+    protected IrisObject loadFile(File j, String name) {
+        try {
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            IrisObject t = new IrisObject(0, 0, 0);
+            t.setLoadKey(name);
+            t.setLoader(manager);
+            t.setLoadFile(j);
+            t.read(j);
+            logLoad(j, t);
+            tlt.addAndGet(p.getMilliseconds());
+            return t;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+    public String[] getPossibleKeys() {
+        if (possibleKeys != null) {
+            return possibleKeys;
+        }
+        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+        KSet<String> m = new KSet<>();
+        for (File i : getFolders()) {
+            m.addAll(getFiles(i, ".iob", true));
+        }
+        possibleKeys = m.toArray(new String[0]);
+        return possibleKeys;
+    }
+
+    private KList<String> getFiles(File dir, String ext, boolean skipDirName) {
+        KList<String> paths = new KList<>();
+        String name = skipDirName ? "" : dir.getName() + "/";
+        for (File f : dir.listFiles()) {
+            if (f.isFile() && f.getName().endsWith(ext)) {
+                paths.add(name + f.getName().replaceAll("\\Q" + ext + "\\E", ""));
+            } else if (f.isDirectory()) {
+                getFiles(f, ext, false).forEach(e -> paths.add(name + e));
+            }
+        }
+        return paths;
+    }
+
+    public File findFile(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return j;
+                }
+            }
+
+            File file = new File(i, name + ".iob");
+
+            if (file.exists()) {
+                return file;
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisObject load(String name) {
+        return load(name, true);
+    }
+
+    private IrisObject loadRaw(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return loadFile(j, name);
+                }
+            }
+
+            File file = new File(i, name + ".iob");
+
+            if (file.exists()) {
+                return loadFile(file, name);
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisObject load(String name, boolean warn) {
+        return loadCache.get(name);
+    }
+}

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

@@ -0,0 +1,475 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.loader;
+
+import com.google.common.util.concurrent.AtomicDouble;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.project.SchemaBuilder;
+import com.volmit.iris.core.service.PreservationSVC;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.framework.MeteredCache;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.data.KCache;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.CustomOutputStream;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.json.JSONArray;
+import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import java.io.*;
+import java.util.Locale;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+@Data
+@EqualsAndHashCode(exclude = "manager")
+@ToString(exclude = "manager")
+public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
+    public static final AtomicDouble tlt = new AtomicDouble(0);
+    private static final int CACHE_SIZE = 100000;
+    protected final AtomicReference<KList<File>> folderCache;
+    protected KSet<String> firstAccess;
+    protected File root;
+    protected String folderName;
+    protected String resourceTypeName;
+    protected KCache<String, T> loadCache;
+    protected Class<? extends T> objectClass;
+    protected String cname;
+    protected String[] possibleKeys = null;
+    protected IrisData manager;
+    protected AtomicInteger loads;
+    protected ChronoLatch sec;
+
+    public ResourceLoader(File root, IrisData manager, String folderName, String resourceTypeName, Class<? extends T> objectClass) {
+        this.manager = manager;
+        firstAccess = new KSet<>();
+        folderCache = new AtomicReference<>();
+        sec = new ChronoLatch(5000);
+        loads = new AtomicInteger();
+        this.objectClass = objectClass;
+        cname = objectClass.getCanonicalName();
+        this.resourceTypeName = resourceTypeName;
+        this.root = root;
+        this.folderName = folderName;
+        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getResourceLoaderCacheSize());
+        Iris.debug("Loader<" + C.GREEN + resourceTypeName + C.LIGHT_PURPLE + "> created in " + C.RED + "IDM/" + manager.getId() + C.LIGHT_PURPLE + " on " + C.GRAY + manager.getDataFolder().getPath());
+        Iris.service(PreservationSVC.class).registerCache(this);
+    }
+
+    public JSONObject buildSchema() {
+        Iris.debug("Building Schema " + objectClass.getSimpleName() + " " + root.getPath());
+        JSONObject o = new JSONObject();
+        KList<String> fm = new KList<>();
+
+        for (int g = 1; g < 8; g++) {
+            fm.add("/" + folderName + Form.repeat("/*", g) + ".json");
+        }
+
+        o.put("fileMatch", new JSONArray(fm.toArray()));
+        o.put("url", "./.iris/schema/" + getFolderName() + "-schema.json");
+        File a = new File(getManager().getDataFolder(), ".iris/schema/" + getFolderName() + "-schema.json");
+        J.attemptAsync(() -> IO.writeAll(a, new SchemaBuilder(objectClass, manager).construct().toString(4)));
+
+        return o;
+    }
+
+    public File findFile(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return j;
+                }
+            }
+
+            File file = new File(i, name + ".json");
+
+            if (file.exists()) {
+                return file;
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public void logLoad(File path, T t) {
+        loads.getAndIncrement();
+
+        if (loads.get() == 1) {
+            sec.flip();
+        }
+
+        if (sec.flip()) {
+            J.a(() -> {
+                Iris.verbose("Loaded " + C.WHITE + loads.get() + " " + resourceTypeName + (loads.get() == 1 ? "" : "s") + C.GRAY + " (" + Form.f(getLoadCache().getSize()) + " " + resourceTypeName + (loadCache.getSize() == 1 ? "" : "s") + " Loaded)");
+                loads.set(0);
+            });
+        }
+
+        Iris.debug("Loader<" + C.GREEN + resourceTypeName + C.LIGHT_PURPLE + "> iload " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in " + C.GRAY + t.getLoadFile().getPath() + C.LIGHT_PURPLE + " TLT: " + C.RED + Form.duration(tlt.get(), 2));
+    }
+
+    public void failLoad(File path, Throwable e) {
+        J.a(() -> Iris.warn("Couldn't Load " + resourceTypeName + " file: " + path.getPath() + ": " + e.getMessage()));
+    }
+
+    private KList<File> matchAllFiles(File root, Predicate<File> f) {
+        KList<File> fx = new KList<>();
+        matchFiles(root, fx, f);
+        return fx;
+    }
+
+    private void matchFiles(File at, KList<File> files, Predicate<File> f) {
+        if (at.isDirectory()) {
+            for (File i : at.listFiles()) {
+                matchFiles(i, files, f);
+            }
+        } else {
+            if (f.test(at)) {
+                files.add(at);
+            }
+        }
+    }
+
+    public String[] getPossibleKeys() {
+        if (possibleKeys != null) {
+            return possibleKeys;
+        }
+
+        KSet<String> m = new KSet<>();
+        KList<File> files = getFolders();
+
+        if (files == null) {
+            possibleKeys = new String[0];
+            return possibleKeys;
+        }
+
+        for (File i : files) {
+            for (File j : matchAllFiles(i, (f) -> f.getName().endsWith(".json"))) {
+                m.add(i.toURI().relativize(j.toURI()).getPath().replaceAll("\\Q.json\\E", ""));
+            }
+        }
+
+        KList<String> v = new KList<>(m);
+        possibleKeys = v.toArray(new String[0]);
+        return possibleKeys;
+    }
+
+    public long count() {
+        return loadCache.getSize();
+    }
+
+    protected T loadFile(File j, String name) {
+        try {
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            T t = getManager().getGson()
+                    .fromJson(preprocess(new JSONObject(IO.readAll(j))).toString(0), objectClass);
+            t.setLoadKey(name);
+            t.setLoadFile(j);
+            t.setLoader(manager);
+            getManager().preprocessObject(t);
+            logLoad(j, t);
+            tlt.addAndGet(p.getMilliseconds());
+            return t;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            failLoad(j, e);
+            return null;
+        }
+    }
+
+    protected JSONObject preprocess(JSONObject j) {
+        return j;
+    }
+
+    public Stream<T> streamAll(Stream<String> s) {
+        return s.map(this::load);
+    }
+
+    public KList<T> loadAll(KList<String> s) {
+        KList<T> m = new KList<>();
+
+        for (String i : s) {
+            T t = load(i);
+
+            if (t != null) {
+                m.add(t);
+            }
+        }
+
+        return m;
+    }
+
+    public KList<T> loadAllParallel(KList<String> s) {
+        KList<T> m = new KList<>();
+        BurstExecutor burst = MultiBurst.burst.burst(s.size());
+
+        for (String i : s) {
+            burst.queue(() -> {
+                T t = load(i);
+
+                if (t != null) {
+                    m.add(t);
+                }
+            });
+        }
+
+        burst.complete();
+        return m;
+    }
+
+    public KList<T> loadAll(KList<String> s, Consumer<T> postLoad) {
+        KList<T> m = new KList<>();
+
+        for (String i : s) {
+            T t = load(i);
+
+            if (t != null) {
+                m.add(t);
+                postLoad.accept(t);
+            }
+        }
+
+        return m;
+    }
+
+    public KList<T> loadAll(String[] s) {
+        KList<T> m = new KList<>();
+
+        for (String i : s) {
+            T t = load(i);
+
+            if (t != null) {
+                m.add(t);
+            }
+        }
+
+        return m;
+    }
+
+    public T load(String name) {
+        return load(name, true);
+    }
+
+    private T loadRaw(String name) {
+        for (File i : getFolders(name)) {
+            //noinspection ConstantConditions
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return loadFile(j, name);
+                }
+            }
+
+            File file = new File(i, name + ".json");
+
+            if (file.exists()) {
+                return loadFile(file, name);
+            }
+        }
+
+        return null;
+    }
+
+    public T load(String name, boolean warn) {
+        if (name == null) {
+            return null;
+        }
+
+        if (name.trim().isEmpty()) {
+            return null;
+        }
+
+        firstAccess.add(name);
+        return loadCache.get(name);
+    }
+
+    public void loadFirstAccess(Engine engine) throws IOException {
+        String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
+        File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
+
+        if (!file.exists()) {
+            return;
+        }
+
+        FileInputStream fin = new FileInputStream(file);
+        GZIPInputStream gzi = new GZIPInputStream(fin);
+        DataInputStream din = new DataInputStream(gzi);
+        int m = din.readInt();
+        KList<String> s = new KList<>();
+
+        for (int i = 0; i < m; i++) {
+            s.add(din.readUTF());
+        }
+
+        din.close();
+        file.deleteOnExit();
+        Iris.info("Loading " + s.size() + " prefetch " + getFolderName());
+        loadAllParallel(s);
+    }
+
+    public void saveFirstAccess(Engine engine) throws IOException {
+        String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
+        File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
+        file.getParentFile().mkdirs();
+        FileOutputStream fos = new FileOutputStream(file);
+        GZIPOutputStream gzo = new CustomOutputStream(fos, 9);
+        DataOutputStream dos = new DataOutputStream(gzo);
+        dos.writeInt(firstAccess.size());
+
+        for (String i : firstAccess) {
+            dos.writeUTF(i);
+        }
+
+        dos.flush();
+        dos.close();
+    }
+
+    public KList<File> getFolders() {
+        synchronized (folderCache) {
+            if (folderCache.get() == null) {
+                KList<File> fc = new KList<>();
+
+                File[] files = root.listFiles();
+                if (files == null) {
+                    throw new IllegalStateException("Failed to list files in " + root);
+                }
+
+                for (File i : files) {
+                    if (i.isDirectory()) {
+                        if (i.getName().equals(folderName)) {
+                            fc.add(i);
+                            break;
+                        }
+                    }
+                }
+
+                folderCache.set(fc);
+            }
+        }
+
+        return folderCache.get();
+    }
+
+    public KList<File> getFolders(String rc) {
+        KList<File> folders = getFolders().copy();
+
+        if (rc.contains(":")) {
+            for (File i : folders.copy()) {
+                if (!rc.startsWith(i.getName() + ":")) {
+                    folders.remove(i);
+                }
+            }
+        }
+
+        return folders;
+    }
+
+    public void clearCache() {
+        possibleKeys = null;
+        loadCache.invalidate();
+        folderCache.set(null);
+    }
+
+    public File fileFor(T b) {
+        for (File i : getFolders()) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(b.getLoadKey())) {
+                    return j;
+                }
+            }
+
+            File file = new File(i, b.getLoadKey() + ".json");
+
+            if (file.exists()) {
+                return file;
+            }
+        }
+
+        return null;
+    }
+
+    public boolean isLoaded(String next) {
+        return loadCache.contains(next);
+    }
+
+    public void clearList() {
+        folderCache.set(null);
+        possibleKeys = null;
+    }
+
+    public KList<String> getPossibleKeys(String arg) {
+        KList<String> f = new KList<>();
+
+        for (String i : getPossibleKeys()) {
+            if (i.equalsIgnoreCase(arg) || i.toLowerCase(Locale.ROOT).startsWith(arg.toLowerCase(Locale.ROOT)) || i.toLowerCase(Locale.ROOT).contains(arg.toLowerCase(Locale.ROOT)) || arg.toLowerCase(Locale.ROOT).contains(i.toLowerCase(Locale.ROOT))) {
+                f.add(i);
+            }
+        }
+
+        return f;
+    }
+
+    public boolean supportsSchemas() {
+        return true;
+    }
+
+    public void clean() {
+
+    }
+
+    public long getSize() {
+        return loadCache.getSize();
+    }
+
+    @Override
+    public KCache<?, ?> getRawCache() {
+        return loadCache;
+    }
+
+    @Override
+    public long getMaxSize() {
+        return loadCache.getMaxSize();
+    }
+
+    @Override
+    public boolean isClosed() {
+        return getManager().isClosed();
+    }
+
+    public long getTotalStorage() {
+        return getSize();
+    }
+}

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

@@ -0,0 +1,170 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.loader;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.engine.object.IrisScript;
+import com.volmit.iris.util.data.KCache;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+
+import java.io.File;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
+    public ScriptResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
+        super(root, idm, folderName, resourceTypeName, IrisScript.class);
+        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getScriptLoaderCacheSize());
+    }
+
+    public boolean supportsSchemas() {
+        return false;
+    }
+
+    public long getSize() {
+        return loadCache.getSize();
+    }
+
+    protected IrisScript loadFile(File j, String name) {
+        try {
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            IrisScript t = new IrisScript(IO.readAll(j));
+            t.setLoadKey(name);
+            t.setLoader(manager);
+            t.setLoadFile(j);
+            logLoad(j, t);
+            tlt.addAndGet(p.getMilliseconds());
+            return t;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+
+    public String[] getPossibleKeys() {
+        if (possibleKeys != null) {
+            return possibleKeys;
+        }
+
+        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+        Set<String> keys = new HashSet<>();
+
+        for (File i : getFolders()) {
+            if (i.isDirectory()) {
+                keys.addAll(getKeysInDirectory(i));
+            }
+        }
+
+        possibleKeys = keys.toArray(new String[0]);
+        return possibleKeys;
+    }
+
+    private Set<String> getKeysInDirectory(File directory) {
+        Set<String> keys = new HashSet<>();
+        for (File file : directory.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".js")) {
+                keys.add(file.getName().replaceAll("\\Q.js\\E", ""));
+            } else if (file.isDirectory()) {
+                keys.addAll(getKeysInDirectory(file));
+            }
+        }
+        return keys;
+    }
+
+//    public String[] getPossibleKeys() {
+//        if (possibleKeys != null) {
+//            return possibleKeys;
+//        }
+//
+//        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+//        KSet<String> m = new KSet<>();
+//
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".js")) {
+//                    m.add(j.getName().replaceAll("\\Q.js\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".js")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.js\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".js")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.js\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        KList<String> v = new KList<>(m);
+//        possibleKeys = v.toArray(new String[0]);
+//        return possibleKeys;
+//    }
+
+    public File findFile(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return j;
+                }
+            }
+
+            File file = new File(i, name + ".js");
+
+            if (file.exists()) {
+                return file;
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    private IrisScript loadRaw(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return loadFile(j, name);
+                }
+            }
+
+            File file = new File(i, name + ".js");
+
+            if (file.exists()) {
+                return loadFile(file, name);
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisScript load(String name, boolean warn) {
+        return loadCache.get(name);
+    }
+}

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

@@ -0,0 +1,28 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms;
+
+@FunctionalInterface
+public interface BiomeBaseInjector {
+    default void setBiome(int x, int z, Object biomeBase) {
+        setBiome(x, 0, z, biomeBase);
+    }
+
+    void setBiome(int x, int y, int z, Object biomeBase);
+}

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

@@ -0,0 +1,48 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms;
+
+import com.volmit.iris.core.pregenerator.PregenListener;
+import com.volmit.iris.server.node.IrisSession;
+import com.volmit.iris.server.packet.work.ChunkPacket;
+import com.volmit.iris.util.documentation.ChunkCoordinates;
+import com.volmit.iris.util.documentation.RegionCoordinates;
+import com.volmit.iris.util.parallel.MultiBurst;
+
+import java.io.Closeable;
+import java.util.concurrent.CompletableFuture;
+
+public interface IHeadless extends Closeable {
+
+    void setSession(IrisSession session);
+
+    int getLoadedChunks();
+
+    @ChunkCoordinates
+    boolean exists(int x, int z);
+
+    @RegionCoordinates
+    CompletableFuture<Void> generateRegion(MultiBurst burst, int x, int z, int maxConcurrent, PregenListener listener);
+
+    @ChunkCoordinates
+    void generateChunk(int x, int z);
+
+    @ChunkCoordinates
+    void addChunk(ChunkPacket packet);
+}

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

@@ -0,0 +1,89 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.nms.v1X.NMSBinding1X;
+import org.bukkit.Bukkit;
+
+import java.util.Map;
+
+public class INMS {
+    private static final Map<String, String> REVISION = Map.of(
+            "1.20.5", "v1_20_R4",
+            "1.20.6", "v1_20_R4",
+            "1.21", "v1_21_R1",
+            "1.21.1", "v1_21_R1"
+    );
+    //@done
+    private static final INMSBinding binding = bind();
+
+    public static INMSBinding get() {
+        return binding;
+    }
+
+    public static String getNMSTag() {
+        if (IrisSettings.get().getGeneral().isDisableNMS()) {
+            return "BUKKIT";
+        }
+
+        try {
+            String name = Bukkit.getServer().getClass().getCanonicalName();
+            if (name.equals("org.bukkit.craftbukkit.CraftServer")) {
+                return REVISION.getOrDefault(Bukkit.getServer().getBukkitVersion().split("-")[0], "BUKKIT");
+            } else {
+                return name.split("\\Q.\\E")[3];
+            }
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.error("Failed to determine server nms version!");
+            e.printStackTrace();
+        }
+
+        return "BUKKIT";
+    }
+
+    private static INMSBinding bind() {
+        String code = getNMSTag();
+        Iris.info("Locating NMS Binding for " + code);
+
+        try {
+            Class<?> clazz = Class.forName("com.volmit.iris.core.nms." + code + ".NMSBinding");
+            try {
+                Object b = clazz.getConstructor().newInstance();
+                if (b instanceof INMSBinding binding) {
+                    Iris.info("Craftbukkit " + code + " <-> " + b.getClass().getSimpleName() + " Successfully Bound");
+                    return binding;
+                }
+            } catch (Throwable e) {
+                Iris.reportError(e);
+                e.printStackTrace();
+            }
+        } catch (ClassNotFoundException |
+                 NoClassDefFoundError classNotFoundException) {
+        }
+
+        Iris.info("Craftbukkit " + code + " <-> " + NMSBinding1X.class.getSimpleName() + " Successfully Bound");
+        Iris.warn("Note: Some features of Iris may not work the same since you are on an unsupported version of Minecraft.");
+        Iris.warn("Note: If this is a new version, expect an update soon.");
+
+        return new NMSBinding1X();
+    }
+}

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

@@ -0,0 +1,160 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms;
+
+import com.volmit.iris.core.nms.container.BiomeColor;
+import com.volmit.iris.core.nms.container.IPackRepository;
+import com.volmit.iris.core.nms.datapack.DataVersion;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
+import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
+import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
+import com.volmit.iris.util.nbt.tag.CompoundTag;
+import org.bukkit.*;
+import org.bukkit.block.Biome;
+import org.bukkit.entity.Dolphin;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.generator.structure.Structure;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.File;
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.Collection;
+
+public interface INMSBinding {
+    boolean hasTile(Material material);
+
+    boolean hasTile(Location l);
+
+    KMap<String, Object> serializeTile(Location location);
+
+    void deserializeTile(KMap<String, Object> s, Location newPosition);
+
+    CompoundTag serializeEntity(Entity location);
+
+    Entity deserializeEntity(CompoundTag s, Location newPosition);
+
+    boolean supportsCustomHeight();
+
+    Object getBiomeBaseFromId(int id);
+
+    int getMinHeight(World world);
+
+    boolean supportsCustomBiomes();
+
+    int getTrueBiomeBaseId(Object biomeBase);
+
+    Object getTrueBiomeBase(Location location);
+
+    String getTrueBiomeBaseKey(Location location);
+
+    Object getCustomBiomeBaseFor(String mckey);
+
+    Object getCustomBiomeBaseHolderFor(String mckey);
+
+    int getBiomeBaseIdForKey(String key);
+
+    String getKeyForBiomeBase(Object biomeBase);
+
+    Object getBiomeBase(World world, Biome biome);
+
+    Object getBiomeBase(Object registry, Biome biome);
+
+    KList<Biome> getBiomes();
+
+    boolean isBukkit();
+
+    int getBiomeId(Biome biome);
+
+    MCABiomeContainer newBiomeContainer(int min, int max, int[] data);
+
+    MCABiomeContainer newBiomeContainer(int min, int max);
+
+    default World createWorld(WorldCreator c) {
+        return c.createWorld();
+    }
+
+    int countCustomBiomes();
+
+    void forceBiomeInto(int x, int y, int z, Object somethingVeryDirty, ChunkGenerator.BiomeGrid chunk);
+
+    default boolean supportsDataPacks() {
+        return false;
+    }
+
+    MCAPaletteAccess createPalette();
+
+    void injectBiomesFromMantle(Chunk e, Mantle mantle);
+
+    ItemStack applyCustomNbt(ItemStack itemStack, KMap<String, Object> customNbt) throws IllegalArgumentException;
+
+    void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException;
+
+    Vector3d getBoundingbox(org.bukkit.entity.EntityType entity);
+
+    default String getMobCategory(EntityType entityType) {
+        // todo: Update to other versions!
+        return null;
+    }
+
+    Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason);
+
+    Color getBiomeColor(Location location, BiomeColor type);
+
+    default DataVersion getDataVersion() {
+        return DataVersion.V1192;
+    }
+
+    boolean registerDimension(String name, IrisDimension dimension);
+
+    boolean registerBiome(String dimensionId, IrisBiomeCustom biome, boolean replace);
+
+    boolean dumpRegistry(File... folders);
+
+    void injectBukkit();
+
+    default IHeadless createHeadless(Engine engine) {
+        throw new IllegalStateException("Headless mode not supported");
+    }
+
+    default int getSpawnChunkCount(World world) {
+        return 441;
+    }
+
+    IPackRepository getPackRepository();
+
+    KList<String> getStructureKeys();
+
+    default void reconnectAll() {
+        new ArrayList<>(Bukkit.getOnlinePlayers())
+                .forEach(this::reconnect);
+    }
+
+    void reconnect(Player player);
+}

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

@@ -0,0 +1,28 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.container;
+
+public enum BiomeColor {
+    FOG,
+    WATER,
+    WATER_FOG,
+    SKY,
+    FOLIAGE,
+    GRASS
+}

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

@@ -0,0 +1,32 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.container;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class BlockPos {
+    private int x;
+    private int y;
+    private int z;
+}

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

@@ -0,0 +1,39 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.container;
+
+import java.util.Collection;
+
+public interface IPackRepository {
+    void reload();
+
+    void reloadWorldData();
+
+    void setSelected(Collection<String> packs);
+
+    boolean addPack(String packId);
+
+    boolean removePack(String packId);
+
+    Collection<String> getAvailableIds();
+
+    Collection<String> getSelectedIds();
+
+    boolean isAvailable(String packId);
+}

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

@@ -0,0 +1,31 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.container;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Pair<A, B> {
+    private A a;
+    private B b;
+}

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

@@ -0,0 +1,58 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.datapack;
+
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
+import com.volmit.iris.core.nms.datapack.v1206.DataFixerV1206;
+import com.volmit.iris.util.collection.KMap;
+import lombok.AccessLevel;
+import lombok.Getter;
+
+import java.util.function.Supplier;
+
+//https://minecraft.wiki/w/Pack_format
+@Getter
+public enum DataVersion {
+    V1192("1.19.2", 10, DataFixerV1192::new),
+    V1205("1.20.6", 41, DataFixerV1206::new);
+    private static final KMap<DataVersion, IDataFixer> cache = new KMap<>();
+    @Getter(AccessLevel.NONE)
+    private final Supplier<IDataFixer> constructor;
+    private final String version;
+    private final int packFormat;
+
+    DataVersion(String version, int packFormat, Supplier<IDataFixer> constructor) {
+        this.constructor = constructor;
+        this.packFormat = packFormat;
+        this.version = version;
+    }
+
+    public static IDataFixer getDefault() {
+        return INMS.get().getDataVersion().get();
+    }
+
+    public static DataVersion getLatest() {
+        return values()[values().length - 1];
+    }
+
+    public IDataFixer get() {
+        return cache.computeIfAbsent(this, k -> constructor.get());
+    }
+}

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

@@ -0,0 +1,29 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.datapack;
+
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.util.json.JSONObject;
+
+public interface IDataFixer {
+
+    JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json);
+
+    JSONObject fixDimension(JSONObject json);
+}

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

@@ -0,0 +1,36 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.datapack.v1192;
+
+import com.volmit.iris.core.nms.datapack.IDataFixer;
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.util.json.JSONObject;
+
+public class DataFixerV1192 implements IDataFixer {
+
+    @Override
+    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+        return json;
+    }
+
+    @Override
+    public JSONObject fixDimension(JSONObject json) {
+        return json;
+    }
+}

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

@@ -0,0 +1,72 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.datapack.v1206;
+
+import com.volmit.iris.core.nms.datapack.IDataFixer;
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.engine.object.IrisBiomeCustomSpawn;
+import com.volmit.iris.engine.object.IrisBiomeCustomSpawnType;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.json.JSONArray;
+import com.volmit.iris.util.json.JSONObject;
+
+import java.util.Locale;
+
+public class DataFixerV1206 implements IDataFixer {
+    @Override
+    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+        int spawnRarity = biome.getSpawnRarity();
+        if (spawnRarity > 0) {
+            json.put("creature_spawn_probability", Math.min(spawnRarity / 20d, 0.9999999));
+        }
+
+        var spawns = biome.getSpawns();
+        if (spawns != null && spawns.isNotEmpty()) {
+            JSONObject spawners = new JSONObject();
+            KMap<IrisBiomeCustomSpawnType, JSONArray> groups = new KMap<>();
+
+            for (IrisBiomeCustomSpawn i : spawns) {
+                JSONArray g = groups.computeIfAbsent(i.getGroup(), (k) -> new JSONArray());
+                JSONObject o = new JSONObject();
+                o.put("type", "minecraft:" + i.getType().name().toLowerCase());
+                o.put("weight", i.getWeight());
+                o.put("minCount", Math.min(i.getMinCount() / 20d, 0));
+                o.put("maxCount", Math.min(i.getMaxCount() / 20d, 0.9999999));
+                g.put(o);
+            }
+
+            for (IrisBiomeCustomSpawnType i : groups.k()) {
+                spawners.put(i.name().toLowerCase(Locale.ROOT), groups.get(i));
+            }
+
+            json.put("spawners", spawners);
+        }
+        return json;
+    }
+
+    @Override
+    public JSONObject fixDimension(JSONObject json) {
+        if (!(json.get("monster_spawn_light_level") instanceof JSONObject lightLevel))
+            return json;
+        var value = (JSONObject) lightLevel.remove("value");
+        lightLevel.put("max_inclusive", value.get("max_inclusive"));
+        lightLevel.put("min_inclusive", value.get("min_inclusive"));
+        return json;
+    }
+}

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

@@ -0,0 +1,317 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.v1X;
+
+import com.google.common.base.Preconditions;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.INMSBinding;
+import com.volmit.iris.core.nms.container.BiomeColor;
+import com.volmit.iris.core.nms.container.BlockPos;
+import com.volmit.iris.core.nms.container.IPackRepository;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
+import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
+import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
+import com.volmit.iris.util.nbt.tag.CompoundTag;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.dynamic.loading.ClassReloadingStrategy;
+import net.bytebuddy.matcher.ElementMatchers;
+import org.bukkit.*;
+import org.bukkit.WorldCreator;
+import org.bukkit.block.Biome;
+import org.bukkit.entity.Dolphin;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.generator.structure.Structure;
+import org.bukkit.inventory.ItemStack;
+
+import java.awt.Color;
+import java.io.File;
+
+public class NMSBinding1X implements INMSBinding {
+    private static final boolean supportsCustomHeight = testCustomHeight();
+
+    @SuppressWarnings("ConstantConditions")
+    private static boolean testCustomHeight() {
+        try {
+            if (World.class.getDeclaredMethod("getMaxHeight") != null && World.class.getDeclaredMethod("getMinHeight") != null)
+                ;
+            {
+                return true;
+            }
+        } catch (Throwable ignored) {
+
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean hasTile(Material material) {
+        return false;
+    }
+
+    @Override
+    public boolean hasTile(Location l) {
+        return false;
+    }
+
+    @Override
+    public KMap<String, Object> serializeTile(Location location) {
+        return null;
+    }
+
+    @Override
+    public void deserializeTile(KMap<String, Object> s, Location newPosition) {
+
+    }
+
+
+    @Override
+    public void injectBiomesFromMantle(Chunk e, Mantle mantle) {
+
+    }
+
+    @Override
+    public ItemStack applyCustomNbt(ItemStack itemStack, KMap<String, Object> customNbt) throws IllegalArgumentException {
+        return itemStack;
+    }
+
+    @Override
+    public void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException {
+
+    }
+
+    public Vector3d getBoundingbox() {
+        return null;
+    }
+
+    @Override
+    public Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        return location.getWorld().spawnEntity(location, type);
+    }
+
+    @Override
+    public boolean registerDimension(String name, IrisDimension dimension) {
+        return false;
+    }
+
+    @Override
+    public boolean registerBiome(String dimensionId, IrisBiomeCustom biome, boolean replace) {
+        return false;
+    }
+
+    @Override
+    public boolean dumpRegistry(File... folders) {
+        return false;
+    }
+
+    @Override
+    public Color getBiomeColor(Location location, BiomeColor type) {
+        return Color.GREEN;
+    }
+
+    @Override
+    public KList<String> getStructureKeys() {
+        var list = Registry.STRUCTURE.stream()
+                .map(Structure::getKey)
+                .map(NamespacedKey::toString)
+                .toList();
+        return new KList<>(list);
+    }
+
+    @Override
+    public void reconnect(Player player) {
+
+    }
+
+    @Override
+    public CompoundTag serializeEntity(Entity location) {
+        return null;
+    }
+
+    @Override
+    public Entity deserializeEntity(CompoundTag s, Location newPosition) {
+        return null;
+    }
+
+    @Override
+    public boolean supportsCustomHeight() {
+        return supportsCustomHeight;
+    }
+
+    @Override
+    public Object getBiomeBaseFromId(int id) {
+        return null;
+    }
+
+    @Override
+    public int getMinHeight(World world) {
+        return supportsCustomHeight ? world.getMinHeight() : 0;
+    }
+
+    @Override
+    public boolean supportsCustomBiomes() {
+        return false;
+    }
+
+    @Override
+    public int getTrueBiomeBaseId(Object biomeBase) {
+        return 0;
+    }
+
+    @Override
+    public Object getTrueBiomeBase(Location location) {
+        return null;
+    }
+
+    @Override
+    public String getTrueBiomeBaseKey(Location location) {
+        return null;
+    }
+
+    @Override
+    public Object getCustomBiomeBaseFor(String mckey) {
+        return null;
+    }
+
+    @Override
+    public Object getCustomBiomeBaseHolderFor(String mckey) {
+        return null;
+    }
+
+    @Override
+    public int getBiomeBaseIdForKey(String key) {
+        return 0;
+    }
+
+    @Override
+    public String getKeyForBiomeBase(Object biomeBase) {
+        return null;
+    }
+
+    public Object getBiomeBase(World world, Biome biome) {
+        return null;
+    }
+
+    @Override
+    public Object getBiomeBase(Object registry, Biome biome) {
+        return null;
+    }
+
+    @Override
+    public KList<Biome> getBiomes() {
+        return new KList<>(Biome.values()).qdel(Biome.CUSTOM);
+    }
+
+    @Override
+    public boolean isBukkit() {
+        return true;
+    }
+
+    @Override
+    public int getBiomeId(Biome biome) {
+        return biome.ordinal();
+    }
+
+    @Override
+    public MCABiomeContainer newBiomeContainer(int min, int max) {
+        Iris.error("Cannot use the custom biome data! Iris is incapable of using MCA generation on this version of minecraft!");
+
+        return null;
+    }
+
+    @Override
+    public MCABiomeContainer newBiomeContainer(int min, int max, int[] v) {
+        Iris.error("Cannot use the custom biome data! Iris is incapable of using MCA generation on this version of minecraft!");
+
+        return null;
+    }
+
+    @Override
+    public int countCustomBiomes() {
+        return 0;
+    }
+
+    @Override
+    public void forceBiomeInto(int x, int y, int z, Object somethingVeryDirty, ChunkGenerator.BiomeGrid chunk) {
+
+    }
+
+    @Override
+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+        return null;
+    }
+
+    @Override
+    public MCAPaletteAccess createPalette() {
+        Iris.error("Cannot use the global data palette! Iris is incapable of using MCA generation on this version of minecraft!");
+        return null;
+    }
+
+    public void injectBukkit() {
+        try {
+            Iris.info("Injecting Bukkit");
+            new ByteBuddy()
+                    .redefine(WorldCreator.class)
+                    .visit(Advice.to(WorldCreatorAdvice.class).on(ElementMatchers.isConstructor().and(ElementMatchers.takesArguments(String.class))))
+                    .make()
+                    .load(WorldCreator.class.getClassLoader(), ClassReloadingStrategy.fromInstalledAgent());
+            Iris.info("Injected Bukkit Successfully!");
+        } catch (Exception e) {
+            Iris.info(C.RED + "Failed to Inject Bukkit!");
+            e.printStackTrace();
+            Iris.reportError(e);
+        }
+
+    }
+
+    @Override
+    public IPackRepository getPackRepository() {
+        return new PackRepository1X();
+    }
+
+    private static class WorldCreatorAdvice {
+        @Advice.OnMethodEnter
+        static void enter(@Advice.Argument(0) String name) {
+            File isIrisWorld = new File(name, "iris");
+            boolean isFromIris = false;
+            StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+            for (StackTraceElement stack : stackTrace) {
+                if (stack.getClassName().contains("Iris")) {
+                    isFromIris = true;
+                    break;
+                }
+            }
+            if (!isFromIris) {
+                Preconditions.checkArgument(!isIrisWorld.exists(), "Only Iris can load Iris Worlds!");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.nms.v1X;
+
+import com.volmit.iris.core.nms.container.IPackRepository;
+
+import java.util.Collection;
+import java.util.List;
+
+class PackRepository1X implements IPackRepository {
+    @Override
+    public void reload() {
+    }
+
+    @Override
+    public void reloadWorldData() {
+    }
+
+    @Override
+    public void setSelected(Collection<String> packs) {
+    }
+
+    @Override
+    public boolean addPack(String packId) {
+        return false;
+    }
+
+    @Override
+    public boolean removePack(String packId) {
+        return false;
+    }
+
+    @Override
+    public Collection<String> getAvailableIds() {
+        return List.of();
+    }
+
+    @Override
+    public Collection<String> getSelectedIds() {
+        return List.of();
+    }
+
+    @Override
+    public boolean isAvailable(String packId) {
+        return false;
+    }
+}

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

@@ -0,0 +1,384 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pack;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.loader.ResourceLoader;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.exceptions.IrisException;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.json.JSONArray;
+import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import lombok.Data;
+import org.bukkit.World;
+import org.zeroturnaround.zip.commons.FileUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Future;
+
+/**
+ * Represents an Iris pack that exists
+ */
+@Data
+public class IrisPack {
+    private final File folder;
+    private final IrisData data;
+
+    /**
+     * Create an iris pack backed by a data folder
+     * the data folder is assumed to be in the Iris/packs/NAME folder
+     *
+     * @param name the name
+     */
+    public IrisPack(String name) {
+        this(packsPack(name));
+    }
+
+    /**
+     * Create an iris pack backed by a data folder
+     *
+     * @param folder the folder of the pack. Must be a directory
+     */
+    public IrisPack(File folder) {
+        this.folder = folder;
+
+        if (!folder.exists()) {
+            throw new RuntimeException("Cannot open Pack " + folder.getPath() + " (directory doesnt exist)");
+        }
+
+        if (!folder.isDirectory()) {
+            throw new RuntimeException("Cannot open Pack " + folder.getPath() + " (not a directory)");
+        }
+
+        this.data = IrisData.get(folder);
+    }
+
+    /**
+     * Create a new pack from the input url
+     *
+     * @param sender the sender
+     * @param url    the url, or name, or really anything see IrisPackRepository.from(String)
+     * @return the iris pack
+     * @throws IrisException fails
+     */
+    public static Future<IrisPack> from(VolmitSender sender, String url) throws IrisException {
+        IrisPackRepository repo = IrisPackRepository.from(url);
+        if (repo == null) {
+            throw new IrisException("Null Repo");
+        }
+
+        try {
+            return from(sender, repo);
+        } catch (MalformedURLException e) {
+            throw new IrisException("Malformed URL " + e.getMessage());
+        }
+    }
+
+    /**
+     * Create a pack from a repo
+     *
+     * @param sender the sender
+     * @param repo   the repo
+     * @return the pack
+     * @throws MalformedURLException shit happens
+     */
+    public static Future<IrisPack> from(VolmitSender sender, IrisPackRepository repo) throws MalformedURLException {
+        CompletableFuture<IrisPack> pack = new CompletableFuture<>();
+        repo.install(sender, () -> {
+            pack.complete(new IrisPack(repo.getRepo()));
+        });
+        return pack;
+    }
+
+    /**
+     * Create a blank pack with a given name
+     *
+     * @param name the name of the pack
+     * @return the pack
+     * @throws IrisException if the pack already exists or another error
+     */
+    public static IrisPack blank(String name) throws IrisException {
+        File f = packsPack(name);
+
+        if (f.exists()) {
+            throw new IrisException("Already exists");
+        }
+
+        File fd = new File(f, "dimensions/" + name + ".json");
+        fd.getParentFile().mkdirs();
+        try {
+            IO.writeAll(fd, "{\n" +
+                    "    \"name\": \"" + Form.capitalize(name) + "\",\n" +
+                    "    \"version\": 1\n" +
+                    "}\n");
+        } catch (IOException e) {
+            throw new IrisException(e.getMessage(), e);
+        }
+
+        IrisPack pack = new IrisPack(f);
+        pack.updateWorkspace();
+        return pack;
+    }
+
+    /**
+     * Get a packs pack folder for a name. Such that overworld would resolve as Iris/packs/overworld
+     *
+     * @param name the name
+     * @return the file path
+     */
+    public static File packsPack(String name) {
+        return Iris.instance.getDataFolderNoCreate(StudioSVC.WORKSPACE_NAME, name);
+    }
+
+    private static KList<File> collectFiles(File f, String fileExtension) {
+        KList<File> l = new KList<>();
+
+        if (f.isDirectory()) {
+            for (File i : f.listFiles()) {
+                l.addAll(collectFiles(i, fileExtension));
+            }
+        } else if (f.getName().endsWith("." + fileExtension)) {
+            l.add(f);
+        }
+
+        return l;
+    }
+
+    /**
+     * Delete this pack. This invalidates this pack and you should
+     * probably no longer use this instance after deleting this pack
+     */
+    public void delete() {
+        IO.delete(folder);
+        folder.delete();
+    }
+
+    /**
+     * Get the name of this pack
+     *
+     * @return the pack name
+     */
+    public String getName() {
+        return folder.getName();
+    }
+
+    /**
+     * Get the file path of the workspace file
+     *
+     * @return the workspace file path
+     */
+    public File getWorkspaceFile() {
+        return new File(getFolder(), getName() + ".code-workspace");
+    }
+
+    /**
+     * Update the workspace file
+     *
+     * @return true if it was updated
+     */
+    public boolean updateWorkspace() {
+        getFolder().mkdirs();
+        File ws = getWorkspaceFile();
+
+        try {
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            Iris.debug("Building Workspace: " + ws.getPath());
+            JSONObject j = generateWorkspaceConfig();
+            IO.writeAll(ws, j.toString(4));
+            p.end();
+            Iris.debug("Building Workspace: " + ws.getPath() + " took " + Form.duration(p.getMilliseconds(), 2));
+            return true;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.warn("Pack invalid: " + ws.getAbsolutePath() + " Re-creating. You may loose some vs-code workspace settings! But not your actual project!");
+            ws.delete();
+            try {
+                IO.writeAll(ws, generateWorkspaceConfig());
+            } catch (IOException e1) {
+                Iris.reportError(e1);
+                e1.printStackTrace();
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Install this pack into a world
+     *
+     * @param world the world to install into (world/iris/pack)
+     * @return the installed pack
+     */
+    public IrisPack install(World world) throws IrisException {
+        return install(new File(world.getWorldFolder(), "iris/pack"));
+    }
+
+    /**
+     * Install this pack into a world
+     *
+     * @param world the world to install into (world/iris/pack)
+     * @return the installed pack
+     */
+    public IrisPack install(IrisWorld world) throws IrisException {
+        return install(new File(world.worldFolder(), "iris/pack"));
+    }
+
+    /**
+     * Install this pack into a world
+     *
+     * @param folder the folder to install this pack into
+     * @return the installed pack
+     */
+    public IrisPack install(File folder) throws IrisException {
+        if (folder.exists()) {
+            throw new IrisException("Cannot install new pack because the folder " + folder.getName() + " already exists!");
+        }
+
+        folder.mkdirs();
+
+        try {
+            FileUtils.copyDirectory(getFolder(), folder);
+        } catch (IOException e) {
+            Iris.reportError(e);
+        }
+
+        return new IrisPack(folder);
+    }
+
+    /**
+     * Create a new pack using this pack as a template. The new pack will be renamed & have a renamed dimension
+     * to match it.
+     *
+     * @param newName the new pack name
+     * @return the new IrisPack
+     */
+    public IrisPack install(String newName) throws IrisException {
+        File newPack = packsPack(newName);
+
+        if (newPack.exists()) {
+            throw new IrisException("Cannot install new pack because the folder " + newName + " already exists!");
+        }
+
+        try {
+            FileUtils.copyDirectory(getFolder(), newPack);
+        } catch (IOException e) {
+            Iris.reportError(e);
+        }
+
+        IrisData data = IrisData.get(newPack);
+        IrisDimension dim = data.getDimensionLoader().load(getDimensionKey());
+        data.dump();
+        File from = dim.getLoadFile();
+        File to = new File(from.getParentFile(), newName + ".json");
+        try {
+            FileUtils.moveFile(from, to);
+            new File(newPack, getWorkspaceFile().getName()).delete();
+        } catch (Throwable e) {
+            throw new IrisException(e);
+        }
+
+        IrisPack pack = new IrisPack(newPack);
+        pack.updateWorkspace();
+
+        return pack;
+    }
+
+    /**
+     * The dimension's assumed loadkey
+     *
+     * @return getName()
+     */
+    public String getDimensionKey() {
+        return getName();
+    }
+
+    /**
+     * Get the main dimension object
+     *
+     * @return the dimension (folder name as dim key)
+     */
+    public IrisDimension getDimension() {
+        return getData().getDimensionLoader().load(getDimensionKey());
+    }
+
+    /**
+     * Find all files in this pack with the given extension
+     *
+     * @param fileExtension the extension
+     * @return the list of files
+     */
+    public KList<File> collectFiles(String fileExtension) {
+        return collectFiles(getFolder(), fileExtension);
+    }
+
+    private JSONObject generateWorkspaceConfig() {
+        JSONObject ws = new JSONObject();
+        JSONArray folders = new JSONArray();
+        JSONObject folder = new JSONObject();
+        folder.put("path", ".");
+        folders.put(folder);
+        ws.put("folders", folders);
+        JSONObject settings = new JSONObject();
+        settings.put("workbench.colorTheme", "Monokai");
+        settings.put("workbench.preferredDarkColorTheme", "Solarized Dark");
+        settings.put("workbench.tips.enabled", false);
+        settings.put("workbench.tree.indent", 24);
+        settings.put("files.autoSave", "onFocusChange");
+        JSONObject jc = new JSONObject();
+        jc.put("editor.autoIndent", "brackets");
+        jc.put("editor.acceptSuggestionOnEnter", "smart");
+        jc.put("editor.cursorSmoothCaretAnimation", true);
+        jc.put("editor.dragAndDrop", false);
+        jc.put("files.trimTrailingWhitespace", true);
+        jc.put("diffEditor.ignoreTrimWhitespace", true);
+        jc.put("files.trimFinalNewlines", true);
+        jc.put("editor.suggest.showKeywords", false);
+        jc.put("editor.suggest.showSnippets", false);
+        jc.put("editor.suggest.showWords", false);
+        JSONObject st = new JSONObject();
+        st.put("strings", true);
+        jc.put("editor.quickSuggestions", st);
+        jc.put("editor.suggest.insertMode", "replace");
+        settings.put("[json]", jc);
+        settings.put("json.maxItemsComputed", 30000);
+        JSONArray schemas = new JSONArray();
+        IrisData dm = IrisData.get(getFolder());
+
+        for (ResourceLoader<?> r : dm.getLoaders().v()) {
+            if (r.supportsSchemas()) {
+                schemas.put(r.buildSchema());
+            }
+        }
+
+        settings.put("json.schemas", schemas);
+        ws.put("settings", settings);
+
+        return ws;
+    }
+}

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

@@ -0,0 +1,132 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pack;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.jobs.DownloadJob;
+import com.volmit.iris.util.scheduling.jobs.JobCollection;
+import com.volmit.iris.util.scheduling.jobs.SingleJob;
+import lombok.Builder;
+import lombok.Data;
+import org.zeroturnaround.zip.ZipUtil;
+import org.zeroturnaround.zip.commons.FileUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.util.UUID;
+
+@Data
+@Builder
+public class IrisPackRepository {
+    @Builder.Default
+    private String user = "IrisDimensions";
+
+    @Builder.Default
+    private String repo = "overworld";
+
+    @Builder.Default
+    private String branch = "master";
+
+    @Builder.Default
+    private String tag = "";
+
+    /**
+     *
+     */
+    public static IrisPackRepository from(String g) {
+        // https://github.com/IrisDimensions/overworld
+        if (g.startsWith("https://github.com/")) {
+            String sub = g.split("\\Qgithub.com/\\E")[1];
+            IrisPackRepository r = IrisPackRepository.builder()
+                    .user(sub.split("\\Q/\\E")[0])
+                    .repo(sub.split("\\Q/\\E")[1]).build();
+
+            if (g.contains("/tree/")) {
+                r.setBranch(g.split("/tree/")[1]);
+            }
+
+            return r;
+        } else if (g.contains("/")) {
+            String[] f = g.split("\\Q/\\E");
+
+            if (f.length == 1) {
+                return from(g);
+            } else if (f.length == 2) {
+                return IrisPackRepository.builder()
+                        .user(f[0])
+                        .repo(f[1])
+                        .build();
+            } else if (f.length >= 3) {
+                IrisPackRepository r = IrisPackRepository.builder()
+                        .user(f[0])
+                        .repo(f[1])
+                        .build();
+
+                if (f[2].startsWith("#")) {
+                    r.setTag(f[2].substring(1));
+                } else {
+                    r.setBranch(f[2]);
+                }
+
+                return r;
+            }
+        } else {
+            return IrisPackRepository.builder()
+                    .user("IrisDimensions")
+                    .repo(g)
+                    .branch(g.equals("overworld") ? "stable" : "master")
+                    .build();
+        }
+
+        return null;
+    }
+
+    public String toURL() {
+        if (!tag.trim().isEmpty()) {
+            return "https://codeload.github.com/" + user + "/" + repo + "/zip/refs/tags/" + tag;
+        }
+
+        return "https://codeload.github.com/" + user + "/" + repo + "/zip/refs/heads/" + branch;
+    }
+
+    public void install(VolmitSender sender, Runnable whenComplete) throws MalformedURLException {
+        File pack = Iris.instance.getDataFolderNoCreate(StudioSVC.WORKSPACE_NAME, getRepo());
+
+        if (!pack.exists()) {
+            File dl = new File(Iris.getTemp(), "dltk-" + UUID.randomUUID() + ".zip");
+            File work = new File(Iris.getTemp(), "extk-" + UUID.randomUUID());
+            new JobCollection(Form.capitalize(getRepo()),
+                    new DownloadJob(toURL(), pack),
+                    new SingleJob("Extracting", () -> ZipUtil.unpack(dl, work)),
+                    new SingleJob("Installing", () -> {
+                        try {
+                            FileUtils.copyDirectory(work.listFiles()[0], pack);
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    })).execute(sender, whenComplete);
+        } else {
+            sender.sendMessage("Pack already exists!");
+        }
+    }
+}

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

@@ -0,0 +1,337 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RollingSequence;
+import com.volmit.iris.util.math.Spiraler;
+import com.volmit.iris.util.scheduling.J;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class ChunkUpdater {
+    private final RollingSequence chunksPerSecond;
+    private final AtomicInteger worldheightsize;
+    private final AtomicInteger worldwidthsize;
+    private final AtomicInteger totalChunks;
+    private final AtomicInteger totalMaxChunks;
+    private final AtomicInteger totalMcaregions;
+    private final AtomicInteger position;
+    private final Object pauseLock;
+    private final Engine engine;
+    private final World world;
+    private AtomicBoolean paused;
+    private AtomicBoolean cancelled;
+    private KMap<Chunk, Long> lastUse;
+    private AtomicInteger chunksProcessed;
+    private AtomicInteger chunksUpdated;
+    private AtomicLong startTime;
+    private ExecutorService executor;
+    private ExecutorService chunkExecutor;
+    private ScheduledExecutorService scheduler;
+    private CompletableFuture future;
+    private CountDownLatch latch;
+
+    public ChunkUpdater(World world) {
+        this.engine = IrisToolbelt.access(world).getEngine();
+        this.chunksPerSecond = new RollingSequence(5);
+        this.world = world;
+        this.lastUse = new KMap();
+        this.worldheightsize = new AtomicInteger(calculateWorldDimensions(new File(world.getWorldFolder(), "region"), 1));
+        this.worldwidthsize = new AtomicInteger(calculateWorldDimensions(new File(world.getWorldFolder(), "region"), 0));
+        int m = Math.max(worldheightsize.get(), worldwidthsize.get());
+        this.executor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors() / 3, 1));
+        this.chunkExecutor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors() / 3, 1));
+        this.scheduler = Executors.newScheduledThreadPool(1);
+        this.future = new CompletableFuture<>();
+        this.startTime = new AtomicLong();
+        this.worldheightsize.set(m);
+        this.worldwidthsize.set(m);
+        this.totalMaxChunks = new AtomicInteger((worldheightsize.get() / 16) * (worldwidthsize.get() / 16));
+        this.chunksProcessed = new AtomicInteger();
+        this.chunksUpdated = new AtomicInteger();
+        this.position = new AtomicInteger(0);
+        this.latch = new CountDownLatch(totalMaxChunks.get());
+        this.paused = new AtomicBoolean(false);
+        this.pauseLock = new Object();
+        this.cancelled = new AtomicBoolean(false);
+        this.totalChunks = new AtomicInteger(0);
+        this.totalMcaregions = new AtomicInteger(0);
+    }
+
+    public int getChunks() {
+        return totalMaxChunks.get();
+    }
+
+    public void start() {
+        unloadAndSaveAllChunks();
+        update();
+    }
+
+    public boolean pause() {
+        unloadAndSaveAllChunks();
+        if (paused.get()) {
+            paused.set(false);
+            return false;
+        } else {
+            paused.set(true);
+            return true;
+        }
+    }
+
+    public void stop() {
+        unloadAndSaveAllChunks();
+        cancelled.set(true);
+    }
+
+
+    private void update() {
+        Iris.info("Updating..");
+        try {
+            startTime.set(System.currentTimeMillis());
+            scheduler.scheduleAtFixedRate(() -> {
+                try {
+                    if (!paused.get()) {
+                        long eta = computeETA();
+                        long elapsedSeconds = (System.currentTimeMillis() - startTime.get()) / 3000;
+                        int processed = chunksProcessed.get();
+                        double cps = elapsedSeconds > 0 ? processed / (double) elapsedSeconds : 0;
+                        chunksPerSecond.put(cps);
+                        double percentage = ((double) chunksProcessed.get() / (double) totalMaxChunks.get()) * 100;
+                        if (!cancelled.get()) {
+                            Iris.info("Updated: " + Form.f(processed) + " of " + Form.f(totalMaxChunks.get()) + " (%.0f%%) " + Form.f(chunksPerSecond.getAverage()) + "/s, ETA: " + Form.duration(eta,
+                                    2), percentage);
+                        }
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }, 0, 3, TimeUnit.SECONDS);
+
+            CompletableFuture.runAsync(() -> {
+                for (int i = 0; i < totalMaxChunks.get(); i++) {
+                    if (paused.get()) {
+                        synchronized (pauseLock) {
+                            try {
+                                pauseLock.wait();
+                            } catch (InterruptedException e) {
+                                Iris.error("Interrupted while waiting for executor: ");
+                                e.printStackTrace();
+                                break;
+                            }
+                        }
+                    }
+                    executor.submit(() -> {
+                        if (!cancelled.get()) {
+                            processNextChunk();
+                        }
+                        latch.countDown();
+                    });
+                }
+            }).thenRun(() -> {
+                try {
+                    latch.await();
+                    close();
+                } catch (Exception e) {
+                    Thread.currentThread().interrupt();
+                }
+            });
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void close() {
+        try {
+            unloadAndSaveAllChunks();
+            executor.shutdown();
+            executor.awaitTermination(5, TimeUnit.SECONDS);
+            chunkExecutor.shutdown();
+            chunkExecutor.awaitTermination(5, TimeUnit.SECONDS);
+            scheduler.shutdownNow();
+        } catch (Exception ignored) {
+        }
+        if (cancelled.get()) {
+            Iris.info("Updated: " + Form.f(chunksUpdated.get()) + " Chunks");
+            Iris.info("Irritated: " + Form.f(chunksProcessed.get()) + " of " + Form.f(totalMaxChunks.get()));
+            Iris.info("Stopped updater.");
+        } else {
+            Iris.info("Processed: " + Form.f(chunksProcessed.get()) + " Chunks");
+            Iris.info("Finished Updating: " + Form.f(chunksUpdated.get()) + " Chunks");
+        }
+    }
+
+    private void processNextChunk() {
+        int pos = position.getAndIncrement();
+        int[] coords = getChunk(pos);
+        if (loadChunksIfGenerated(coords[0], coords[1])) {
+            Chunk c = world.getChunkAt(coords[0], coords[1]);
+            engine.updateChunk(c);
+            chunksUpdated.incrementAndGet();
+        }
+        chunksProcessed.getAndIncrement();
+    }
+
+    private boolean loadChunksIfGenerated(int x, int z) {
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                if (!PaperLib.isChunkGenerated(world, x + dx, z + dz)) {
+                    return false;
+                }
+            }
+        }
+
+        AtomicBoolean generated = new AtomicBoolean(true);
+        KList<Future<?>> futures = new KList<>(9);
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                int xx = x + dx;
+                int zz = z + dz;
+                futures.add(chunkExecutor.submit(() -> {
+                    Chunk c;
+                    try {
+                        c = PaperLib.getChunkAtAsync(world, xx, zz, false).get();
+                    } catch (InterruptedException | ExecutionException e) {
+                        generated.set(false);
+                        return;
+                    }
+                    if (!c.isLoaded()) {
+                        CountDownLatch latch = new CountDownLatch(1);
+                        J.s(() -> {
+                            c.load(false);
+                            latch.countDown();
+                        });
+                        try {
+                            latch.await();
+                        } catch (InterruptedException ignored) {
+                        }
+                    }
+                    if (!c.isGenerated()) {
+                        generated.set(false);
+                    }
+                    lastUse.put(c, M.ms());
+                }));
+            }
+        }
+        while (!futures.isEmpty()) {
+            futures.removeIf(Future::isDone);
+            try {
+                Thread.sleep(50);
+            } catch (InterruptedException ignored) {
+            }
+        }
+        return generated.get();
+    }
+
+    private void unloadAndSaveAllChunks() {
+        try {
+            J.sfut(() -> {
+                if (world == null) {
+                    Iris.warn("World was null somehow...");
+                    return;
+                }
+
+                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
+                    Long lastUseTime = lastUse.get(i);
+                    if (lastUseTime != null && M.ms() - lastUseTime >= 5000) {
+                        i.unload();
+                        lastUse.remove(i);
+                    }
+                }
+                world.save();
+            }).get();
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private long computeETA() {
+        return (long) (totalMaxChunks.get() > 1024 ? // Generated chunks exceed 1/8th of total?
+                // If yes, use smooth function (which gets more accurate over time since its less sensitive to outliers)
+                ((totalMaxChunks.get() - chunksProcessed.get()) * ((double) (M.ms() - startTime.get()) / (double) chunksProcessed.get())) :
+                // If no, use quick function (which is less accurate over time but responds better to the initial delay)
+                ((totalMaxChunks.get() - chunksProcessed.get()) / chunksPerSecond.getAverage()) * 1000
+        );
+    }
+
+    private int calculateWorldDimensions(File regionDir, Integer o) {
+        File[] files = regionDir.listFiles((dir, name) -> name.endsWith(".mca"));
+
+        int minX = Integer.MAX_VALUE;
+        int maxX = Integer.MIN_VALUE;
+        int minZ = Integer.MAX_VALUE;
+        int maxZ = Integer.MIN_VALUE;
+
+        for (File file : files) {
+            String[] parts = file.getName().split("\\.");
+            int x = Integer.parseInt(parts[1]);
+            int z = Integer.parseInt(parts[2]);
+
+            if (x < minX) minX = x;
+            if (x > maxX) maxX = x;
+            if (z < minZ) minZ = z;
+            if (z > maxZ) maxZ = z;
+        }
+
+        int height = (maxX - minX + 1) * 32 * 16;
+        int width = (maxZ - minZ + 1) * 32 * 16;
+
+        if (o == 1) {
+            return height;
+        }
+        if (o == 0) {
+            return width;
+        }
+        return 0;
+    }
+
+    private int[] getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(worldheightsize.get() * 2, worldwidthsize.get() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+        int[] coords = new int[2];
+        coords[0] = xx.get();
+        coords[1] = zz.get();
+
+        return coords;
+    }
+}

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

@@ -0,0 +1,82 @@
+package com.volmit.iris.core.pregenerator;
+
+public final class EmptyListener implements PregenListener {
+    public static final PregenListener INSTANCE = new EmptyListener();
+
+    private EmptyListener() {}
+
+    @Override
+    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
+
+    }
+
+    @Override
+    public void onChunkGenerating(int x, int z) {
+
+    }
+
+    @Override
+    public void onChunkGenerated(int x, int z) {
+
+    }
+
+    @Override
+    public void onRegionGenerated(int x, int z) {
+
+    }
+
+    @Override
+    public void onRegionGenerating(int x, int z) {
+
+    }
+
+    @Override
+    public void onChunkCleaned(int x, int z) {
+
+    }
+
+    @Override
+    public void onRegionSkipped(int x, int z) {
+
+    }
+
+    @Override
+    public void onNetworkStarted(int x, int z) {
+
+    }
+
+    @Override
+    public void onNetworkFailed(int x, int z) {
+
+    }
+
+    @Override
+    public void onNetworkReclaim(int revert) {
+
+    }
+
+    @Override
+    public void onNetworkGeneratedChunk(int x, int z) {
+
+    }
+
+    @Override
+    public void onNetworkDownloaded(int x, int z) {
+
+    }
+
+    @Override
+    public void onClose() {
+
+    }
+
+    @Override
+    public void onSaving() {
+
+    }
+
+    @Override
+    public void onChunkExistsInRegionGen(int x, int z) {
+
+    }
+}

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

@@ -0,0 +1,433 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisPackBenchmarking;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
+import com.volmit.iris.util.math.RollingSequence;
+import com.volmit.iris.util.nbt.mca.Chunk;
+import com.volmit.iris.util.nbt.mca.MCAFile;
+import com.volmit.iris.util.nbt.mca.MCAUtil;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.Looper;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+
+import java.io.*;
+import java.lang.reflect.Type;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+public class IrisPregenerator {
+    private static AtomicInteger generated;
+    private static AtomicInteger totalChunks;
+    private final String saveFile = "regions.json";
+    private final PregenTask task;
+    private final PregeneratorMethod generator;
+    private final PregenListener listener;
+    private final Looper ticker;
+    private final AtomicBoolean paused;
+    private final AtomicBoolean shutdown;
+    private final RollingSequence chunksPerSecond;
+    private final RollingSequence chunksPerMinute;
+    private final RollingSequence regionsPerMinute;
+    private final KList<Integer> chunksPerSecondHistory;
+    private final AtomicInteger generatedLast;
+    private final AtomicInteger generatedLastMinute;
+    private final AtomicLong startTime;
+    private final ChronoLatch minuteLatch;
+    private final AtomicReference<String> currentGeneratorMethod;
+    private final KSet<Position2> retry;
+    private final KSet<Position2> net;
+    private final ChronoLatch cl;
+    private final ChronoLatch saveLatch = new ChronoLatch(30000);
+    private Set<Position2> generatedRegions;
+
+    public IrisPregenerator(PregenTask task, PregeneratorMethod generator, PregenListener listener) {
+        generatedRegions = ConcurrentHashMap.newKeySet();
+        this.listener = listenify(listener);
+        cl = new ChronoLatch(5000);
+        this.shutdown = new AtomicBoolean(false);
+        this.paused = new AtomicBoolean(false);
+        this.task = task;
+        this.generator = generator;
+        retry = new KSet<>();
+        net = new KSet<>();
+        currentGeneratorMethod = new AtomicReference<>("Void");
+        minuteLatch = new ChronoLatch(60000, false);
+        chunksPerSecond = new RollingSequence(10);
+        chunksPerMinute = new RollingSequence(10);
+        regionsPerMinute = new RollingSequence(10);
+        chunksPerSecondHistory = new KList<>();
+        generated = new AtomicInteger(0);
+        generatedLast = new AtomicInteger(0);
+        generatedLastMinute = new AtomicInteger(0);
+        totalChunks = new AtomicInteger(0);
+        if (!IrisPackBenchmarking.benchmarkInProgress) {
+            loadCompletedRegions();
+            IrisToolbelt.access(generator.getWorld()).getEngine().saveEngineData();
+        }
+        task.iterateRegions((_a, _b) -> totalChunks.addAndGet(1024));
+        startTime = new AtomicLong(M.ms());
+        ticker = new Looper() {
+            @Override
+            protected long loop() {
+                long eta = computeETA();
+                int secondGenerated = generated.get() - generatedLast.get();
+                generatedLast.set(generated.get());
+                chunksPerSecond.put(secondGenerated);
+                chunksPerSecondHistory.add(secondGenerated);
+
+                if (minuteLatch.flip()) {
+                    int minuteGenerated = generated.get() - generatedLastMinute.get();
+                    generatedLastMinute.set(generated.get());
+                    chunksPerMinute.put(minuteGenerated);
+                    regionsPerMinute.put((double) minuteGenerated / 1024D);
+                }
+
+                listener.onTick(chunksPerSecond.getAverage(), chunksPerMinute.getAverage(),
+                        regionsPerMinute.getAverage(),
+                        (double) generated.get() / (double) totalChunks.get(),
+                        generated.get(), totalChunks.get(),
+                        totalChunks.get() - generated.get(),
+                        eta, M.ms() - startTime.get(), currentGeneratorMethod.get());
+
+                if (cl.flip() && !paused.get()) {
+                    double percentage = ((double) generated.get() / (double) totalChunks.get()) * 100;
+                    if (!IrisPackBenchmarking.benchmarkInProgress) {
+                        Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration(eta, 2), percentage);
+                    } else {
+                        Iris.info("Benchmarking: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration(eta, 2), percentage);
+                    }
+                }
+                return 1000;
+            }
+        };
+    }
+
+    private long computeETA() {
+        long currentTime = M.ms();
+        long elapsedTime = currentTime - startTime.get();
+        int generatedChunks = generated.get();
+        int remainingChunks = totalChunks.get() - generatedChunks;
+
+        if (generatedChunks <= 12_000) {
+            // quick
+            return (long) (remainingChunks * ((double) elapsedTime / generatedChunks));
+        } else {
+            //smooth
+            return (long) (remainingChunks / chunksPerSecond.getAverage() * 1000);
+        }
+    }
+
+
+    public void close() {
+        shutdown.set(true);
+    }
+
+    public void start() {
+        init();
+        ticker.start();
+        checkRegions();
+        task.iterateRegions((x, z) -> visitRegion(x, z, true));
+        task.iterateRegions((x, z) -> visitRegion(x, z, false));
+        shutdown();
+        if (!IrisPackBenchmarking.benchmarkInProgress) {
+            Iris.info(C.IRIS + "Pregen stopped.");
+            // todo: optimizer just takes too long.
+//            if (totalChunks.get() == generated.get() && task.isOptimizer()) {
+//                Iris.info("Starting World Optimizer..");
+//                ChunkUpdater updater = new ChunkUpdater(generator.getWorld());
+//                updater.start();
+//            }
+        } else {
+            IrisPackBenchmarking.getInstance().finishedBenchmark(chunksPerSecondHistory);
+        }
+    }
+
+    private void checkRegions() {
+        task.iterateRegions(this::checkRegion);
+    }
+
+    private void init() {
+        generator.init();
+        generator.save();
+    }
+
+    private void shutdown() {
+        listener.onSaving();
+        generator.close();
+        ticker.interrupt();
+        listener.onClose();
+        saveCompletedRegions();
+        Mantle mantle = getMantle();
+        if (mantle != null) {
+            mantle.trim(0, 0);
+        }
+    }
+
+    private void getGeneratedRegions() {
+        World world = generator.getWorld();
+        File[] region = new File(world.getWorldFolder(), "region").listFiles();
+        BurstExecutor b = MultiBurst.burst.burst(region.length);
+        b.setMulticore(true);
+        b.queue(() -> {
+            for (File file : region) {
+                try {
+                    String regex = "r\\.(\\d+)\\.(-?\\d+)\\.mca";
+                    Pattern pattern = Pattern.compile(regex);
+                    Matcher matcher = pattern.matcher(file.getName());
+                    if (!matcher.find()) continue;
+                    int x = Integer.parseInt(matcher.group(1));
+                    int z = Integer.parseInt(matcher.group(2));
+                    Position2 pos = new Position2(x, z);
+                    generatedRegions.add(pos);
+
+                    MCAFile mca = MCAUtil.read(file, 0);
+
+                    boolean notFull = false;
+                    for (int i = 0; i < 1024; i++) {
+                        Chunk chunk = mca.getChunk(i);
+                        if (chunk == null) {
+                            generatedRegions.remove(pos);
+                            notFull = true;
+                            break;
+                        }
+                    }
+                    Iris.info("Completed MCA region: " + file.getName());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        b.complete();
+    }
+
+    private void visitRegion(int x, int z, boolean regions) {
+        while (paused.get() && !shutdown.get()) {
+            J.sleep(50);
+        }
+
+        if (shutdown.get()) {
+            listener.onRegionSkipped(x, z);
+            return;
+        }
+
+        Position2 pos = new Position2(x, z);
+
+        if (generatedRegions.contains(pos)) {
+            if (regions) {
+                listener.onRegionGenerated(x, z);
+                generated.addAndGet(1024);
+            }
+            return;
+        }
+
+        currentGeneratorMethod.set(generator.getMethod(x, z));
+        boolean hit = false;
+        if (generator.supportsRegions(x, z, listener) && regions) {
+            hit = true;
+            listener.onRegionGenerating(x, z);
+            generator.generateRegion(x, z, listener);
+        } else if (!regions) {
+            hit = true;
+            listener.onRegionGenerating(x, z);
+            PregenTask.iterateRegion(x, z, (xx, zz) -> {
+                while (paused.get() && !shutdown.get()) {
+                    J.sleep(50);
+                }
+
+                generator.generateChunk(xx, zz, listener);
+            });
+        }
+
+        if (hit) {
+            listener.onRegionGenerated(x, z);
+
+            if (saveLatch.flip()) {
+                listener.onSaving();
+                generator.save();
+            }
+
+            generatedRegions.add(pos);
+            checkRegions();
+        }
+    }
+
+    private void checkRegion(int x, int z) {
+        if (generatedRegions.contains(new Position2(x, z))) {
+            return;
+        }
+
+        generator.supportsRegions(x, z, listener);
+    }
+
+    public void saveCompletedRegions() {
+        if (IrisPackBenchmarking.benchmarkInProgress) return;
+        Gson gson = new Gson();
+        try (Writer writer = new FileWriter(generator.getWorld().getWorldFolder().getPath() + "/" + saveFile)) {
+            gson.toJson(new HashSet<>(generatedRegions), writer);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void loadCompletedRegions() {
+        if (task.isResetCache()) {
+            File test = new File(generator.getWorld().getWorldFolder().getPath() + "/" + saveFile);
+            if (!test.delete()) {
+                Iris.info(C.RED + "Failed to reset region cache ");
+            }
+        }
+        Gson gson = new Gson();
+        try (Reader reader = new FileReader(generator.getWorld().getWorldFolder().getPath() + "/" + saveFile)) {
+            Type setType = new TypeToken<HashSet<Position2>>() {
+            }.getType();
+            Set<Position2> loadedSet = gson.fromJson(reader, setType);
+            if (loadedSet != null) {
+                generatedRegions.clear();
+                generatedRegions.addAll(loadedSet);
+            }
+        } catch (FileNotFoundException e) {
+            // all fine
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void pause() {
+        paused.set(true);
+    }
+
+    public void resume() {
+        paused.set(false);
+    }
+
+    private PregenListener listenify(PregenListener listener) {
+        return new PregenListener() {
+            @Override
+            public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
+                listener.onTick(chunksPerSecond, chunksPerMinute, regionsPerMinute, percent, generated, totalChunks, chunksRemaining, eta, elapsed, method);
+            }
+
+            @Override
+            public void onChunkGenerating(int x, int z) {
+                listener.onChunkGenerating(x, z);
+            }
+
+            @Override
+            public void onChunkGenerated(int x, int z) {
+                listener.onChunkGenerated(x, z);
+                generated.addAndGet(1);
+            }
+
+            @Override
+            public void onRegionGenerated(int x, int z) {
+                generatedRegions.add(new Position2(x, z));
+                saveCompletedRegions();
+                listener.onRegionGenerated(x, z);
+            }
+
+            @Override
+            public void onRegionGenerating(int x, int z) {
+                listener.onRegionGenerating(x, z);
+            }
+
+            @Override
+            public void onChunkCleaned(int x, int z) {
+                listener.onChunkCleaned(x, z);
+            }
+
+            @Override
+            public void onRegionSkipped(int x, int z) {
+                listener.onRegionSkipped(x, z);
+            }
+
+            @Override
+            public void onNetworkStarted(int x, int z) {
+                net.add(new Position2(x, z));
+            }
+
+            @Override
+            public void onNetworkFailed(int x, int z) {
+                retry.add(new Position2(x, z));
+            }
+
+            @Override
+            public void onNetworkReclaim(int revert) {
+                generated.addAndGet(-revert);
+            }
+
+            @Override
+            public void onNetworkGeneratedChunk(int x, int z) {
+                generated.addAndGet(1);
+            }
+
+            @Override
+            public void onNetworkDownloaded(int x, int z) {
+                net.remove(new Position2(x, z));
+            }
+
+            @Override
+            public void onClose() {
+                listener.onClose();
+            }
+
+            @Override
+            public void onSaving() {
+                listener.onSaving();
+            }
+
+            @Override
+            public void onChunkExistsInRegionGen(int x, int z) {
+                listener.onChunkExistsInRegionGen(x, z);
+            }
+        };
+    }
+
+    public boolean paused() {
+        return paused.get();
+    }
+
+    public Mantle getMantle() {
+        return generator.getMantle();
+    }
+}

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

@@ -0,0 +1,302 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
+import com.volmit.iris.util.math.RollingSequence;
+import com.volmit.iris.util.math.Spiraler;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import io.papermc.lib.PaperLib;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class LazyPregenerator extends Thread implements Listener {
+    private static final Map<String, LazyPregenJob> jobs = new HashMap<>();
+    @Getter
+    private static LazyPregenerator instance;
+    private static AtomicInteger lazyGeneratedChunks;
+    private final LazyPregenJob job;
+    private final File destination;
+    private final int maxPosition;
+    private final long rate;
+    private final ChronoLatch latch;
+    private final AtomicInteger generatedLast;
+    private final AtomicInteger lazyTotalChunks;
+    private final AtomicLong startTime;
+    private final RollingSequence chunksPerSecond;
+    private final RollingSequence chunksPerMinute;
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+    private World world;
+
+    public LazyPregenerator(LazyPregenJob job, File destination) {
+        this.job = job;
+        this.destination = destination;
+        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+        }).count();
+        this.world = Bukkit.getWorld(job.getWorld());
+        this.rate = Math.round((1D / (job.getChunksPerMinute() / 60D)) * 1000D);
+        this.latch = new ChronoLatch(15000);
+        this.startTime = new AtomicLong(M.ms());
+        this.chunksPerSecond = new RollingSequence(10);
+        this.chunksPerMinute = new RollingSequence(10);
+        lazyGeneratedChunks = new AtomicInteger(0);
+        this.generatedLast = new AtomicInteger(0);
+        this.lazyTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
+        jobs.put(job.getWorld(), job);
+        LazyPregenerator.instance = this;
+    }
+
+    public LazyPregenerator(File file) throws IOException {
+        this(new Gson().fromJson(IO.readAll(file), LazyPregenJob.class), file);
+    }
+
+    public static void loadLazyGenerators() {
+        for (World i : Bukkit.getWorlds()) {
+            File lazygen = new File(i.getWorldFolder(), "lazygen.json");
+            if (lazygen.exists()) {
+                try {
+                    LazyPregenerator p = new LazyPregenerator(lazygen);
+                    p.start();
+                    Iris.info("Started Lazy Pregenerator: " + p.job);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    public static void setPausedLazy(World world) {
+        LazyPregenJob job = jobs.get(world.getName());
+        if (isPausedLazy(world)) {
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if (job.paused) {
+            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedLazy(World world) {
+        LazyPregenJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
+    @EventHandler
+    public void on(WorldUnloadEvent e) {
+        if (e.getWorld().equals(world)) {
+            interrupt();
+        }
+    }
+
+    public void run() {
+        while (!interrupted()) {
+            J.sleep(rate);
+            tick();
+        }
+
+        try {
+            saveNow();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tick() {
+        LazyPregenJob job = jobs.get(world.getName());
+        if (latch.flip() && !job.paused) {
+            long eta = computeETA();
+            save();
+            int secondGenerated = lazyGeneratedChunks.get() - generatedLast.get();
+            generatedLast.set(lazyGeneratedChunks.get());
+            secondGenerated = secondGenerated / 15;
+            chunksPerSecond.put(secondGenerated);
+            chunksPerMinute.put(secondGenerated * 60);
+            if (!job.isSilent()) {
+                Iris.info("LazyGen: " + C.IRIS + world.getName() + C.RESET + " RTT: " + Form.f(lazyGeneratedChunks.get()) + " of " + Form.f(lazyTotalChunks.get()) + " " + Form.f((int) chunksPerMinute.getAverage()) + "/m ETA: " + Form.duration((double) eta, 2));
+            }
+        }
+
+        if (lazyGeneratedChunks.get() >= lazyTotalChunks.get()) {
+            if (job.isHealing()) {
+                int pos = (job.getHealingPosition() + 1) % maxPosition;
+                job.setHealingPosition(pos);
+                tickRegenerate(getChunk(pos));
+            } else {
+                Iris.info("Completed Lazy Gen!");
+                interrupt();
+            }
+        } else {
+            int pos = job.getPosition() + 1;
+            job.setPosition(pos);
+            if (!job.paused) {
+                tickGenerate(getChunk(pos));
+            }
+        }
+    }
+
+    private long computeETA() {
+        return (long) ((lazyTotalChunks.get() - lazyGeneratedChunks.get()) / chunksPerMinute.getAverage()) * 1000;
+        // todo broken
+    }
+
+    private void tickGenerate(Position2 chunk) {
+        executorService.submit(() -> {
+            CountDownLatch latch = new CountDownLatch(1);
+            if (PaperLib.isPaper()) {
+                PaperLib.getChunkAtAsync(world, chunk.getX(), chunk.getZ(), true)
+                        .thenAccept((i) -> {
+                            Iris.verbose("Generated Async " + chunk);
+                            latch.countDown();
+                        });
+            } else {
+                J.s(() -> {
+                    world.getChunkAt(chunk.getX(), chunk.getZ());
+                    Iris.verbose("Generated " + chunk);
+                    latch.countDown();
+                });
+            }
+            try {
+                latch.await();
+            } catch (InterruptedException ignored) {
+            }
+            lazyGeneratedChunks.addAndGet(1);
+        });
+    }
+
+    private void tickRegenerate(Position2 chunk) {
+        J.s(() -> world.regenerateChunk(chunk.getX(), chunk.getZ()));
+        Iris.verbose("Regenerated " + chunk);
+    }
+
+    public Position2 getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+
+        return new Position2(xx.get(), zz.get());
+    }
+
+    public void save() {
+        J.a(() -> {
+            try {
+                saveNow();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    public void shutdownInstance(World world) throws IOException {
+        Iris.info("LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
+        LazyPregenJob job = jobs.get(world.getName());
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File lazyFile = new File(worldDirectory, "lazygen.json");
+
+        if (job == null) {
+            Iris.error("No Lazygen job found for world: " + world.getName());
+            return;
+        }
+
+        try {
+            if (!job.isPaused()) {
+                job.setPaused(true);
+            }
+            save();
+            jobs.remove(world.getName());
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    while (lazyFile.exists()) {
+                        lazyFile.delete();
+                        J.sleep(1000);
+                    }
+                    Iris.info("LazyGen: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
+                }
+            }.runTaskLater(Iris.instance, 20L);
+        } catch (Exception e) {
+            Iris.error("Failed to shutdown Lazygen for " + world.getName());
+            e.printStackTrace();
+        } finally {
+            saveNow();
+            interrupt();
+        }
+    }
+
+
+    public void saveNow() throws IOException {
+        IO.writeAll(this.destination, new Gson().toJson(job));
+    }
+
+    @Data
+    @Builder
+    public static class LazyPregenJob {
+        @Builder.Default
+        boolean silent = false;
+        @Builder.Default
+        boolean paused = false;
+        private String world;
+        @Builder.Default
+        private int healingPosition = 0;
+        @Builder.Default
+        private boolean healing = false;
+        @Builder.Default
+        private int chunksPerMinute = 32;
+        @Builder.Default
+        private int radiusBlocks = 5000;
+        @Builder.Default
+        private int position = 0;
+    }
+}
+

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

@@ -0,0 +1,51 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator;
+
+public interface PregenListener {
+    void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method);
+
+    void onChunkGenerating(int x, int z);
+
+    void onChunkGenerated(int x, int z);
+
+    void onRegionGenerated(int x, int z);
+
+    void onRegionGenerating(int x, int z);
+
+    void onChunkCleaned(int x, int z);
+
+    void onRegionSkipped(int x, int z);
+
+    void onNetworkStarted(int x, int z);
+
+    void onNetworkFailed(int x, int z);
+
+    void onNetworkReclaim(int revert);
+
+    void onNetworkGeneratedChunk(int x, int z);
+
+    void onNetworkDownloaded(int x, int z);
+
+    void onClose();
+
+    void onSaving();
+
+    void onChunkExistsInRegionGen(int x, int z);
+}

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

@@ -0,0 +1,104 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator;
+
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.math.Position2;
+import com.volmit.iris.util.math.Spiraled;
+import com.volmit.iris.util.math.Spiraler;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+
+import java.util.Comparator;
+
+@Builder
+@Data
+@AllArgsConstructor(access = AccessLevel.PROTECTED)
+public class PregenTask {
+    private static final Position2 ZERO = new Position2(0, 0);
+    private static final KList<Position2> ORDER_CENTER = computeChunkOrder();
+    private static final KMap<Position2, KList<Position2>> ORDERS = new KMap<>();
+
+
+    @Builder.Default
+    private boolean resetCache = false;
+    @Builder.Default
+    private boolean gui = false;
+    @Builder.Default
+    private Position2 center = new Position2(0, 0);
+    @Builder.Default
+    private int width = 1;
+    @Builder.Default
+    private int height = 1;
+
+    public static void iterateRegion(int xr, int zr, Spiraled s, Position2 pull) {
+        for (Position2 i : ORDERS.computeIfAbsent(pull, PregenTask::computeOrder)) {
+            s.on(i.getX() + (xr << 5), i.getZ() + (zr << 5));
+        }
+    }
+
+    public static void iterateRegion(int xr, int zr, Spiraled s) {
+        iterateRegion(xr, zr, s, new Position2(-(xr << 5), -(zr << 5)));
+    }
+
+    private static KList<Position2> computeOrder(Position2 pull) {
+        KList<Position2> p = new KList<>();
+        new Spiraler(33, 33, (x, z) -> {
+            int xx = (x + 15);
+            int zz = (z + 15);
+            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
+                return;
+            }
+
+            p.add(new Position2(xx, zz));
+        }).drain();
+        p.sort(Comparator.comparing((i) -> i.distance(pull)));
+
+        return p;
+    }
+
+    private static KList<Position2> computeChunkOrder() {
+        Position2 center = new Position2(15, 15);
+        KList<Position2> p = new KList<>();
+        new Spiraler(33, 33, (x, z) -> {
+            int xx = x + 15;
+            int zz = z + 15;
+            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
+                return;
+            }
+
+            p.add(new Position2(xx, zz));
+        }).drain();
+        p.sort(Comparator.comparing((i) -> i.distance(center)));
+        return p;
+    }
+
+    public void iterateRegions(Spiraled s) {
+        new Spiraler(getWidth() * 2, getHeight() * 2, s)
+                .setOffset(center.getX(), center.getZ()).drain();
+    }
+
+    public void iterateAllChunks(Spiraled s) {
+        new Spiraler(getWidth() * 2, getHeight() * 2, (x, z) -> iterateRegion(x, z, s))
+                .setOffset(center.getX(), center.getZ()).drain();
+    }
+}

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

@@ -0,0 +1,83 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator;
+
+import com.volmit.iris.util.mantle.Mantle;
+import org.bukkit.World;
+
+/**
+ * Represents something that is capable of generating in chunks or regions, or both
+ */
+public interface PregeneratorMethod {
+    /**
+     * This is called before any generate methods are called. Setup your generator here
+     */
+    void init();
+
+    /**
+     * This is called after the pregenerator is done. Save your work and stop threads
+     */
+    void close();
+
+    /**
+     * This is called every X amount of chunks or regions. Save work,
+     * but no need to save all of it. At the end, close() will still be called.
+     */
+    void save();
+
+    /**
+     * Return true if regions can be generated
+     *
+     * @param x the x region
+     * @param z the z region
+     * @return true if they can be
+     */
+    boolean supportsRegions(int x, int z, PregenListener listener);
+
+    /**
+     * Return the name of the method being used
+     *
+     * @param x the x region
+     * @param z the z region
+     * @return the name
+     */
+    String getMethod(int x, int z);
+
+    /**
+     * Called to generate a region. Execute sync, if multicore internally, wait
+     * for the task to complete
+     *
+     * @param x        the x
+     * @param z        the z
+     * @param listener signal chunks generating & generated. Parallel capable.
+     */
+    void generateRegion(int x, int z, PregenListener listener);
+
+    /**
+     * Called to generate a chunk. You can go async so long as save will wait on the threads to finish
+     *
+     * @param x the x
+     * @param z the z
+     */
+    void generateChunk(int x, int z, PregenListener listener);
+
+    Mantle getMantle();
+
+    World getWorld();
+}

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

@@ -0,0 +1,360 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
+import com.volmit.iris.util.math.RollingSequence;
+import com.volmit.iris.util.math.Spiraler;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.HyperLock;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import io.papermc.lib.PaperLib;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.IntStream;
+
+public class TurboPregenerator extends Thread implements Listener {
+    private static final Map<String, TurboPregenJob> jobs = new HashMap<>();
+    @Getter
+    private static TurboPregenerator instance;
+    private static AtomicInteger turboGeneratedChunks;
+    private final TurboPregenJob job;
+    private final File destination;
+    private final int maxPosition;
+    private final ChronoLatch latch;
+    private final AtomicInteger generatedLast;
+    private final AtomicLong cachedLast;
+    private final RollingSequence cachePerSecond;
+    private final AtomicInteger turboTotalChunks;
+    private final AtomicLong startTime;
+    private final RollingSequence chunksPerSecond;
+    private final RollingSequence chunksPerMinute;
+    private final HyperLock hyperLock;
+    private final ExecutorService executorService = Executors.newFixedThreadPool(10);
+    private World world;
+    private KList<Position2> queue;
+    private ConcurrentHashMap<Integer, Position2> cache;
+    private AtomicInteger maxWaiting;
+    private ReentrantLock cachinglock;
+    private AtomicBoolean caching;
+    private MultiBurst burst;
+
+    public TurboPregenerator(TurboPregenJob job, File destination) {
+        this.job = job;
+        queue = new KList<>(512);
+        this.maxWaiting = new AtomicInteger(128);
+        this.destination = destination;
+        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+        }).count();
+        this.world = Bukkit.getWorld(job.getWorld());
+        this.latch = new ChronoLatch(3000);
+        this.burst = MultiBurst.burst;
+        this.hyperLock = new HyperLock();
+        this.startTime = new AtomicLong(M.ms());
+        this.cachePerSecond = new RollingSequence(10);
+        this.chunksPerSecond = new RollingSequence(10);
+        this.chunksPerMinute = new RollingSequence(10);
+        turboGeneratedChunks = new AtomicInteger(0);
+        this.generatedLast = new AtomicInteger(0);
+        this.cachedLast = new AtomicLong(0);
+        this.caching = new AtomicBoolean(false);
+        this.turboTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
+        cache = new ConcurrentHashMap<>(turboTotalChunks.get());
+        this.cachinglock = new ReentrantLock();
+        jobs.put(job.getWorld(), job);
+        TurboPregenerator.instance = this;
+    }
+
+    public TurboPregenerator(File file) throws IOException {
+        this(new Gson().fromJson(IO.readAll(file), TurboPregenerator.TurboPregenJob.class), file);
+    }
+
+    public static void loadTurboGenerator(String i) {
+        World x = Bukkit.getWorld(i);
+        File turbogen = new File(x.getWorldFolder(), "turbogen.json");
+        if (turbogen.exists()) {
+            try {
+                TurboPregenerator p = new TurboPregenerator(turbogen);
+                p.start();
+                Iris.info("Started Turbo Pregenerator: " + p.job);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
+    public static void setPausedTurbo(World world) {
+        TurboPregenJob job = jobs.get(world.getName());
+        if (isPausedTurbo(world)) {
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if (job.paused) {
+            Iris.info(C.BLUE + "TurboGen: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "TurboGen: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedTurbo(World world) {
+        TurboPregenJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
+    @EventHandler
+    public void on(WorldUnloadEvent e) {
+        if (e.getWorld().equals(world)) {
+            interrupt();
+        }
+    }
+
+    public void run() {
+        while (!interrupted()) {
+            tick();
+        }
+
+        try {
+            saveNow();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tick() {
+        TurboPregenJob job = jobs.get(world.getName());
+        if (!cachinglock.isLocked() && cache.isEmpty() && !caching.get()) {
+            ExecutorService cache = Executors.newFixedThreadPool(1);
+            cache.submit(this::cache);
+        }
+
+        if (latch.flip() && caching.get()) {
+            long secondCached = cache.mappingCount() - cachedLast.get();
+            cachedLast.set(cache.mappingCount());
+            secondCached = secondCached / 3;
+            cachePerSecond.put(secondCached);
+            Iris.info("TurboGen: " + C.IRIS + world.getName() + C.RESET + C.BLUE + " Caching: " + Form.f(cache.mappingCount()) + " of " + Form.f(turboTotalChunks.get()) + " " + Form.f((int) cachePerSecond.getAverage()) + "/s");
+        }
+
+        if (latch.flip() && !job.paused && !cachinglock.isLocked()) {
+            long eta = computeETA();
+            save();
+            int secondGenerated = turboGeneratedChunks.get() - generatedLast.get();
+            generatedLast.set(turboGeneratedChunks.get());
+            secondGenerated = secondGenerated / 3;
+            chunksPerSecond.put(secondGenerated);
+            chunksPerMinute.put(secondGenerated * 60);
+            Iris.info("TurboGen: " + C.IRIS + world.getName() + C.RESET + " RTT: " + Form.f(turboGeneratedChunks.get()) + " of " + Form.f(turboTotalChunks.get()) + " " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
+
+        }
+        if (turboGeneratedChunks.get() >= turboTotalChunks.get()) {
+            Iris.info("Completed Turbo Gen!");
+            interrupt();
+        } else {
+            if (!cachinglock.isLocked()) {
+                int pos = job.getPosition() + 1;
+                job.setPosition(pos);
+                if (!job.paused) {
+                    if (queue.size() < maxWaiting.get()) {
+                        Position2 chunk = cache.get(pos);
+                        queue.add(chunk);
+                    }
+                    waitForChunksPartial();
+                }
+            }
+        }
+    }
+
+    private void cache() {
+        if (!cachinglock.isLocked()) {
+            cachinglock.lock();
+            caching.set(true);
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            BurstExecutor b = MultiBurst.burst.burst(turboTotalChunks.get());
+            b.setMulticore(true);
+            int[] list = IntStream.rangeClosed(0, turboTotalChunks.get()).toArray();
+            AtomicInteger order = new AtomicInteger(turboTotalChunks.get());
+
+            int threads = Runtime.getRuntime().availableProcessors();
+            if (threads > 1) threads--;
+            ExecutorService process = Executors.newFixedThreadPool(threads);
+
+            for (int id : list) {
+                b.queue(() -> {
+                    cache.put(id, getChunk(id));
+                    order.addAndGet(-1);
+                });
+            }
+            b.complete();
+
+            if (order.get() < 0) {
+                cachinglock.unlock();
+                caching.set(false);
+                Iris.info("Completed Caching in: " + Form.duration(p.getMilliseconds(), 2));
+            }
+        } else {
+            Iris.error("TurboCache is locked!");
+        }
+    }
+
+    private void waitForChunksPartial() {
+        while (!queue.isEmpty() && maxWaiting.get() > queue.size()) {
+            try {
+                for (Position2 c : new KList<>(queue)) {
+                    tickGenerate(c);
+                    queue.remove(c);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private long computeETA() {
+        return (long) ((turboTotalChunks.get() - turboGeneratedChunks.get()) / chunksPerMinute.getAverage()) * 1000;
+        // todo broken
+    }
+
+    private void tickGenerate(Position2 chunk) {
+        executorService.submit(() -> {
+            CountDownLatch latch = new CountDownLatch(1);
+            PaperLib.getChunkAtAsync(world, chunk.getX(), chunk.getZ(), true)
+                    .thenAccept((i) -> {
+                        latch.countDown();
+                    });
+            try {
+                latch.await();
+            } catch (InterruptedException ignored) {
+            }
+            turboGeneratedChunks.addAndGet(1);
+        });
+    }
+
+    public Position2 getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+
+        return new Position2(xx.get(), zz.get());
+    }
+
+    public void save() {
+        J.a(() -> {
+            try {
+                saveNow();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    public void shutdownInstance(World world) throws IOException {
+        Iris.info("turboGen: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
+        TurboPregenJob job = jobs.get(world.getName());
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File turboFile = new File(worldDirectory, "turbogen.json");
+
+        if (job == null) {
+            Iris.error("No turbogen job found for world: " + world.getName());
+            return;
+        }
+
+        try {
+            if (!job.isPaused()) {
+                job.setPaused(true);
+            }
+            save();
+            jobs.remove(world.getName());
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    while (turboFile.exists()) {
+                        turboFile.delete();
+                        J.sleep(1000);
+                    }
+                    Iris.info("turboGen: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
+                }
+            }.runTaskLater(Iris.instance, 20L);
+        } catch (Exception e) {
+            Iris.error("Failed to shutdown turbogen for " + world.getName());
+            e.printStackTrace();
+        } finally {
+            saveNow();
+            interrupt();
+        }
+    }
+
+
+    public void saveNow() throws IOException {
+        IO.writeAll(this.destination, new Gson().toJson(job));
+    }
+
+    @Data
+    @Builder
+    public static class TurboPregenJob {
+        @Builder.Default
+        boolean paused = false;
+        private String world;
+        @Builder.Default
+        private int radiusBlocks = 5000;
+        @Builder.Default
+        private int position = 0;
+    }
+}
+

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

@@ -0,0 +1,80 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator.methods;
+
+import com.volmit.iris.core.pregenerator.PregenListener;
+import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.util.mantle.Mantle;
+import io.papermc.lib.PaperLib;
+import org.bukkit.World;
+
+public class AsyncOrMedievalPregenMethod implements PregeneratorMethod {
+    private final PregeneratorMethod method;
+    private final World world;
+
+    public AsyncOrMedievalPregenMethod(World world, int threads) {
+        this.world = world;
+        method = PaperLib.isPaper() ? new AsyncPregenMethod(world, threads) : new MedievalPregenMethod(world);
+    }
+
+    @Override
+    public void init() {
+        method.init();
+    }
+
+    @Override
+    public void close() {
+        method.close();
+    }
+
+    @Override
+    public void save() {
+        method.save();
+    }
+
+    @Override
+    public String getMethod(int x, int z) {
+        return method.getMethod(x, z);
+    }
+
+    @Override
+    public boolean supportsRegions(int x, int z, PregenListener listener) {
+        return false;
+    }
+
+    @Override
+    public void generateRegion(int x, int z, PregenListener listener) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void generateChunk(int x, int z, PregenListener listener) {
+        method.generateChunk(x, z, listener);
+    }
+
+    @Override
+    public Mantle getMantle() {
+        return method.getMantle();
+    }
+
+    @Override
+    public World getWorld() {
+        return world;
+    }
+}

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

@@ -0,0 +1,176 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator.methods;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.PregenListener;
+import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.scheduling.J;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.Future;
+
+public class AsyncPregenMethod implements PregeneratorMethod {
+    private final World world;
+    private final MultiBurst burst;
+    private final KList<Future<?>> future;
+    private final Map<Chunk, Long> lastUse;
+
+    public AsyncPregenMethod(World world, int threads) {
+        if (!PaperLib.isPaper()) {
+            throw new UnsupportedOperationException("Cannot use PaperAsync on non paper!");
+        }
+        this.world = world;
+        burst = new MultiBurst("Iris Async Pregen", Thread.MIN_PRIORITY);
+        future = new KList<>(256);
+        this.lastUse = new KMap<>();
+    }
+
+    private void unloadAndSaveAllChunks() {
+        try {
+            J.sfut(() -> {
+                if (world == null) {
+                    Iris.warn("World was null somehow...");
+                    return;
+                }
+
+                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
+                    Long lastUseTime = lastUse.get(i);
+                    if (lastUseTime != null && M.ms() - lastUseTime >= 10000) {
+                        i.unload();
+                        lastUse.remove(i);
+                    }
+                }
+                world.save();
+            }).get();
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void completeChunk(int x, int z, PregenListener listener) {
+        try {
+            PaperLib.getChunkAtAsync(world, x, z, true).thenAccept((i) -> {
+                lastUse.put(i, M.ms());
+                listener.onChunkGenerated(x, z);
+                listener.onChunkCleaned(x, z);
+            }).get();
+        } catch (InterruptedException ignored) {
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void waitForChunksPartial(int maxWaiting) {
+        while (future.size() > maxWaiting) {
+            try {
+                Future<?> i = future.remove(0);
+
+                if (i == null) {
+                    continue;
+                }
+
+                i.get();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void waitForChunks() {
+        for (Future<?> i : future.copy()) {
+            if (i == null) {
+                continue;
+            }
+
+            try {
+                i.get();
+                future.remove(i);
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    public void init() {
+        unloadAndSaveAllChunks();
+    }
+
+    @Override
+    public String getMethod(int x, int z) {
+        return "Async";
+    }
+
+    @Override
+    public void close() {
+        waitForChunks();
+        unloadAndSaveAllChunks();
+        burst.close();
+    }
+
+    @Override
+    public void save() {
+        waitForChunksPartial(256);
+        unloadAndSaveAllChunks();
+    }
+
+    @Override
+    public boolean supportsRegions(int x, int z, PregenListener listener) {
+        return false;
+    }
+
+    @Override
+    public void generateRegion(int x, int z, PregenListener listener) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void generateChunk(int x, int z, PregenListener listener) {
+        listener.onChunkGenerating(x, z);
+        if (future.size() > 256) {
+            waitForChunksPartial(256);
+        }
+        future.add(burst.complete(() -> completeChunk(x, z, listener)));
+    }
+
+    @Override
+    public Mantle getMantle() {
+        if (IrisToolbelt.isIrisWorld(world)) {
+            return IrisToolbelt.access(world).getEngine().getMantle().getMantle();
+        }
+
+        return null;
+    }
+
+    @Override
+    public World getWorld() {
+        return world;
+    }
+}

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

@@ -0,0 +1,71 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator.methods;
+
+import com.volmit.iris.core.pregenerator.PregenListener;
+import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.util.mantle.Mantle;
+import org.bukkit.World;
+
+public class DummyPregenMethod implements PregeneratorMethod {
+    @Override
+    public void init() {
+
+    }
+
+    @Override
+    public void close() {
+
+    }
+
+    @Override
+    public String getMethod(int x, int z) {
+        return "Dummy";
+    }
+
+    @Override
+    public void save() {
+
+    }
+
+    @Override
+    public boolean supportsRegions(int x, int z, PregenListener listener) {
+        return false;
+    }
+
+    @Override
+    public void generateRegion(int x, int z, PregenListener listener) {
+
+    }
+
+    @Override
+    public void generateChunk(int x, int z, PregenListener listener) {
+
+    }
+
+    @Override
+    public Mantle getMantle() {
+        return null;
+    }
+
+    @Override
+    public World getWorld() {
+        return null;
+    }
+}

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

@@ -0,0 +1,117 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator.methods;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.nms.IHeadless;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.pregenerator.PregenListener;
+import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.parallel.MultiBurst;
+import org.bukkit.World;
+
+import java.io.IOException;
+import java.util.concurrent.Semaphore;
+
+public class HeadlessPregenMethod implements PregeneratorMethod {
+    private final Engine engine;
+    private final IHeadless headless;
+    private final Semaphore semaphore;
+    private final int max;
+    private final World world;
+    private final MultiBurst burst;
+
+    public HeadlessPregenMethod(Engine engine) {
+        this.world = engine.getWorld().realWorld();
+        this.max = IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism());
+        this.engine = engine;
+        this.headless = INMS.get().createHeadless(engine);
+        burst = new MultiBurst("HeadlessPregen", 8 );
+        this.semaphore = new Semaphore(max);
+    }
+
+    @Override
+    public void init() {
+    }
+
+    @Override
+    public void close() {
+        try {
+            semaphore.acquire(max);
+        } catch (InterruptedException ignored) {
+        }
+        try {
+            headless.close();
+        } catch (IOException e) {
+            Iris.error("Failed to close headless");
+            e.printStackTrace();
+        }
+        burst.close();
+    }
+
+    @Override
+    public void save() {
+    }
+
+    @Override
+    public boolean supportsRegions(int x, int z, PregenListener listener) {
+        return false;
+    }
+
+    @Override
+    public String getMethod(int x, int z) {
+        return "Headless";
+    }
+
+    @Override
+    public void generateRegion(int x, int z, PregenListener listener) {
+    }
+
+    @Override
+    public void generateChunk(int x, int z, PregenListener listener) {
+        try {
+            semaphore.acquire();
+        } catch (InterruptedException ignored) {
+            semaphore.release();
+            return;
+        }
+        burst.complete(() -> {
+            try {
+                listener.onChunkGenerating(x, z);
+                headless.generateChunk(x, z);
+                listener.onChunkGenerated(x, z);
+            } finally {
+                semaphore.release();
+            }
+        });
+    }
+
+    @Override
+    public Mantle getMantle() {
+        return engine.getMantle().getMantle();
+    }
+
+    @Override
+    public World getWorld() {
+        return world;
+    }
+}

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

@@ -0,0 +1,79 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.pregenerator.methods;
+
+import com.volmit.iris.core.pregenerator.PregenListener;
+import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.util.mantle.Mantle;
+import org.bukkit.World;
+
+public class HybridPregenMethod implements PregeneratorMethod {
+    private final PregeneratorMethod inWorld;
+    private final World world;
+
+    public HybridPregenMethod(World world, int threads) {
+        this.world = world;
+        inWorld = new AsyncOrMedievalPregenMethod(world, threads);
+    }
+
+    @Override
+    public String getMethod(int x, int z) {
+        return "Hybrid<" + inWorld.getMethod(x, z) + ">";
+    }
+
+    @Override
+    public void init() {
+        inWorld.init();
+    }
+
+    @Override
+    public void close() {
+        inWorld.close();
+    }
+
+    @Override
+    public void save() {
+        inWorld.save();
+    }
+
+    @Override
+    public boolean supportsRegions(int x, int z, PregenListener listener) {
+        return inWorld.supportsRegions(x, z, listener);
+    }
+
+    @Override
+    public void generateRegion(int x, int z, PregenListener listener) {
+        inWorld.generateRegion(x, z, listener);
+    }
+
+    @Override
+    public void generateChunk(int x, int z, PregenListener listener) {
+        inWorld.generateChunk(x, z, listener);
+    }
+
+    @Override
+    public Mantle getMantle() {
+        return inWorld.getMantle();
+    }
+
+    @Override
+    public World getWorld() {
+        return world;
+    }
+}