DivineMC/patches/unapplied/server/0008-Parallel-world-ticking.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: NONPLAYT <76615486+NONPLAYT@users.noreply.github.com>
Date: Wed, 29 Jan 2025 00:59:03 +0300
Subject: [PATCH] Parallel world ticking


diff --git a/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java b/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
index b5817aa8f537593f6d9fc6b612c82ccccb250ac7..5683395e09a65b1b39748df5152fffef630ac083 100644
--- a/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
+++ b/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
@@ -1031,7 +1031,7 @@ public final class ChunkHolderManager {
         if (changedFullStatus.isEmpty()) {
             return;
         }
-        if (!TickThread.isTickThread()) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && !TickThread.isTickThreadFor(world)) { // DivineMC - Parallel world ticking
             this.taskScheduler.scheduleChunkTask(() -> {
                 final ArrayDeque<NewChunkHolder> pendingFullLoadUpdate = ChunkHolderManager.this.pendingFullLoadUpdate;
                 for (int i = 0, len = changedFullStatus.size(); i < len; ++i) {
@@ -1057,7 +1057,13 @@ public final class ChunkHolderManager {
 
     // note: never call while inside the chunk system, this will absolutely break everything
     public void processUnloads() {
-        TickThread.ensureTickThread("Cannot unload chunks off-main");
+        // DivineMC start - Parallel world ticking
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+            TickThread.ensureTickThread(world, "Cannot unload chunks off-main");
+        } else {
+            TickThread.ensureTickThread("Cannot unload chunks off-main");
+        }
+        // DivineMC end - Parallel world ticking
 
         if (BLOCK_TICKET_UPDATES.get() == Boolean.TRUE) {
             throw new IllegalStateException("Cannot unload chunks recursively");
@@ -1339,7 +1345,7 @@ public final class ChunkHolderManager {
 
         List<NewChunkHolder> changedFullStatus = null;
 
-        final boolean isTickThread = TickThread.isTickThread();
+        final boolean isTickThread = org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && TickThread.isTickThreadFor(world) || TickThread.isTickThread(); // DivineMC - Parallel world ticking
 
         boolean ret = false;
         final boolean canProcessFullUpdates = processFullUpdates & isTickThread;
diff --git a/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java b/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
index 4a881636ba21fae9e50950bbba2b4321b71d35ab..ebcd52da2228893f7a2d96f61e71906f8d2783ba 100644
--- a/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
+++ b/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
@@ -46,7 +46,7 @@ public class BoatDispenseItemBehavior extends DefaultDispenseItemBehavior {
         org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(singleItemStack);
 
         org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(d1, d2 + d4, d3));
-        if (!DispenserBlock.eventFired) {
+        if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
             serverLevel.getCraftServer().getPluginManager().callEvent(event);
         }
 
diff --git a/net/minecraft/core/dispenser/DefaultDispenseItemBehavior.java b/net/minecraft/core/dispenser/DefaultDispenseItemBehavior.java
index bd5bbc7e55c6bea77991fe5a3c0c2580313d16c5..b822dd53138c9cde3e7248afb7589ca32a1b178a 100644
--- a/net/minecraft/core/dispenser/DefaultDispenseItemBehavior.java
+++ b/net/minecraft/core/dispenser/DefaultDispenseItemBehavior.java
@@ -78,7 +78,7 @@ public class DefaultDispenseItemBehavior implements DispenseItemBehavior {
         org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(stack);
 
         org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block, craftItem.clone(), org.bukkit.craftbukkit.util.CraftVector.toBukkit(itemEntity.getDeltaMovement()));
-        if (!DispenserBlock.eventFired) {
+        if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
             level.getCraftServer().getPluginManager().callEvent(event);
         }
 
diff --git a/net/minecraft/core/dispenser/DispenseItemBehavior.java b/net/minecraft/core/dispenser/DispenseItemBehavior.java
index f576449e8bc6fd92963cbe3954b0c853a02def3c..075987ec1eabb7385918049c54d7210ff2b38847 100644
--- a/net/minecraft/core/dispenser/DispenseItemBehavior.java
+++ b/net/minecraft/core/dispenser/DispenseItemBehavior.java
@@ -89,7 +89,7 @@ public interface DispenseItemBehavior {
                 org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(singleItemStack);
 
                 org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
-                if (!DispenserBlock.eventFired) {
+                if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                     serverLevel.getCraftServer().getPluginManager().callEvent(event);
                 }
 
@@ -147,7 +147,7 @@ public interface DispenseItemBehavior {
                     org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(singleItemStack);
 
                     org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
-                    if (!DispenserBlock.eventFired) {
+                    if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                         serverLevel.getCraftServer().getPluginManager().callEvent(event);
                     }
 
@@ -201,7 +201,7 @@ public interface DispenseItemBehavior {
                         org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(singleItemStack);
 
                         org.bukkit.event.block.BlockDispenseArmorEvent event = new org.bukkit.event.block.BlockDispenseArmorEvent(block, craftItem.clone(), entitiesOfClass.get(0).getBukkitLivingEntity());
-                        if (!DispenserBlock.eventFired) {
+                        if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                             world.getCraftServer().getPluginManager().callEvent(event);
                         }
 
@@ -251,7 +251,7 @@ public interface DispenseItemBehavior {
                             org.bukkit.block.Block block = org.bukkit.craftbukkit.block.CraftBlock.at(world, blockSource.pos());
                             org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(singleCopy);
                             org.bukkit.event.block.BlockDispenseArmorEvent event = new org.bukkit.event.block.BlockDispenseArmorEvent(block, craftItem.clone(), abstractChestedHorse.getBukkitLivingEntity());
-                            if (!DispenserBlock.eventFired) {
+                            if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                                 world.getCraftServer().getPluginManager().callEvent(event);
                             }
 
@@ -329,7 +329,7 @@ public interface DispenseItemBehavior {
                     org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item.copyWithCount(1)); // Paper - single item in event
 
                     org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(x, y, z));
-                    if (!DispenserBlock.eventFired) {
+                    if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                         level.getCraftServer().getPluginManager().callEvent(event);
                     }
 
@@ -389,7 +389,7 @@ public interface DispenseItemBehavior {
                         org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item.copyWithCount(1)); // Paper - single item in event
 
                         org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), org.bukkit.craftbukkit.util.CraftVector.toBukkit(blockPos));
-                        if (!DispenserBlock.eventFired) {
+                        if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                             levelAccessor.getMinecraftWorld().getCraftServer().getPluginManager().callEvent(event);
                         }
 
@@ -425,7 +425,7 @@ public interface DispenseItemBehavior {
                 org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item); // Paper - ignore stack size on damageable items
 
                 org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
-                if (!DispenserBlock.eventFired) {
+                if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                     serverLevel.getCraftServer().getPluginManager().callEvent(event);
                 }
 
@@ -482,7 +482,7 @@ public interface DispenseItemBehavior {
                 org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item.copyWithCount(1)); // Paper - single item in event
 
                 org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
-                if (!DispenserBlock.eventFired) {
+                if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                     level.getCraftServer().getPluginManager().callEvent(event);
                 }
 
@@ -510,8 +510,10 @@ public interface DispenseItemBehavior {
                 // CraftBukkit start
                 level.captureTreeGeneration = false;
                 if (level.capturedBlockStates.size() > 0) {
-                    org.bukkit.TreeType treeType = net.minecraft.world.level.block.SaplingBlock.treeType;
-                    net.minecraft.world.level.block.SaplingBlock.treeType = null;
+                    // DivineMC start - Parallel world ticking
+                    org.bukkit.TreeType treeType = net.minecraft.world.level.block.SaplingBlock.getTreeTypeTL();
+                    net.minecraft.world.level.block.SaplingBlock.setTreeTypeTL(null);
+                    // DivineMC end - Parallel world ticking
                     org.bukkit.Location location = org.bukkit.craftbukkit.util.CraftLocation.toBukkit(blockPos, level.getWorld());
                     List<org.bukkit.block.BlockState> blocks = new java.util.ArrayList<>(level.capturedBlockStates.values());
                     level.capturedBlockStates.clear();
@@ -548,7 +550,7 @@ public interface DispenseItemBehavior {
                 org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(singleItemStack);
 
                 org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector((double) blockPos.getX() + 0.5D, (double) blockPos.getY(), (double) blockPos.getZ() + 0.5D));
-                if (!DispenserBlock.eventFired) {
+                if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                     level.getCraftServer().getPluginManager().callEvent(event);
                 }
 
@@ -591,7 +593,7 @@ public interface DispenseItemBehavior {
                     org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item.copyWithCount(1)); // Paper - single item in event
 
                     org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), org.bukkit.craftbukkit.util.CraftVector.toBukkit(blockPos));
-                    if (!DispenserBlock.eventFired) {
+                    if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                         level.getCraftServer().getPluginManager().callEvent(event);
                     }
 
@@ -644,7 +646,7 @@ public interface DispenseItemBehavior {
                 org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item.copyWithCount(1)); // Paper - single item in event
 
                 org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), org.bukkit.craftbukkit.util.CraftVector.toBukkit(blockPos));
-                if (!DispenserBlock.eventFired) {
+                if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                     level.getCraftServer().getPluginManager().callEvent(event);
                 }
 
@@ -702,7 +704,7 @@ public interface DispenseItemBehavior {
                     org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item.copyWithCount(1)); // Paper - only single item in event
 
                     org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), org.bukkit.craftbukkit.util.CraftVector.toBukkit(blockPos));
-                    if (!DispenserBlock.eventFired) {
+                    if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                         serverLevel.getCraftServer().getPluginManager().callEvent(event);
                     }
 
@@ -783,7 +785,7 @@ public interface DispenseItemBehavior {
                     org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item); // Paper - ignore stack size on damageable items
 
                     org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseArmorEvent(block, craftItem.clone(), entitiesOfClass.get(0).getBukkitLivingEntity());
-                    if (!DispenserBlock.eventFired) {
+                    if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                         serverLevel.getCraftServer().getPluginManager().callEvent(event);
                     }
 
diff --git a/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java b/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java
index b91b2f5ea6a1da0477541dc65fdfbfa57b9af475..136c52cab0097fb68e8d12f653f1dab934de9bde 100644
--- a/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java
+++ b/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java
@@ -39,7 +39,7 @@ public class EquipmentDispenseItemBehavior extends DefaultDispenseItemBehavior {
             org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemStack);
 
             org.bukkit.event.block.BlockDispenseArmorEvent event = new org.bukkit.event.block.BlockDispenseArmorEvent(block, craftItem.clone(), (org.bukkit.craftbukkit.entity.CraftLivingEntity) livingEntity.getBukkitEntity());
-            if (!DispenserBlock.eventFired) {
+            if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                 world.getCraftServer().getPluginManager().callEvent(event);
             }
 
diff --git a/net/minecraft/core/dispenser/MinecartDispenseItemBehavior.java b/net/minecraft/core/dispenser/MinecartDispenseItemBehavior.java
index 116395b6c00a0814922516707544a9ff26d68835..11d4da87aa80aa338d5f3048285079777bae7d3d 100644
--- a/net/minecraft/core/dispenser/MinecartDispenseItemBehavior.java
+++ b/net/minecraft/core/dispenser/MinecartDispenseItemBehavior.java
@@ -62,7 +62,7 @@ public class MinecartDispenseItemBehavior extends DefaultDispenseItemBehavior {
         org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack1);
 
         org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block2, craftItem.clone(), new org.bukkit.util.Vector(vec31.x, vec31.y, vec31.z));
-        if (!DispenserBlock.eventFired) {
+        if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
             serverLevel.getCraftServer().getPluginManager().callEvent(event);
         }
 
diff --git a/net/minecraft/core/dispenser/ProjectileDispenseBehavior.java b/net/minecraft/core/dispenser/ProjectileDispenseBehavior.java
index 449d9b72ff4650961daa9d1bd25940f3914a6b12..ce12d4729d100be7dffaf4bdfc1c999d68c07bac 100644
--- a/net/minecraft/core/dispenser/ProjectileDispenseBehavior.java
+++ b/net/minecraft/core/dispenser/ProjectileDispenseBehavior.java
@@ -32,7 +32,7 @@ public class ProjectileDispenseBehavior extends DefaultDispenseItemBehavior {
         org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack1);
 
         org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector((double) direction.getStepX(), (double) direction.getStepY(), (double) direction.getStepZ()));
-        if (!DispenserBlock.eventFired) {
+        if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
             serverLevel.getCraftServer().getPluginManager().callEvent(event);
         }
 
diff --git a/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java b/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java
index 626e9feb6a6e7a2cbc7c63e30ba4fb6b923e85c7..81b37cf681ff0220263628b390910d9597662a3a 100644
--- a/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java
+++ b/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java
@@ -25,7 +25,7 @@ public class ShearsDispenseItemBehavior extends OptionalDispenseItemBehavior {
         org.bukkit.block.Block bukkitBlock = org.bukkit.craftbukkit.block.CraftBlock.at(serverLevel, blockSource.pos());
         org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item); // Paper - ignore stack size on damageable items
         org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
-        if (!DispenserBlock.eventFired) {
+        if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
             serverLevel.getCraftServer().getPluginManager().callEvent(event);
         }
 
diff --git a/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java b/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
index 5ab2c8333178335515e619b87ae420f948c83bd1..e3034132c9119956e15a6a0342173d70e44ad669 100644
--- a/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
+++ b/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
@@ -27,7 +27,7 @@ public class ShulkerBoxDispenseBehavior extends OptionalDispenseItemBehavior {
             org.bukkit.craftbukkit.inventory.CraftItemStack craftItem = org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(item.copyWithCount(1)); // Paper - single item in event
 
             org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockPos.getX(), blockPos.getY(), blockPos.getZ()));
-            if (!DispenserBlock.eventFired) {
+            if (!DispenserBlock.getEventFiredTL()) { // DivineMC - Parallel world ticking
                 blockSource.level().getCraftServer().getPluginManager().callEvent(event);
             }
 
diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
index 4cb26cb312802ffc00426293014ed3994793a391..5a726da8535aa939f043829a3c60fdd9d4ed154a 100644
--- a/net/minecraft/server/MinecraftServer.java
+++ b/net/minecraft/server/MinecraftServer.java
@@ -288,6 +288,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
     public boolean lagging = false; // Purpur - Lagging threshold
     public static final long SERVER_INIT = System.nanoTime(); // Paper - Lag compensation
     protected boolean upnp = false; // Purpur - UPnP Port Forwarding
+    public java.util.concurrent.Semaphore serverLevelTickingSemaphore = null; // DivineMC - Parallel world ticking
 
     public static <S extends MinecraftServer> S spin(Function<Thread, S> threadFunction) {
         ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.init(); // Paper - rewrite data converter system
@@ -320,24 +321,36 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
     private long lastMidTickExecute;
     private long lastMidTickExecuteFailure;
 
+    // DivineMC start - Parallel world ticking
+    private boolean tickLevelMidTickTasks(ServerLevel world) {
+        long currTime = System.nanoTime();
+        if (currTime - ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)world).moonrise$getLastMidTickFailure() <= TASK_EXECUTION_FAILURE_BACKOFF) {
+            return false;
+        }
+        if (!world.getChunkSource().pollTask()) {
+            // we need to back off if this fails
+            ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)world).moonrise$setLastMidTickFailure(currTime);
+            return false;
+        }
+        return true;
+    }
+    // DivineMC end - Parallel world ticking
+
     private boolean tickMidTickTasks() {
         // give all worlds a fair chance at by targeting them all.
         // if we execute too many tasks, that's fine - we have logic to correctly handle overuse of allocated time.
-        boolean executed = false;
-        for (final ServerLevel world : this.getAllLevels()) {
-            long currTime = System.nanoTime();
-            if (currTime - ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)world).moonrise$getLastMidTickFailure() <= TASK_EXECUTION_FAILURE_BACKOFF) {
-                continue;
-            }
-            if (!world.getChunkSource().pollTask()) {
-                // we need to back off if this fails
-                ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)world).moonrise$setLastMidTickFailure(currTime);
-            } else {
-                executed = true;
+        // DivineMC start - Parallel world ticking
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && Thread.currentThread() instanceof ca.spottedleaf.moonrise.common.util.TickThread.ServerLevelTickThread levelThread) {
+            return this.tickLevelMidTickTasks(levelThread.currentlyTickingServerLevel);
+        } else {
+            boolean executed = false;
+            for (final ServerLevel world : this.getAllLevels()) {
+                executed = executed || this.tickLevelMidTickTasks(world);
             }
-        }
 
-        return executed;
+            return executed;
+        }
+        // DivineMC end - Parallel world ticking
     }
 
     @Override
@@ -1666,6 +1679,18 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
         }
     }
 
+    // DivineMC start - Parallel world ticking
+    private void tickLevel(ServerLevel serverLevel, BooleanSupplier hasTimeLeft) {
+        try {
+            serverLevel.tick(hasTimeLeft);
+        } catch (Throwable levelTickingException) {
+            CrashReport crashReport = CrashReport.forThrowable(levelTickingException, "Exception ticking world");
+            serverLevel.fillReportDetails(crashReport);
+            throw new ReportedException(crashReport);
+        }
+    }
+    // DivineMC end - Parallel world ticking
+
     protected void tickChildren(BooleanSupplier hasTimeLeft) {
         this.getPlayerList().getPlayers().forEach(serverPlayer1 -> serverPlayer1.connection.suspendFlushing());
         this.server.getScheduler().mainThreadHeartbeat(); // CraftBukkit
@@ -1714,28 +1739,43 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
         }
 
         this.isIteratingOverLevels = true; // Paper - Throw exception on world create while being ticked
-        for (ServerLevel serverLevel : this.getAllLevels()) {
-            serverLevel.hasPhysicsEvent = org.bukkit.event.block.BlockPhysicsEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - BlockPhysicsEvent
-            serverLevel.hasEntityMoveEvent = io.papermc.paper.event.entity.EntityMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - Add EntityMoveEvent
-            serverLevel.updateLagCompensationTick(); // Paper - lag compensation
-            net.minecraft.world.level.block.entity.HopperBlockEntity.skipHopperEvents = serverLevel.paperConfig().hopper.disableMoveEvent || org.bukkit.event.inventory.InventoryMoveItemEvent.getHandlerList().getRegisteredListeners().length == 0; // Paper - Perf: Optimize Hoppers
-            serverLevel.hasRidableMoveEvent = org.purpurmc.purpur.event.entity.RidableMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Purpur - Ridables
-            /* Drop global time updates
-            if (this.tickCount % 20 == 0) {
-                this.synchronizeTime(serverLevel);
-            }
-            // CraftBukkit end */
+        // DivineMC start - Parallel world ticking
+        java.util.ArrayDeque<java.util.concurrent.Future<ServerLevel>> tasks = new java.util.ArrayDeque<>();
+        try {
+            for (ServerLevel serverLevel : this.getAllLevels()) {
+                serverLevel.hasPhysicsEvent = org.bukkit.event.block.BlockPhysicsEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - BlockPhysicsEvent
+                serverLevel.hasEntityMoveEvent = io.papermc.paper.event.entity.EntityMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - Add EntityMoveEvent
+                serverLevel.updateLagCompensationTick(); // Paper - lag compensation
+                net.minecraft.world.level.block.entity.HopperBlockEntity.skipHopperEvents = serverLevel.paperConfig().hopper.disableMoveEvent || org.bukkit.event.inventory.InventoryMoveItemEvent.getHandlerList().getRegisteredListeners().length == 0; // Paper - Perf: Optimize Hoppers
+                serverLevel.hasRidableMoveEvent = org.purpurmc.purpur.event.entity.RidableMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Purpur - Ridables
+                if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+                    serverLevelTickingSemaphore.acquire();
+                    tasks.add(
+                        serverLevel.tickExecutor.submit(() -> {
+                            ca.spottedleaf.moonrise.common.util.TickThread.ServerLevelTickThread currentThread = (ca.spottedleaf.moonrise.common.util.TickThread.ServerLevelTickThread) Thread.currentThread();
+                            currentThread.currentlyTickingServerLevel = serverLevel;
 
-            try {
-                serverLevel.tick(hasTimeLeft);
-            } catch (Throwable var7) {
-                CrashReport crashReport = CrashReport.forThrowable(var7, "Exception ticking world");
-                serverLevel.fillReportDetails(crashReport);
-                throw new ReportedException(crashReport);
+                            try {
+                                tickLevel(serverLevel, hasTimeLeft);
+                            } finally {
+                                serverLevelTickingSemaphore.release();
+                            }
+                        }, serverLevel)
+                    );
+                } else {
+                    tickLevel(serverLevel, hasTimeLeft);
+                }
+
+                serverLevel.explosionDensityCache.clear(); // Paper - Optimize explosions
             }
 
-            serverLevel.explosionDensityCache.clear(); // Paper - Optimize explosions
+            while (!tasks.isEmpty()) {
+                tasks.pop().get();
+            }
+        } catch (java.lang.InterruptedException | java.util.concurrent.ExecutionException e) {
+            throw new RuntimeException(e);
         }
+        // DivineMC end - Parallel world ticking
         this.isIteratingOverLevels = false; // Paper - Throw exception on world create while being ticked
 
         this.tickConnection();
@@ -1813,6 +1853,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
         Map<ResourceKey<Level>, ServerLevel> oldLevels = this.levels;
         Map<ResourceKey<Level>, ServerLevel> newLevels = Maps.newLinkedHashMap(oldLevels);
         newLevels.remove(level.dimension());
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) level.tickExecutor.shutdown(); // DivineMC - Parallel world ticking
         this.levels = Collections.unmodifiableMap(newLevels);
     }
     // CraftBukkit end
diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
index 0d889730641fd88d4da0c9116226a4dae385e846..f7a061ad623fa909389c60c1d5b4be840f99e2bf 100644
--- a/net/minecraft/server/dedicated/DedicatedServer.java
+++ b/net/minecraft/server/dedicated/DedicatedServer.java
@@ -243,6 +243,12 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
         io.papermc.paper.command.PaperCommands.registerCommands(this); // Paper - setup /paper command
         this.server.spark.registerCommandBeforePlugins(this.server); // Paper - spark
         com.destroystokyo.paper.Metrics.PaperMetrics.startMetrics(); // Paper - start metrics
+        // DivineMC start - Parallel world ticking
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+            serverLevelTickingSemaphore = new java.util.concurrent.Semaphore(org.bxteam.divinemc.DivineConfig.parallelThreadCount);
+            DedicatedServer.LOGGER.info("Using {} permits for Parallel world ticking", serverLevelTickingSemaphore.availablePermits());
+        }
+        // DivineMC end - Parallel world ticking
         /*// Purpur start - Purpur config files // Purpur - Configurable void damage height and damage
         try {
             org.purpurmc.purpur.PurpurConfig.init((java.io.File) options.valueOf("purpur-settings"));
diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
index ba5ca5213fafd60b2257409f334a7c6b28fe918a..52ba052fc1ff2a35786570c282a7de4e9dff99f5 100644
--- a/net/minecraft/server/level/ServerLevel.java
+++ b/net/minecraft/server/level/ServerLevel.java
@@ -182,7 +182,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
     private final MinecraftServer server;
     public final net.minecraft.world.level.storage.PrimaryLevelData serverLevelData; // CraftBukkit - type
     private int lastSpawnChunkRadius;
-    final EntityTickList entityTickList = new EntityTickList();
+    final EntityTickList entityTickList = new EntityTickList(this); // DivineMC - Parallel world ticking
     // Paper - rewrite chunk system
     private final GameEventDispatcher gameEventDispatcher;
     public boolean noSave;
@@ -208,6 +208,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
     private double preciseTime; // Purpur - Configurable daylight cycle
     private boolean forceTime; // Purpur - Configurable daylight cycle
     private final RandomSequences randomSequences;
+    public java.util.concurrent.ExecutorService tickExecutor; // DivineMC - Parallel world ticking
 
     // CraftBukkit start
     public final LevelStorageSource.LevelStorageAccess levelStorageAccess;
@@ -700,6 +701,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
         this.chunkDataController = new ca.spottedleaf.moonrise.patches.chunk_system.io.datacontroller.ChunkDataController((ServerLevel)(Object)this, this.chunkTaskScheduler);
         // Paper end - rewrite chunk system
         this.getCraftServer().addWorld(this.getWorld()); // CraftBukkit
+        this.tickExecutor = java.util.concurrent.Executors.newSingleThreadExecutor(new org.bxteam.divinemc.server.ServerLevelTickExecutorThreadFactory(getWorld().getName())); // DivineMC - Parallel world ticking
         this.preciseTime = this.serverLevelData.getDayTime(); // Purpur - Configurable daylight cycle
     }
 
@@ -1281,12 +1283,12 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
         if (fluidState.is(fluid)) {
             fluidState.tick(this, pos, blockState);
         }
-        // Paper start - rewrite chunk system
-        if ((++this.tickedBlocksOrFluids & 7L) != 0L) {
-            ((ca.spottedleaf.moonrise.patches.chunk_system.server.ChunkSystemMinecraftServer)this.server).moonrise$executeMidTickTasks();
+        // DivineMC start - Parallel world ticking
+        ++this.tickedBlocksOrFluids;
+        if (!org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && (this.tickedBlocksOrFluids & 7L) != 0L) {
+            this.server.moonrise$executeMidTickTasks();
         }
-        // Paper end - rewrite chunk system
-
+        // DivineMC end - Parallel world ticking
     }
 
     private void tickBlock(BlockPos pos, Block block) {
@@ -1294,12 +1296,12 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
         if (blockState.is(block)) {
             blockState.tick(this, pos, this.random);
         }
-        // Paper start - rewrite chunk system
-        if ((++this.tickedBlocksOrFluids & 7L) != 0L) {
-            ((ca.spottedleaf.moonrise.patches.chunk_system.server.ChunkSystemMinecraftServer)this.server).moonrise$executeMidTickTasks();
+        // DivineMC start - Parallel world ticking
+        ++this.tickedBlocksOrFluids;
+        if (!org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && (this.tickedBlocksOrFluids & 7L) != 0L) {
+            this.server.moonrise$executeMidTickTasks();
         }
-        // Paper end - rewrite chunk system
-
+        // DivineMC end - Parallel world ticking
     }
 
     // Paper start - log detailed entity tick information
@@ -1548,6 +1550,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
     }
 
     private void addPlayer(ServerPlayer player) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(this, "Cannot add player off-main"); // DivineMC - Parallel world ticking (additional concurrency issues logs)
         Entity entity = this.getEntities().get(player.getUUID());
         if (entity != null) {
             LOGGER.warn("Force-added player with duplicate UUID {}", player.getUUID());
@@ -1560,7 +1563,13 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
 
     // CraftBukkit start
     private boolean addEntity(Entity entity, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason spawnReason) {
-        org.spigotmc.AsyncCatcher.catchOp("entity add"); // Spigot
+        // DivineMC start - Parallel world ticking
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+            ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(this, "Cannot add entity off-main");
+        } else {
+            org.spigotmc.AsyncCatcher.catchOp("entity add"); // Spigot
+        }
+        // DivineMC end - Parallel world ticking
         entity.generation = false; // Paper - Don't fire sync event during generation; Reset flag if it was added during a ServerLevel generation process
         // Paper start - extra debug info
         if (entity.valid) {
diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
index 21d41b477cc0e8d2476d1e3141bdf23d0c06f3e0..195d9dc696a9a7da0bb041612b73c0bbacf2919e 100644
--- a/net/minecraft/server/level/ServerPlayer.java
+++ b/net/minecraft/server/level/ServerPlayer.java
@@ -432,6 +432,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
         return this.viewDistanceHolder;
     }
     // Paper end - rewrite chunk system
+    public boolean hasTickedAtLeastOnceInNewWorld = false; // DivineMC - Parallel world ticking
 
     public ServerPlayer(MinecraftServer server, ServerLevel level, GameProfile gameProfile, ClientInformation clientInformation) {
         super(level, level.getSharedSpawnPos(), level.getSharedSpawnAngle(), gameProfile);
@@ -808,6 +809,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
 
     @Override
     public void tick() {
+        hasTickedAtLeastOnceInNewWorld = true; // DivineMC - Parallel world ticking
         // CraftBukkit start
         if (this.joining) {
             this.joining = false;
@@ -1453,6 +1455,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
                 return this;
             } else {
                 // CraftBukkit start
+                if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureOnlyTickThread("Cannot change dimension of a player off-main, from world " + serverLevel().getWorld().getName() + " to world " + level.getWorld().getName()); // DivineMC - Parallel world ticking (additional concurrency issues logs)
                 /*
                 this.isChangingDimension = true;
                 LevelData levelData = level.getLevelData();
@@ -1815,6 +1818,12 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
                 return OptionalInt.empty();
             } else {
                 // CraftBukkit start
+                // DivineMC start - Parallel world ticking
+                if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && !hasTickedAtLeastOnceInNewWorld) {
+                    MinecraftServer.LOGGER.warn("Ignoring request to open container {} because we haven't ticked in the current world yet!", abstractContainerMenu, new Throwable());
+                    return OptionalInt.empty();
+                }
+                // DivineMC end - Parallel world ticking
                 this.containerMenu = abstractContainerMenu; // Moved up
                 if (!this.isImmobile())
                 this.connection
@@ -1879,6 +1888,11 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
     }
     @Override
     public void closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
+        // DivineMC start - Parallel world ticking (debugging)
+        if (org.bxteam.divinemc.DivineConfig.logContainerCreationStacktraces) {
+            MinecraftServer.LOGGER.warn("Closing {} inventory that was created at", this.getBukkitEntity().getName(), this.containerMenu.containerCreationStacktrace);
+        }
+        // DivineMC end - Parallel world ticking (debugging)
         org.bukkit.craftbukkit.event.CraftEventFactory.handleInventoryCloseEvent(this, reason); // CraftBukkit
         // Paper end - Inventory close reason
         this.connection.send(new ClientboundContainerClosePacket(this.containerMenu.containerId));
diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
index 6f66c5a93383b2897425e117c32add9a34054add..5ff0ce34cfacb745748d3dc627127842ac1df9fa 100644
--- a/net/minecraft/server/players/PlayerList.java
+++ b/net/minecraft/server/players/PlayerList.java
@@ -150,6 +150,7 @@ public abstract class PlayerList {
     abstract public void loadAndSaveFiles(); // Paper - fix converting txt to json file; moved from DedicatedPlayerList constructor
 
     public void placeNewPlayer(Connection connection, ServerPlayer player, CommonListenerCookie cookie) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureOnlyTickThread("Cannot place new player off-main"); // DivineMC - Parallel world ticking
         player.isRealPlayer = true; // Paper
         player.loginTime = System.currentTimeMillis(); // Paper - Replace OfflinePlayer#getLastPlayed
         GameProfile gameProfile = player.getGameProfile();
@@ -716,6 +717,14 @@ public abstract class PlayerList {
         return this.respawn(player, keepInventory, reason, eventReason, null);
     }
     public ServerPlayer respawn(ServerPlayer player, boolean keepInventory, Entity.RemovalReason reason, org.bukkit.event.player.PlayerRespawnEvent.RespawnReason eventReason, org.bukkit.Location location) {
+        // DivineMC start - Parallel world ticking (additional concurrency issues logs)
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+            if (location != null)
+                ca.spottedleaf.moonrise.common.util.TickThread.ensureOnlyTickThread("Cannot respawn player off-main, from world " + player.serverLevel().getWorld().getName() + " to world " + location.getWorld().getName());
+            else
+                ca.spottedleaf.moonrise.common.util.TickThread.ensureOnlyTickThread("Cannot respawn player off-main, respawning in world " + player.serverLevel().getWorld().getName());
+        }
+        // DivineMC end - Parallel world ticking (additional concurrency issues logs)
         this.players.remove(player);
         this.playersByName.remove(player.getScoreboardName().toLowerCase(java.util.Locale.ROOT)); // Spigot
         player.serverLevel().removePlayerImmediately(player, reason);
@@ -725,6 +734,7 @@ public abstract class PlayerList {
         ServerPlayer serverPlayer = player;
         Level fromWorld = player.level();
         player.wonGame = false;
+        serverPlayer.hasTickedAtLeastOnceInNewWorld = false; // DivineMC - Parallel world ticking
         // CraftBukkit end
         serverPlayer.connection = player.connection;
         serverPlayer.restoreFrom(player, keepInventory);
diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
index 4c4bed85db28d92ca55593a19ac23616619e4bd1..7e29f1f1972f2fb4f9a779653467bc85ce37c7bc 100644
--- a/net/minecraft/world/entity/Entity.java
+++ b/net/minecraft/world/entity/Entity.java
@@ -3314,14 +3314,34 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
             if (this.portalProcess != null) {
                 if (this.portalProcess.processPortalTeleportation(serverLevel, this, this.canUsePortal(false))) {
                     this.setPortalCooldown();
-                    TeleportTransition portalDestination = this.portalProcess.getPortalDestination(serverLevel, this);
-                    if (portalDestination != null) {
-                        ServerLevel level = portalDestination.newLevel();
-                        if (this instanceof ServerPlayer // CraftBukkit - always call event for players
-                            || (level != null && (level.dimension() == serverLevel.dimension() || this.canTeleport(serverLevel, level)))) { // CraftBukkit
-                            this.teleport(portalDestination);
+                    // DivineMC start - Parallel world ticking
+                    java.util.function.Consumer<Entity> portalEntityTask = entity -> {
+                        assert entity.portalProcess != null;
+
+                        if (entity.portalProcess.isParallelCancelledByPlugin()) {
+                            entity.portalProcess = null;
+                            return;
+                        }
+
+                        TeleportTransition portalDestination = entity.portalProcess.getPortalDestination(serverLevel, entity);
+                        if (portalDestination != null) {
+                            ServerLevel level = portalDestination.newLevel();
+                            if (entity instanceof ServerPlayer // CraftBukkit - always call event for players
+                                || (level != null && (level.dimension() == serverLevel.dimension() || entity.canTeleport(serverLevel, level)))) { // CraftBukkit
+                                entity.teleport(portalDestination);
+                            }
                         }
+                        if (this.portalProcess != null)
+                            entity.portalProcess.confirmParallelAsHandled();
+                    };
+
+                    if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+                        this.portalProcess.setParallelAsScheduled();
+                        this.getBukkitEntity().taskScheduler.schedule(portalEntityTask, entity -> {}, 0);
+                    } else {
+                        portalEntityTask.accept(this);
                     }
+                    // DivineMC end - Parallel world ticking
                 } else if (this.portalProcess.hasExpired()) {
                     this.portalProcess = null;
                 }
@@ -3851,6 +3871,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
     }
 
     private Entity teleportCrossDimension(ServerLevel level, TeleportTransition teleportTransition) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(level, "Cannot teleport entity to another world off-main, from world " + this.level.getWorld().getName() + " to world " + level.getWorld().getName()); // DivineMC - Parallel world ticking
         List<Entity> passengers = this.getPassengers();
         List<Entity> list = new ArrayList<>(passengers.size());
         this.ejectPassengers();
diff --git a/net/minecraft/world/entity/PortalProcessor.java b/net/minecraft/world/entity/PortalProcessor.java
index 88b07fbb96b20124777889830afa480673629d43..be357d9e3c5327ceec12c31830551a564c8cea1b 100644
--- a/net/minecraft/world/entity/PortalProcessor.java
+++ b/net/minecraft/world/entity/PortalProcessor.java
@@ -11,6 +11,7 @@ public class PortalProcessor {
     private BlockPos entryPosition;
     private int portalTime;
     private boolean insidePortalThisTick;
+    private org.bxteam.divinemc.util.PWTTeleportState teleportState = org.bxteam.divinemc.util.PWTTeleportState.INACTIVE; // DivineMC - Parallel world ticking
 
     public PortalProcessor(Portal portal, BlockPos entryPosition) {
         this.portal = portal;
@@ -19,6 +20,7 @@ public class PortalProcessor {
     }
 
     public boolean processPortalTeleportation(ServerLevel level, Entity entity, boolean canChangeDimensions) {
+        if (this.isParallelTeleportScheduled()) return false; // DivineMC - Parallel world ticking
         if (!this.insidePortalThisTick) {
             this.decayTick();
             return false;
@@ -42,7 +44,7 @@ public class PortalProcessor {
     }
 
     public boolean hasExpired() {
-        return this.portalTime <= 0;
+        return !this.isParallelTeleportScheduled() && this.portalTime <= 0; // DivineMC - Parallel world ticking
     }
 
     public BlockPos getEntryPosition() {
@@ -68,4 +70,30 @@ public class PortalProcessor {
     public boolean isSamePortal(Portal portal) {
         return this.portal == portal;
     }
+
+    // DivineMC start - Parallel world ticking
+    public boolean isParallelTeleportPending() {
+        return this.teleportState == org.bxteam.divinemc.util.PWTTeleportState.PENDING;
+    }
+
+    public boolean isParallelTeleportScheduled() {
+        return this.teleportState != org.bxteam.divinemc.util.PWTTeleportState.INACTIVE;
+    }
+
+    public boolean isParallelCancelledByPlugin() {
+        return this.teleportState == org.bxteam.divinemc.util.PWTTeleportState.CANCELLED;
+    }
+
+    public void setParallelAsScheduled() {
+        this.teleportState = org.bxteam.divinemc.util.PWTTeleportState.PENDING;
+    }
+
+    public void confirmParallelAsHandled() {
+        this.teleportState = org.bxteam.divinemc.util.PWTTeleportState.INACTIVE;
+    }
+
+    public void setParallelAsCancelled() {
+        this.teleportState = org.bxteam.divinemc.util.PWTTeleportState.CANCELLED;
+    }
+    // DivineMC end - Parallel world ticking
 }
diff --git a/net/minecraft/world/entity/ai/behavior/GoToPotentialJobSite.java b/net/minecraft/world/entity/ai/behavior/GoToPotentialJobSite.java
index 3614551856c594f3c0cfee984fcf03fad672b007..6add256046e392d8eb797e3fa9d1cbe7cca575df 100644
--- a/net/minecraft/world/entity/ai/behavior/GoToPotentialJobSite.java
+++ b/net/minecraft/world/entity/ai/behavior/GoToPotentialJobSite.java
@@ -46,12 +46,22 @@ public class GoToPotentialJobSite extends Behavior<Villager> {
             BlockPos blockPos = globalPos.pos();
             ServerLevel level1 = level.getServer().getLevel(globalPos.dimension());
             if (level1 != null) {
-                PoiManager poiManager = level1.getPoiManager();
-                if (poiManager.exists(blockPos, holder -> true)) {
-                    poiManager.release(blockPos);
-                }
+                // DivineMC start - Parallel world ticking
+                Runnable releasePoiTask = () -> {
+                    PoiManager poiManager = level1.getPoiManager();
+                    if (poiManager.exists(blockPos, holder -> true)) {
+                        poiManager.release(blockPos);
+                    }
+
+                    DebugPackets.sendPoiTicketCountPacket(level, blockPos);
+                };
 
-                DebugPackets.sendPoiTicketCountPacket(level, blockPos);
+                if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+                    level.moonrise$getChunkTaskScheduler().scheduleChunkTask(0, 0, releasePoiTask, ca.spottedleaf.concurrentutil.util.Priority.BLOCKING);
+                } else {
+                    releasePoiTask.run();
+                }
+                // DivineMC end - Parallel world ticking
             }
         });
         entity.getBrain().eraseMemory(MemoryModuleType.POTENTIAL_JOB_SITE);
diff --git a/net/minecraft/world/entity/npc/Villager.java b/net/minecraft/world/entity/npc/Villager.java
index fec90e482c8935dfca609bbf90e67f86a1586221..4ee1791f293ba3abdbfe69824b85566fd9a36586 100644
--- a/net/minecraft/world/entity/npc/Villager.java
+++ b/net/minecraft/world/entity/npc/Villager.java
@@ -803,13 +803,24 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
             this.brain.getMemory(moduleType).ifPresent(globalPos -> {
                 ServerLevel level = server.getLevel(globalPos.dimension());
                 if (level != null) {
-                    PoiManager poiManager = level.getPoiManager();
-                    Optional<Holder<PoiType>> type = poiManager.getType(globalPos.pos());
-                    BiPredicate<Villager, Holder<PoiType>> biPredicate = POI_MEMORIES.get(moduleType);
-                    if (type.isPresent() && biPredicate.test(this, type.get())) {
-                        poiManager.release(globalPos.pos());
-                        DebugPackets.sendPoiTicketCountPacket(level, globalPos.pos());
+                    // DivineMC start - Parallel world ticking
+                    Runnable releasePoiTask = () -> {
+                        PoiManager poiManager = level.getPoiManager();
+                        Optional<Holder<PoiType>> type = poiManager.getType(globalPos.pos());
+                        BiPredicate<Villager, Holder<PoiType>> biPredicate = POI_MEMORIES.get(moduleType);
+                        if (type.isPresent() && biPredicate.test(this, type.get())) {
+                            poiManager.release(globalPos.pos());
+                            DebugPackets.sendPoiTicketCountPacket(level, globalPos.pos());
+                        }
+                    };
+
+                    if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+                        level.moonrise$getChunkTaskScheduler().scheduleChunkTask(0, 0, releasePoiTask, ca.spottedleaf.concurrentutil.util.Priority.BLOCKING);
+                    }
+                    else {
+                        releasePoiTask.run();
                     }
+                    // DivineMC end - Parallel world ticking
                 }
             });
         }
diff --git a/net/minecraft/world/entity/projectile/ThrownEnderpearl.java b/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
index d212f57c8c0b2086f567fd30237b110203d9e8cb..d59bdab65c034bab443ea9448930fdff85a85392 100644
--- a/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
+++ b/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
@@ -126,40 +126,50 @@ public class ThrownEnderpearl extends ThrowableItemProjectile {
                 Vec3 vec3 = this.oldPosition();
                 if (owner instanceof ServerPlayer serverPlayer) {
                     if (serverPlayer.connection.isAcceptingMessages()) {
-                        // CraftBukkit start
-                        ServerPlayer serverPlayer1 = serverPlayer.teleport(new TeleportTransition(serverLevel, vec3, Vec3.ZERO, 0.0F, 0.0F, Relative.union(Relative.ROTATION, Relative.DELTA), TeleportTransition.DO_NOTHING, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.ENDER_PEARL));
-                        if (serverPlayer1 == null) {
-                            this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.HIT);
-                            return;
-                        }
-                        // CraftBukkit end
-                        if (this.random.nextFloat() < serverLevel.purpurConfig.enderPearlEndermiteChance && serverLevel.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING)) { // Purpur - Configurable Ender Pearl RNG
-                            Endermite endermite = EntityType.ENDERMITE.create(serverLevel, EntitySpawnReason.TRIGGERED);
-                            if (endermite != null) {
-                                endermite.setPlayerSpawned(true); // Purpur - Add back player spawned endermite API
-                                endermite.moveTo(owner.getX(), owner.getY(), owner.getZ(), owner.getYRot(), owner.getXRot());
-                                serverLevel.addFreshEntity(endermite, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.ENDER_PEARL);
+                        // DivineMC start - Parallel world ticking
+                        java.util.function.Consumer<ServerPlayer> teleportPlayerCrossDimensionTask = taskServerPlayer -> {
+                            // CraftBukkit start
+                            ServerPlayer serverPlayer1 = serverPlayer.teleport(new TeleportTransition(serverLevel, vec3, Vec3.ZERO, 0.0F, 0.0F, Relative.union(Relative.ROTATION, Relative.DELTA), TeleportTransition.DO_NOTHING, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.ENDER_PEARL));
+                            if (serverPlayer1 == null) {
+                                this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.HIT);
+                                return;
+                            }
+                            // CraftBukkit end
+                            if (this.random.nextFloat() < serverLevel.purpurConfig.enderPearlEndermiteChance && serverLevel.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING)) { // Purpur - Configurable Ender Pearl RNG
+                                Endermite endermite = EntityType.ENDERMITE.create(serverLevel, EntitySpawnReason.TRIGGERED);
+                                if (endermite != null) {
+                                    endermite.setPlayerSpawned(true); // Purpur - Add back player spawned endermite API
+                                    endermite.moveTo(owner.getX(), owner.getY(), owner.getZ(), owner.getYRot(), owner.getXRot());
+                                    serverLevel.addFreshEntity(endermite, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.ENDER_PEARL);
+                                }
                             }
-                        }
 
-                        if (this.isOnPortalCooldown()) {
-                            owner.setPortalCooldown();
-                        }
+                            if (this.isOnPortalCooldown()) {
+                                owner.setPortalCooldown();
+                            }
 
-                        // CraftBukkit start - moved up
-                        // ServerPlayer serverPlayer1 = serverPlayer.teleport(
-                        //     new TeleportTransition(
-                        //         serverLevel, vec3, Vec3.ZERO, 0.0F, 0.0F, Relative.union(Relative.ROTATION, Relative.DELTA), TeleportTransition.DO_NOTHING
-                        //     )
-                        // );
-                        // CraftBukkit end - moved up
-                        if (serverPlayer1 != null) {
-                            serverPlayer1.resetFallDistance();
-                            serverPlayer1.resetCurrentImpulseContext();
-                            serverPlayer1.hurtServer(serverPlayer.serverLevel(), this.damageSources().enderPearl().eventEntityDamager(this), this.level().purpurConfig.enderPearlDamage); // CraftBukkit // Paper - fix DamageSource API // Purpur - Configurable Ender Pearl damage
-                        }
+                            // CraftBukkit start - moved up
+                            // ServerPlayer serverPlayer1 = serverPlayer.teleport(
+                            //     new TeleportTransition(
+                            //         serverLevel, vec3, Vec3.ZERO, 0.0F, 0.0F, Relative.union(Relative.ROTATION, Relative.DELTA), TeleportTransition.DO_NOTHING
+                            //     )
+                            // );
+                            // CraftBukkit end - moved up
+                            if (serverPlayer1 != null) {
+                                serverPlayer1.resetFallDistance();
+                                serverPlayer1.resetCurrentImpulseContext();
+                                serverPlayer1.hurtServer(serverPlayer.serverLevel(), this.damageSources().enderPearl().eventEntityDamager(this), this.level().purpurConfig.enderPearlDamage); // CraftBukkit // Paper - fix DamageSource API // Purpur - Configurable Ender Pearl damage
+                            }
 
-                        this.playSound(serverLevel, vec3);
+                            this.playSound(serverLevel, vec3);
+                        };
+
+                        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+                            serverPlayer.getBukkitEntity().taskScheduler.schedule(teleportPlayerCrossDimensionTask, entity -> {}, 0);
+                        } else {
+                            teleportPlayerCrossDimensionTask.accept(serverPlayer);
+                        }
+                        // DivineMC end - Parallel world ticking
                     }
                 } else {
                     Entity entity = owner.teleport(
diff --git a/net/minecraft/world/inventory/AbstractContainerMenu.java b/net/minecraft/world/inventory/AbstractContainerMenu.java
index e6419715fab462b12790ecb175ce1e1a1fceed8f..b03068bb94c785db51da660361ce28b9f4b45898 100644
--- a/net/minecraft/world/inventory/AbstractContainerMenu.java
+++ b/net/minecraft/world/inventory/AbstractContainerMenu.java
@@ -92,8 +92,14 @@ public abstract class AbstractContainerMenu {
     }
     public void startOpen() {}
     // CraftBukkit end
+    public Throwable containerCreationStacktrace; // DivineMC - Parallel world ticking
 
     protected AbstractContainerMenu(@Nullable MenuType<?> menuType, int containerId) {
+        // DivineMC start - Parallel world ticking (debugging)
+        if (org.bxteam.divinemc.DivineConfig.logContainerCreationStacktraces) {
+            this.containerCreationStacktrace = new Throwable();
+        }
+        // DivineMC start - Parallel world ticking (debugging)
         this.menuType = menuType;
         this.containerId = containerId;
     }
diff --git a/net/minecraft/world/item/ItemStack.java b/net/minecraft/world/item/ItemStack.java
index 264b713e8b7c3d5f7d8e1facc90a60349f2cf414..596abdcda01e412d995d150ca9d056a5278ea691 100644
--- a/net/minecraft/world/item/ItemStack.java
+++ b/net/minecraft/world/item/ItemStack.java
@@ -407,8 +407,10 @@ public final class ItemStack implements DataComponentHolder {
             if (interactionResult.consumesAction() && serverLevel.captureTreeGeneration && !serverLevel.capturedBlockStates.isEmpty()) {
                 serverLevel.captureTreeGeneration = false;
                 org.bukkit.Location location = org.bukkit.craftbukkit.util.CraftLocation.toBukkit(clickedPos, serverLevel.getWorld());
-                org.bukkit.TreeType treeType = net.minecraft.world.level.block.SaplingBlock.treeType;
-                net.minecraft.world.level.block.SaplingBlock.treeType = null;
+                // DivineMC start - Parallel world ticking
+                org.bukkit.TreeType treeType = net.minecraft.world.level.block.SaplingBlock.getTreeTypeTL();
+                net.minecraft.world.level.block.SaplingBlock.setTreeTypeTL(null);
+                // DivineMC end - Parallel world ticking
                 List<org.bukkit.craftbukkit.block.CraftBlockState> blocks = new java.util.ArrayList<>(serverLevel.capturedBlockStates.values());
                 serverLevel.capturedBlockStates.clear();
                 org.bukkit.event.world.StructureGrowEvent structureEvent = null;
diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
index 0c58919e8242317ba276e103b81d07006c41deca..788e83078e9e430b84bf5dc9df877eb7ef46543b 100644
--- a/net/minecraft/world/level/Level.java
+++ b/net/minecraft/world/level/Level.java
@@ -170,6 +170,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
     public final io.papermc.paper.antixray.ChunkPacketBlockController chunkPacketBlockController; // Paper - Anti-Xray
     public final org.purpurmc.purpur.PurpurWorldConfig purpurConfig; // Purpur - Purpur config files
     public final org.bxteam.divinemc.DivineWorldConfig divineConfig; // DivineMC - Configuration
+    public io.papermc.paper.redstone.RedstoneWireTurbo turbo = new io.papermc.paper.redstone.RedstoneWireTurbo((net.minecraft.world.level.block.RedStoneWireBlock) net.minecraft.world.level.block.Blocks.REDSTONE_WIRE); // DivineMC - Parallel world ticking (moved to world)
     public static BlockPos lastPhysicsProblem; // Spigot
     private org.spigotmc.TickLimiter entityLimiter;
     private org.spigotmc.TickLimiter tileLimiter;
@@ -1149,6 +1150,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
 
     @Override
     public boolean setBlock(BlockPos pos, BlockState state, int flags, int recursionLeft) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread((ServerLevel)this, pos, "Updating block asynchronously"); // DivineMC - Parallel world ticking (additional concurrency issues logs)
         // CraftBukkit start - tree generation
         if (this.captureTreeGeneration) {
             // Paper start - Protect Bedrock and End Portal/Frames from being destroyed
@@ -1529,11 +1531,12 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
                 toRemove.add(tickingBlockEntity); // Paper - Fix MC-117075; use removeAll
             } else if (runsNormally && this.shouldTickBlocksAt(tickingBlockEntity.getPos())) {
                 tickingBlockEntity.tick();
-                // Paper start - rewrite chunk system
-                if ((++tickedEntities & 7) == 0) {
-                    ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemLevel)(Level)(Object)this).moonrise$midTickTasks();
+                // DivineMC start - Parallel world ticking
+                ++tickedEntities;
+                if (!org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && (tickedEntities & 7) == 0) {
+                    this.moonrise$midTickTasks();
                 }
-                // Paper end - rewrite chunk system
+                // DivineMC end - Parallel world ticking
             }
         }
         this.blockEntityTickers.removeAll(toRemove); // Paper - Fix MC-117075
@@ -1553,7 +1556,11 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
             entity.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DISCARD);
             // Paper end - Prevent block entity and entity crashes
         }
-        this.moonrise$midTickTasks(); // Paper - rewrite chunk system
+        // DivineMC start - Parallel world ticking
+        if (!org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+            this.moonrise$midTickTasks(); // Paper - rewrite chunk system
+        }
+        // DivineMC end - Parallel world ticking
     }
 
     // Paper start - Option to prevent armor stands from doing entity lookups
@@ -1696,6 +1703,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
 
     @Nullable
     public BlockEntity getBlockEntity(BlockPos pos, boolean validate) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThreadOrAsyncThread((ServerLevel) this, "Cannot read world asynchronously"); // DivineMC - Parallel world ticking
         // Paper start - Perf: Optimize capturedTileEntities lookup
         net.minecraft.world.level.block.entity.BlockEntity blockEntity;
         if (!this.capturedTileEntities.isEmpty() && (blockEntity = this.capturedTileEntities.get(pos)) != null) {
@@ -1713,6 +1721,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
     }
 
     public void setBlockEntity(BlockEntity blockEntity) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread((ServerLevel) this, "Cannot modify world asynchronously"); // DivineMC - Parallel world ticking
         BlockPos blockPos = blockEntity.getBlockPos();
         if (!this.isOutsideBuildHeight(blockPos)) {
             // CraftBukkit start
@@ -1797,6 +1806,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
 
     @Override
     public List<Entity> getEntities(@Nullable Entity entity, AABB boundingBox, Predicate<? super Entity> predicate) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread((ServerLevel)this, boundingBox, "Cannot getEntities asynchronously"); // DivineMC - Parallel world ticking (additional concurrency issues logs)
         List<Entity> list = Lists.newArrayList();
 
         // Paper start - rewrite chunk system
@@ -2106,8 +2116,15 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
     public abstract RecipeAccess recipeAccess();
 
     public BlockPos getBlockRandomPos(int x, int y, int z, int yMask) {
-        this.randValue = this.randValue * 3 + 1013904223;
-        int i = this.randValue >> 2;
+        // DivineMC start - Parallel world ticking
+        int i;
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+            i = this.random.nextInt() >> 2;
+        } else {
+            this.randValue = this.randValue * 3 + 1013904223;
+            i = this.randValue >> 2;
+        }
+        // DivineMC end - Parallel world ticking
         return new BlockPos(x + (i & 15), y + (i >> 16 & yMask), z + (i >> 8 & 15));
     }
 
diff --git a/net/minecraft/world/level/block/DispenserBlock.java b/net/minecraft/world/level/block/DispenserBlock.java
index e0a4d41e5bcf144ea4c10d6f633c3a95ed2c5aec..12ead3dc17828558b2e6b67a5f306a5948f7b2cf 100644
--- a/net/minecraft/world/level/block/DispenserBlock.java
+++ b/net/minecraft/world/level/block/DispenserBlock.java
@@ -51,6 +51,25 @@ public class DispenserBlock extends BaseEntityBlock {
     public static final Map<Item, DispenseItemBehavior> DISPENSER_REGISTRY = new IdentityHashMap<>();
     private static final int TRIGGER_DURATION = 4;
     public static boolean eventFired = false; // CraftBukkit
+    // DivineMC start - Parallel world ticking
+    public static ThreadLocal<Boolean> eventFiredTL = ThreadLocal.withInitial(() -> Boolean.FALSE);
+
+    public static boolean getEventFiredTL() {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && eventFiredTL.get()) return true;
+
+        synchronized (DispenserBlock.class) {
+            return eventFired;
+        }
+    }
+
+    public static void setEventFiredTL(boolean value) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) eventFiredTL.set(value);
+
+        synchronized (DispenserBlock.class) {
+            eventFired = value;
+        }
+    }
+    // DivineMC end - Parallel world ticking
 
     @Override
     public MapCodec<? extends DispenserBlock> codec() {
@@ -96,7 +115,7 @@ public class DispenserBlock extends BaseEntityBlock {
                 DispenseItemBehavior dispenseMethod = this.getDispenseMethod(level, item);
                 if (dispenseMethod != DispenseItemBehavior.NOOP) {
                     if (!org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockPreDispenseEvent(level, pos, item, randomSlot)) return; // Paper - Add BlockPreDispenseEvent
-                    DispenserBlock.eventFired = false; // CraftBukkit - reset event status
+                    DispenserBlock.setEventFiredTL(Boolean.FALSE); // CraftBukkit - reset event status // DivineMC - Parallel world ticking
                     dispenserBlockEntity.setItem(randomSlot, dispenseMethod.dispense(blockSource, item));
                 }
             }
diff --git a/net/minecraft/world/level/block/FungusBlock.java b/net/minecraft/world/level/block/FungusBlock.java
index 85f0eac75784565c658c5178c544f969db3d6f54..fc900a7c382f825110c561070155c1f6451557ed 100644
--- a/net/minecraft/world/level/block/FungusBlock.java
+++ b/net/minecraft/world/level/block/FungusBlock.java
@@ -76,9 +76,9 @@ public class FungusBlock extends BushBlock implements BonemealableBlock {
             // CraftBukkit start
             .map((value) -> {
                 if (this == Blocks.WARPED_FUNGUS) {
-                    SaplingBlock.treeType = org.bukkit.TreeType.WARPED_FUNGUS;
+                    SaplingBlock.setTreeTypeTL(org.bukkit.TreeType.WARPED_FUNGUS); // DivineMC - Parallel world ticking
                 } else if (this == Blocks.CRIMSON_FUNGUS) {
-                    SaplingBlock.treeType = org.bukkit.TreeType.CRIMSON_FUNGUS;
+                    SaplingBlock.setTreeTypeTL(org.bukkit.TreeType.CRIMSON_FUNGUS); // DivineMC - Parallel world ticking
                 }
                 return value;
             })
diff --git a/net/minecraft/world/level/block/MushroomBlock.java b/net/minecraft/world/level/block/MushroomBlock.java
index 904369f4d7db41026183f2de7c96c2f0f4dc204d..371334bc3a1ea505b3293f13542aef4cf8f2a2d2 100644
--- a/net/minecraft/world/level/block/MushroomBlock.java
+++ b/net/minecraft/world/level/block/MushroomBlock.java
@@ -94,7 +94,7 @@ public class MushroomBlock extends BushBlock implements BonemealableBlock {
             return false;
         } else {
             level.removeBlock(pos, false);
-            SaplingBlock.treeType = (this == Blocks.BROWN_MUSHROOM) ? org.bukkit.TreeType.BROWN_MUSHROOM : org.bukkit.TreeType.RED_MUSHROOM; // CraftBukkit
+            SaplingBlock.setTreeTypeTL((this == Blocks.BROWN_MUSHROOM) ? org.bukkit.TreeType.BROWN_MUSHROOM : org.bukkit.TreeType.RED_MUSHROOM); // CraftBukkit // DivineMC - Parallel world ticking
             if (optional.get().value().place(level, level.getChunkSource().getGenerator(), random, pos)) {
                 return true;
             } else {
diff --git a/net/minecraft/world/level/block/RedStoneWireBlock.java b/net/minecraft/world/level/block/RedStoneWireBlock.java
index 12c9d60314c99fb65e640d255a2d0c6b7790ad4d..4293c5f11a17500353b63cad399727ece1461c5e 100644
--- a/net/minecraft/world/level/block/RedStoneWireBlock.java
+++ b/net/minecraft/world/level/block/RedStoneWireBlock.java
@@ -308,7 +308,13 @@ public class RedStoneWireBlock extends Block {
             if (orientation != null) {
                 source = pos.relative(orientation.getFront().getOpposite());
             }
-            turbo.updateSurroundingRedstone(worldIn, pos, state, source);
+            // DivineMC start - Parallel world ticking
+            if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+                worldIn.turbo.updateSurroundingRedstone(worldIn, pos, state, source);
+            } else {
+                turbo.updateSurroundingRedstone(worldIn, pos, state, source);
+            }
+            // DivineMC end
             return;
         }
         updatePowerStrength(worldIn, pos, state, orientation, blockAdded);
@@ -336,7 +342,13 @@ public class RedStoneWireBlock extends Block {
                 // [Space Walker] suppress shape updates and emit those manually to
                 // bypass the new neighbor update stack.
                 if (level.setBlock(pos, state, Block.UPDATE_KNOWN_SHAPE | Block.UPDATE_CLIENTS)) {
-                    turbo.updateNeighborShapes(level, pos, state);
+                    // DivineMC start - Parallel world ticking
+                    if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) {
+                        level.turbo.updateNeighborShapes(level, pos, state);
+                    } else {
+                        turbo.updateNeighborShapes(level, pos, state);
+                    }
+                    // DivineMC end - Parallel world ticking
                 }
             }
         }
diff --git a/net/minecraft/world/level/block/SaplingBlock.java b/net/minecraft/world/level/block/SaplingBlock.java
index e014f052e9b0f5ca6b28044e2389782b7d0e0cb8..4ad0e278a348407beed1ec4381bfeacf4de32a0d 100644
--- a/net/minecraft/world/level/block/SaplingBlock.java
+++ b/net/minecraft/world/level/block/SaplingBlock.java
@@ -27,6 +27,26 @@ public class SaplingBlock extends BushBlock implements BonemealableBlock {
     protected static final VoxelShape SHAPE = Block.box(2.0, 0.0, 2.0, 14.0, 12.0, 14.0);
     protected final TreeGrower treeGrower;
     public static org.bukkit.TreeType treeType; // CraftBukkit
+    // DivineMC start - Parallel world ticking
+    public static final ThreadLocal<org.bukkit.TreeType> treeTypeTL = new ThreadLocal<>();
+
+    public static org.bukkit.TreeType getTreeTypeTL() {
+        org.bukkit.TreeType treeTypeRTCopy;
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && (treeTypeRTCopy = treeTypeTL.get()) != null) return treeTypeRTCopy;
+
+        synchronized (SaplingBlock.class) {
+            return treeType;
+        }
+    }
+
+    public static void setTreeTypeTL(org.bukkit.TreeType value) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) treeTypeTL.set(value);
+
+        synchronized (SaplingBlock.class) {
+            treeType = value;
+        }
+    }
+    // DivineMC end - Parallel world ticking
 
     @Override
     public MapCodec<? extends SaplingBlock> codec() {
@@ -63,14 +83,16 @@ public class SaplingBlock extends BushBlock implements BonemealableBlock {
                 this.treeGrower.growTree(level, level.getChunkSource().getGenerator(), pos, state, random);
                 level.captureTreeGeneration = false;
                 if (!level.capturedBlockStates.isEmpty()) {
-                    org.bukkit.TreeType treeType = SaplingBlock.treeType;
-                    SaplingBlock.treeType = null;
+                    // DivineMC start - Parallel world ticking
+                    org.bukkit.TreeType treeTypeLocal = SaplingBlock.getTreeTypeTL();
+                    SaplingBlock.setTreeTypeTL(null);
+                    // DivineMC end - Parallel world ticking
                     org.bukkit.Location location = org.bukkit.craftbukkit.util.CraftLocation.toBukkit(pos, level.getWorld());
                     java.util.List<org.bukkit.block.BlockState> blocks = new java.util.ArrayList<>(level.capturedBlockStates.values());
                     level.capturedBlockStates.clear();
                     org.bukkit.event.world.StructureGrowEvent event = null;
-                    if (treeType != null) {
-                        event = new org.bukkit.event.world.StructureGrowEvent(location, treeType, false, null, blocks);
+                    if (treeTypeLocal != null) { // DivineMC - Parallel world ticking
+                        event = new org.bukkit.event.world.StructureGrowEvent(location, treeTypeLocal, false, null, blocks); // DivineMC - Parallel world ticking
                         org.bukkit.Bukkit.getPluginManager().callEvent(event);
                     }
                     if (event == null || !event.isCancelled()) {
diff --git a/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java b/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
index 26db603ed681a6c302596627d4dd5bf8a9bafc4e..20e8155c0c5f4bd60344c1bbd15f7555ad9ef554 100644
--- a/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
+++ b/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
@@ -77,6 +77,12 @@ public abstract class BaseContainerBlockEntity extends BlockEntity implements Co
         return canUnlock(player, code, displayName, null);
     }
     public static boolean canUnlock(Player player, LockCode code, Component displayName, @Nullable BlockEntity blockEntity) {
+        // DivineMC start - Parallel world ticking
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking && player instanceof net.minecraft.server.level.ServerPlayer serverPlayer && blockEntity != null && blockEntity.getLevel() != serverPlayer.serverLevel()) {
+            net.minecraft.server.MinecraftServer.LOGGER.warn("Player {} ({}) attempted to open a BlockEntity @ {} {}, {}, {} while they were in a different world {} than the block themselves!", serverPlayer.getScoreboardName(), serverPlayer.getStringUUID(), blockEntity.getLevel().getWorld().getName(), blockEntity.getBlockPos().getX(), blockEntity.getBlockPos().getY(), blockEntity.getBlockPos().getZ(), serverPlayer.level().getWorld().getName());
+            return false;
+        }
+        // DivineMC end - Parallel world ticking
         if (player instanceof net.minecraft.server.level.ServerPlayer serverPlayer && blockEntity != null && blockEntity.getLevel() != null && blockEntity.getLevel().getBlockEntity(blockEntity.getBlockPos()) == blockEntity) {
             final org.bukkit.block.Block block = org.bukkit.craftbukkit.block.CraftBlock.at(blockEntity.getLevel(), blockEntity.getBlockPos());
             net.kyori.adventure.text.Component lockedMessage = net.kyori.adventure.text.Component.translatable("container.isLocked", io.papermc.paper.adventure.PaperAdventure.asAdventure(displayName));
diff --git a/net/minecraft/world/level/block/entity/SculkCatalystBlockEntity.java b/net/minecraft/world/level/block/entity/SculkCatalystBlockEntity.java
index 1638eccef431fb68775af624110f1968f0c6dabd..491ac8be8fdaa573fe1b3a234a14110d89b43345 100644
--- a/net/minecraft/world/level/block/entity/SculkCatalystBlockEntity.java
+++ b/net/minecraft/world/level/block/entity/SculkCatalystBlockEntity.java
@@ -43,9 +43,9 @@ public class SculkCatalystBlockEntity extends BlockEntity implements GameEventLi
     // Paper end - Fix NPE in SculkBloomEvent world access
 
     public static void serverTick(Level level, BlockPos pos, BlockState state, SculkCatalystBlockEntity sculkCatalyst) {
-        org.bukkit.craftbukkit.event.CraftEventFactory.sourceBlockOverride = sculkCatalyst.getBlockPos(); // CraftBukkit - SPIGOT-7068: Add source block override, not the most elegant way but better than passing down a BlockPosition up to five methods deep.
+        org.bukkit.craftbukkit.event.CraftEventFactory.setSourceBlockOverrideTL(pos); // DivineMC - Parallel world ticking // CraftBukkit - SPIGOT-7068: Add source block override, not the most elegant way but better than passing down a BlockPosition up to five methods deep.
         sculkCatalyst.catalystListener.getSculkSpreader().updateCursors(level, pos, level.getRandom(), true);
-        org.bukkit.craftbukkit.event.CraftEventFactory.sourceBlockOverride = null; // CraftBukkit
+        org.bukkit.craftbukkit.event.CraftEventFactory.setSourceBlockOverrideTL(null); // DivineMC - Parallel world ticking // CraftBukkit
     }
 
     @Override
diff --git a/net/minecraft/world/level/block/grower/TreeGrower.java b/net/minecraft/world/level/block/grower/TreeGrower.java
index cf7311c507de09a8f89934e430b2201e8bdffe51..e76cb020471f28c29f1b24addb5cd101ddc9630f 100644
--- a/net/minecraft/world/level/block/grower/TreeGrower.java
+++ b/net/minecraft/world/level/block/grower/TreeGrower.java
@@ -204,55 +204,59 @@ public final class TreeGrower {
     // CraftBukkit start
     private void setTreeType(Holder<ConfiguredFeature<?, ?>> holder) {
         ResourceKey<ConfiguredFeature<?, ?>> treeFeature = holder.unwrapKey().get();
+        // DivineMC start - Parallel world ticking
+        org.bukkit.TreeType treeType;
         if (treeFeature == TreeFeatures.OAK || treeFeature == TreeFeatures.OAK_BEES_005) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.TREE;
+            treeType = org.bukkit.TreeType.TREE;
         } else if (treeFeature == TreeFeatures.HUGE_RED_MUSHROOM) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.RED_MUSHROOM;
+            treeType = org.bukkit.TreeType.RED_MUSHROOM;
         } else if (treeFeature == TreeFeatures.HUGE_BROWN_MUSHROOM) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.BROWN_MUSHROOM;
+            treeType = org.bukkit.TreeType.BROWN_MUSHROOM;
         } else if (treeFeature == TreeFeatures.JUNGLE_TREE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.COCOA_TREE;
+            treeType = org.bukkit.TreeType.COCOA_TREE;
         } else if (treeFeature == TreeFeatures.JUNGLE_TREE_NO_VINE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.SMALL_JUNGLE;
+            treeType = org.bukkit.TreeType.SMALL_JUNGLE;
         } else if (treeFeature == TreeFeatures.PINE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.TALL_REDWOOD;
+            treeType = org.bukkit.TreeType.TALL_REDWOOD;
         } else if (treeFeature == TreeFeatures.SPRUCE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.REDWOOD;
+            treeType = org.bukkit.TreeType.REDWOOD;
         } else if (treeFeature == TreeFeatures.ACACIA) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.ACACIA;
+            treeType = org.bukkit.TreeType.ACACIA;
         } else if (treeFeature == TreeFeatures.BIRCH || treeFeature == TreeFeatures.BIRCH_BEES_005) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.BIRCH;
+            treeType = org.bukkit.TreeType.BIRCH;
         } else if (treeFeature == TreeFeatures.SUPER_BIRCH_BEES_0002) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.TALL_BIRCH;
+            treeType = org.bukkit.TreeType.TALL_BIRCH;
         } else if (treeFeature == TreeFeatures.SWAMP_OAK) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.SWAMP;
+            treeType = org.bukkit.TreeType.SWAMP;
         } else if (treeFeature == TreeFeatures.FANCY_OAK || treeFeature == TreeFeatures.FANCY_OAK_BEES_005) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.BIG_TREE;
+            treeType = org.bukkit.TreeType.BIG_TREE;
         } else if (treeFeature == TreeFeatures.JUNGLE_BUSH) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.JUNGLE_BUSH;
+            treeType = org.bukkit.TreeType.JUNGLE_BUSH;
         } else if (treeFeature == TreeFeatures.DARK_OAK) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.DARK_OAK;
+            treeType = org.bukkit.TreeType.DARK_OAK;
         } else if (treeFeature == TreeFeatures.MEGA_SPRUCE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.MEGA_REDWOOD;
+            treeType = org.bukkit.TreeType.MEGA_REDWOOD;
         } else if (treeFeature == TreeFeatures.MEGA_PINE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.MEGA_PINE;
+            treeType = org.bukkit.TreeType.MEGA_PINE;
         } else if (treeFeature == TreeFeatures.MEGA_JUNGLE_TREE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.JUNGLE;
+            treeType = org.bukkit.TreeType.JUNGLE;
         } else if (treeFeature == TreeFeatures.AZALEA_TREE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.AZALEA;
+            treeType = org.bukkit.TreeType.AZALEA;
         } else if (treeFeature == TreeFeatures.MANGROVE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.MANGROVE;
+            treeType = org.bukkit.TreeType.MANGROVE;
         } else if (treeFeature == TreeFeatures.TALL_MANGROVE) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.TALL_MANGROVE;
+            treeType = org.bukkit.TreeType.TALL_MANGROVE;
         } else if (treeFeature == TreeFeatures.CHERRY || treeFeature == TreeFeatures.CHERRY_BEES_005) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.CHERRY;
+            treeType = org.bukkit.TreeType.CHERRY;
         } else if (treeFeature == TreeFeatures.PALE_OAK || treeFeature == TreeFeatures.PALE_OAK_BONEMEAL) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.PALE_OAK;
+            treeType = org.bukkit.TreeType.PALE_OAK;
         } else if (treeFeature == TreeFeatures.PALE_OAK_CREAKING) {
-            net.minecraft.world.level.block.SaplingBlock.treeType = org.bukkit.TreeType.PALE_OAK_CREAKING;
+            treeType = org.bukkit.TreeType.PALE_OAK_CREAKING;
         } else {
             throw new IllegalArgumentException("Unknown tree generator " + treeFeature);
         }
+        net.minecraft.world.level.block.SaplingBlock.setTreeTypeTL(treeType);
+        // DivineMC end - Parallel world ticking
     }
     // CraftBukkit end
 }
diff --git a/net/minecraft/world/level/chunk/LevelChunk.java b/net/minecraft/world/level/chunk/LevelChunk.java
index e3d71604c161373ef44164606602290af1bd1cb0..b245f594ff91e2d29c83f56b9ed5165f37387e7e 100644
--- a/net/minecraft/world/level/chunk/LevelChunk.java
+++ b/net/minecraft/world/level/chunk/LevelChunk.java
@@ -365,6 +365,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
 
     @Nullable
     public BlockState setBlockState(BlockPos pos, BlockState state, boolean isMoving, boolean doPlace) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(this.level, pos, "Updating block asynchronously"); // DivineMC - Parallel world ticking
         // CraftBukkit end
         int y = pos.getY();
         LevelChunkSection section = this.getSection(this.getSectionIndex(y));
diff --git a/net/minecraft/world/level/entity/EntityTickList.java b/net/minecraft/world/level/entity/EntityTickList.java
index c89701d7bdc9b889038d3c52f2232fb17624b113..018a04674897cfcec0e8de5cb2ab06243a994ae3 100644
--- a/net/minecraft/world/level/entity/EntityTickList.java
+++ b/net/minecraft/world/level/entity/EntityTickList.java
@@ -10,17 +10,26 @@ import net.minecraft.world.entity.Entity;
 
 public class EntityTickList {
     public final ca.spottedleaf.moonrise.common.list.IteratorSafeOrderedReferenceSet<net.minecraft.world.entity.Entity> entities = new ca.spottedleaf.moonrise.common.list.IteratorSafeOrderedReferenceSet<>(); // Paper - rewrite chunk system
+    // DivineMC start - Parallel world ticking
+    private final net.minecraft.server.level.ServerLevel serverLevel;
+
+    public EntityTickList(net.minecraft.server.level.ServerLevel serverLevel) {
+        this.serverLevel = serverLevel;
+    }
+    // DivineMC end - Parallel world ticking
 
     private void ensureActiveIsNotIterated() {
         // Paper - rewrite chunk system
     }
 
     public void add(Entity entity) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(entity, "Asynchronous entity ticklist addition"); // Paper // DivineMC - Parallel world ticking
         this.ensureActiveIsNotIterated();
         this.entities.add(entity); // Paper - rewrite chunk system
     }
 
     public void remove(Entity entity) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(entity, "Asynchronous entity ticklist removal"); // Paper // DivineMC - Parallel world ticking
         this.ensureActiveIsNotIterated();
         this.entities.remove(entity); // Paper - rewrite chunk system
     }
@@ -30,6 +39,7 @@ public class EntityTickList {
     }
 
     public void forEach(Consumer<Entity> entity) {
+        if (org.bxteam.divinemc.DivineConfig.enableParallelWorldTicking) ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(serverLevel, "Asynchronous entity ticklist iteration"); // DivineMC - Parallel world ticking
         // Paper start - rewrite chunk system
         // To ensure nothing weird happens with dimension travelling, do not iterate over new entries...
         // (by dfl iterator() is configured to not iterate over new entries)
diff --git a/net/minecraft/world/level/saveddata/maps/MapIndex.java b/net/minecraft/world/level/saveddata/maps/MapIndex.java
index ffe604f8397a002800e6ecc2f878d0f6f1c98703..8f6436d2e87e7e11d98dcf20f4a62a4b3c7f6d92 100644
--- a/net/minecraft/world/level/saveddata/maps/MapIndex.java
+++ b/net/minecraft/world/level/saveddata/maps/MapIndex.java
@@ -34,17 +34,24 @@ public class MapIndex extends SavedData {
 
     @Override
     public CompoundTag save(CompoundTag tag, HolderLookup.Provider registries) {
-        for (Entry<String> entry : this.usedAuxIds.object2IntEntrySet()) {
-            tag.putInt(entry.getKey(), entry.getIntValue());
+        // DivineMC start - make map data thread-safe
+        synchronized (this.usedAuxIds) {
+            for (Entry<String> entry : this.usedAuxIds.object2IntEntrySet()) {
+                tag.putInt(entry.getKey(), entry.getIntValue());
+            }
         }
-
+        // DivineMC end - make map data thread-safe
         return tag;
     }
 
     public MapId getFreeAuxValueForMap() {
-        int i = this.usedAuxIds.getInt("map") + 1;
-        this.usedAuxIds.put("map", i);
-        this.setDirty();
-        return new MapId(i);
+        // DivineMC start - make map data thread-safe
+        synchronized (this.usedAuxIds) {
+            int i = this.usedAuxIds.getInt("map") + 1;
+            this.usedAuxIds.put("map", i);
+            this.setDirty();
+            return new MapId(i);
+        }
+        // DivineMC end - make map data thread-safe
     }
 }