diff --git a/build.gradle.kts b/build.gradle.kts
index a4fd395..227106b 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -17,6 +17,10 @@ repositories {
     maven("https://repo.codemc.org/repository/maven-public")
     maven("https://repo.extendedclip.com/content/repositories/placeholderapi/")
     maven("https://jitpack.io")
+    maven {
+        name = "tcoded-releases"
+        url = uri("https://repo.tcoded.com/releases")
+    }
 }
 
 dependencies {
@@ -31,6 +35,7 @@ dependencies {
     implementation(libs.commons.lang3)
     implementation(libs.nbt.api)
     implementation(libs.holoeasy)
+    implementation("com.tcoded:FoliaLib:0.5.1")
 }
 
 tasks {
@@ -60,6 +65,7 @@ tasks {
         relocate("org.holoeasy", "fr.aerwyn81.libs.holoEasy")
         relocate("org.json", "fr.aerwyn81.libs.json")
         relocate("org.slf4j", "fr.aerwyn81.libs.slf4j")
+        relocate("com.tcoded.folialib", "fr.aerwyn81.headblocks.lib.folialib")
 
         if (project.hasProperty("cd"))
             archiveFileName.set("HeadBlocks.jar")
@@ -68,7 +74,23 @@ tasks {
 
         destinationDirectory.set(file(System.getenv("outputDir") ?: "$rootDir/build/"))
 
-        minimize()
+        // Temporarily disable minimization to ensure FoliaLib and NBT API are included
+        // TODO: Re-enable minimization with proper exclusions once Shadow plugin syntax is confirmed
+        // minimize {
+        //     exclude(dependency("com.tcoded:folialib:.*"))
+        //     exclude(dependency("de.tr7zw:item-nbt-api:.*"))
+        // }
+    }
+
+    register<Copy>("copyJarToTarget") {
+        dependsOn("shadowJar")
+        // Copy the shadowJar output (with all dependencies) from build/ to target folder
+        from(shadowJar.get().archiveFile)
+        into(file("$rootDir/target"))
+    }
+
+    build {
+        dependsOn("copyJarToTarget")
     }
 }
 
@@ -81,6 +103,7 @@ bukkit {
     softDepend = listOf("PlaceholderAPI", "HeadDatabase", "packetevents")
     version = project.version.toString()
     website = "https://just2craft.fr"
+    foliaSupported = true
 
     commands {
         register("headblocks") {
diff --git a/folia_implementation_testing_checklist.md b/folia_implementation_testing_checklist.md
new file mode 100644
index 0000000..4d5d5cb
--- /dev/null
+++ b/folia_implementation_testing_checklist.md
@@ -0,0 +1,263 @@
+## Folia Testing Checklist - HeadBlocks
+
+## Testing Environment
+
+*   **Server Type**: Folia (1.21.8)
+*   **Plugin Version**: 2.8.2 (dev - customized)
+*   **Status**: ⏳ In Progress
+
+## Test Results Legend
+
+*   ✅ **PASSED** - Feature works correctly
+*   ❌ **FAILED** - Feature has errors/issues
+*   ⏸️ **SKIPPED** - Not tested yet
+*   ⚠️ **PARTIAL** - Works but with minor issues
+
+## 1\. Basic Configuration Features
+
+### 1.1 Heads Theme
+
+*   ✅ **headsTheme** - Theme switching works correctly
+    *   Easter theme loads and displays correctly
+    *   Halloween theme loads and displays correctly
+    *   Christmas theme loads and displays correctly
+    *   Custom theme works
+    *   Theme switching doesn't break existing heads
+
+### 1.2 Progress Bar
+
+*   ✅ **progressBar** - Progress bar displays correctly
+    *   Progress bar shows correct completion percentage
+    *   Colors display correctly (completed/not completed)
+    *   Symbol displays correctly
+    *   Works in placeholders (%progress%)
+
+## 2\. Head Click Interactions
+
+### 2.1 Messages
+
+*   ✅ **headClick.messages** - Messages send correctly on head click
+    *   Messages display with correct formatting
+    *   Placeholders work (%player%, %prefix%, %current%, %max%, %progress%, %headName%)
+    *   PlaceholderAPI placeholders work
+    *   Multiple messages display correctly
+
+### 2.2 Title
+
+*   ✅ **headClick.title** - Title displays correctly
+    *   Title enabled/disabled works
+    *   firstLine displays correctly
+    *   subTitle displays correctly
+    *   Fade in/stay/fade out timings work
+    *   Placeholders work in title
+
+### 2.3 Firework
+
+*   ✅ **headClick.firework** - Firework launches correctly
+    *   Firework enabled/disabled works
+    *   Custom colors work
+    *   Random colors work (empty colors array)
+    *   fadeColors work
+    *   flicker setting works
+    *   power setting works
+
+### 2.4 Particles
+
+*   ✅ **headClick.particles** - Particles display correctly
+    *   Particles enabled/disabled works
+    *   Particle type displays correctly (VILLAGER\_ANGRY)
+    *   Particles show for already found heads
+    *   Colors work for REDSTONE type
+
+### 2.5 Sounds
+
+*   ✅ **headClick.sounds** - Sounds play correctly
+    *   alreadyOwn sound plays (block\_note\_block\_didgeridoo)
+    *   notOwn sound plays (block\_note\_block\_bell)
+    *   Sounds play at correct volume/location
+
+### 2.6 Commands
+
+*   ✅ **headClick.commands** - Commands execute correctly
+    *   Commands execute on head click
+    *   Placeholders work in commands (%player%)
+    *   Multiple commands execute
+    *   Commands execute in correct order
+
+### 2.7 Randomize Commands
+
+*   ✅ **headClick.randomizeCommands** - Command randomization works
+    *   When false: commands execute in order
+    *   When true: commands execute randomly
+    *   All commands still execute (no duplicates)
+
+### 2.8 Slots Required
+
+*   ⏸️ **headClick.slotsRequired** - Inventory space check works
+    *   When -1: no check performed
+    *   When set: commands only execute if enough inventory space
+    *   Correct number of slots checked
+
+### 2.9 Push Back
+
+*   ✅ **headClick.pushBack** - Push back works correctly
+    *   Push back enabled/disabled works
+    *   Power setting works correctly
+    *   Only pushes when head is already found
+    *   Push direction is correct
+
+## 3\. Visual Features
+
+### 3.1 Holograms
+
+*   ✅ **holograms** - Holograms display correctly
+    *   DEFAULT plugin mode works (TextDisplay)
+    *   ADVANCED plugin mode works (requires PacketEvents)
+    *   Height above head is correct (0.4)
+    *   Found hologram displays correctly
+    *   Not found hologram displays correctly
+    *   Advanced placeholders work (%state%, %current%, %max%)
+    *   Holograms update when head is found
+    *   Multiple lines display correctly
+
+### 3.2 Floating Particles
+
+*   ✅ **floatingParticles** - Floating particles display correctly
+    *   Not found particles enabled/disabled works
+    *   Found particles enabled/disabled works
+    *   Particle type displays correctly (REDSTONE)
+    *   Colors work correctly (multiple colors)
+    *   Amount setting works
+    *   Particles float above head correctly
+
+### 3.3 Spin
+
+*   ⏸️ **spin** - Head spinning works correctly
+    *   Spin enabled/disabled works
+    *   Speed setting works (20)
+    *   Linked mode works (all heads spin identically)
+    *   Unlinked mode works (heads spin independently)
+    *   Spinning doesn't cause performance issues
+    *   Spinning continues after server restart
+
+## 4\. System Features
+
+### 4.1 Hint System
+
+*   ⏸️ **hint** - Hint system works correctly
+    *   Distance setting works (16 blocks)
+    *   Frequency setting works (20)
+    *   Sound plays correctly (BLOCK\_AMETHYST\_BLOCK\_CHIME)
+    *   Action bar message displays correctly
+    *   Placeholders work (%prefix%, %arrow%, %position%, %distance%)
+    *   Hint only shows when within distance
+
+### 4.2 Internal Task
+
+*   ⏸️ **internalTask** - Internal tasks work correctly
+    *   Delay setting works (20)
+    *   Hologram updates work correctly
+    *   Particle updates work correctly
+    *   Player view distance works (16 blocks)
+    *   Performance is acceptable
+
+### 4.3 Should Reset Player Data
+
+*   ✅ **shouldResetPlayerData** - Data reset works correctly
+    *   When true: player data deleted when head destroyed
+    *   When false: player data remains when head destroyed
+    *   Data reset doesn't affect other heads
+
+### 4.4 Hide Found Heads
+
+*   ⏸️ **hideFoundHeads** - Head hiding works correctly
+    *   Feature enabled/disabled works
+    *   Found heads are hidden visually
+    *   Collision box still exists (forcefield effect)
+    *   Requires PacketEvents (if enabled)
+    *   Requires server restart to apply
+    *   Works correctly on Folia
+
+## 5\. GUI Features
+
+### 5.1 GUI Configuration
+
+*   ✅ **gui** - GUI displays and works correctly
+    *   Border icon displays (GRAY\_STAINED\_GLASS\_PANE)
+    *   Previous icon displays (ARROW)
+    *   Next icon displays (ARROW)
+    *   Back icon displays (SPRUCE\_DOOR)
+    *   Close icon displays (BARRIER)
+    *   All GUI interactions work
+    *   GUI opens/closes correctly
+    *   Navigation works correctly
+
+## 6\. Additional Tests
+
+### 6.1 General Functionality
+
+*   ✅ Plugin loads without errors on Folia
+*   ✅ Plugin enables successfully
+*   ✅ Plugin disables cleanly
+*   ✅ No console errors during normal operation
+*   ✅ No performance issues with multiple heads
+*   ✅ Commands work correctly
+*   ✅ Permissions work correctly
+
+### 6.2 Edge Cases
+
+*   ⏸️ Multiple players interacting with same head
+*   ⏸️ Head in unloaded chunk
+*   ⏸️ Server restart preserves data
+*   ⏸️ Chunk load/unload doesn't break heads
+*   ⏸️ World change doesn't break heads
+
+## Test Results Summary
+
+**Total Features**: 19 main categories  
+**Passed**: 15  
+**Failed**: 0  
+**Skipped**: 4  
+**Partial**: 0
+
+### Passed Features:
+
+*   ✅ 1.1 Heads Theme
+*   ✅ 1.2 Progress Bar
+*   ✅ 2.1 Messages
+*   ✅ 2.2 Title
+*   ✅ 2.3 Firework
+*   ✅ 2.4 Particles
+*   ✅ 2.5 Sounds
+*   ✅ 2.6 Commands
+*   ✅ 2.7 Randomize Commands
+*   ✅ 2.9 Push Back
+*   ✅ 3.1 Holograms
+*   ✅ 3.2 Floating Particles
+*   ✅ 4.3 Should Reset Player Data
+*   ✅ 5.1 GUI Configuration
+*   ✅ 6.1 General Functionality
+
+### Remaining Tests:
+
+*   ⏸️ 2.8 Slots Required
+*   ⏸️ 3.3 Spin
+*   ⏸️ 4.1 Hint System
+*   ⏸️ 4.2 Internal Task
+*   ⏸️ 4.4 Hide Found Heads
+*   ⏸️ 6.2 Edge Cases
+
+## Notes
+
+*   Test on Folia server first
+*   Report any errors immediately
+*   Test features in batches for efficiency
+*   Update status as you test each feature
+
+## Error Log
+
+_Add any errors encountered during testing here:_
+
+```plaintext
+[No errors yet]
+```
\ No newline at end of file
diff --git a/src/main/java/fr/aerwyn81/headblocks/HeadBlocks.java b/src/main/java/fr/aerwyn81/headblocks/HeadBlocks.java
index 833a77e..49c520c 100644
--- a/src/main/java/fr/aerwyn81/headblocks/HeadBlocks.java
+++ b/src/main/java/fr/aerwyn81/headblocks/HeadBlocks.java
@@ -15,6 +15,7 @@
 import fr.aerwyn81.headblocks.utils.config.ConfigUpdater;
 import fr.aerwyn81.headblocks.utils.internal.LogUtil;
 import fr.aerwyn81.headblocks.utils.internal.Metrics;
+import com.tcoded.folialib.FoliaLib;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.holoeasy.HoloEasy;
@@ -37,6 +38,7 @@ public final class HeadBlocks extends JavaPlugin {
     private PacketEventsHook packetEventsHook;
 
     private HoloEasy holoEasyLib;
+    private FoliaLib foliaLib;
 
     @Override
     public void onLoad() {
@@ -72,6 +74,17 @@ public void onLoad() {
     public void onEnable() {
         instance = this;
 
+        // Initialize FoliaLib - required for Folia support
+        // FoliaLib automatically detects platform (Folia/Paper/Spigot) and uses appropriate scheduler
+        try {
+            foliaLib = new FoliaLib(this);
+        } catch (Exception e) {
+            LogUtil.error("CRITICAL: Failed to initialize FoliaLib: {0}", e.getMessage());
+            LogUtil.error("Plugin cannot function without FoliaLib. Disabling...");
+            getPluginLoader().disablePlugin(this);
+            return;
+        }
+
         initializeExternals();
 
         LogUtil.info("HeadBlocks initializing...");
@@ -95,6 +108,19 @@ public void onEnable() {
 
         isPacketEventsActive = Bukkit.getPluginManager().isPluginEnabled("packetevents");
 
+        // Compatibility warnings for external dependencies on Folia
+        if (isPacketEventsActive && foliaLib.isFolia()) {
+            // TODO: Verify PacketEvents Folia compatibility
+            // If issues occur, may need to disable head hiding feature on Folia
+            LogUtil.warning("PacketEvents detected on Folia - head hiding feature may have compatibility issues");
+        }
+
+        if (holoEasyLib != null && foliaLib.isFolia()) {
+            // TODO: Verify HoloEasy Folia compatibility
+            // If issues occur, may need to fallback to DEFAULT hologram type
+            LogUtil.warning("HoloEasy detected on Folia - advanced holograms may have compatibility issues");
+        }
+
         LanguageService.initialize(ConfigService.getLanguage());
         LanguageService.pushMessages();
 
@@ -170,7 +196,11 @@ public void onDisable() {
         HeadService.clearHeadMoves();
         GuiService.clearCache();
 
-        Bukkit.getScheduler().cancelTasks(this);
+        if (foliaLib != null) {
+            foliaLib.getScheduler().cancelAllTasks();
+        } else {
+            Bukkit.getScheduler().cancelTasks(this);
+        }
 
         packetEventsHook.unload();
 
@@ -182,14 +212,9 @@ public void onDisable() {
     }
 
     public void startInternalTaskTimer() {
-        if (this.globalTask != null) {
-            try {
-                this.globalTask.cancel();
-            } catch (IllegalStateException ignored) {
-            } // Not scheduled yet
-            finally {
-                this.globalTask = null;
-            }
+        // Cancel all existing tasks (including previous global task iterations)
+        if (foliaLib != null) {
+            foliaLib.getScheduler().cancelAllTasks();
         }
 
         this.globalTask = new GlobalTask();
@@ -198,7 +223,27 @@ public void startInternalTaskTimer() {
             return;
         }
 
-        globalTask.runTaskTimer(this, 0, ConfigService.getDelayGlobalTask());
+        // Use FoliaLib timer for global iteration, then schedule per-location tasks
+        // This ensures each head's operations run on the correct region thread in Folia
+        foliaLib.getScheduler().runTimer(() -> {
+            if (HeadBlocks.isReloadInProgress)
+                return;
+
+            HeadService.getChargedHeadLocations().forEach(headLocation -> {
+                var location = headLocation.getLocation();
+                if (location.getWorld() == null || 
+                    !location.getWorld().isChunkLoaded(location.getBlockX() >> 4, location.getBlockZ() >> 4)) {
+                    return;
+                }
+
+                // Schedule region-aware task for each location
+                // On Folia: runs on the region thread for that location
+                // On Paper/Spigot: runs on main thread (same behavior as before)
+                foliaLib.getScheduler().runAtLocation(location, task -> {
+                    GlobalTask.handleHeadLocation(headLocation);
+                });
+            });
+        }, 0, ConfigService.getDelayGlobalTask());
     }
 
     public static HeadBlocks getInstance() {
@@ -220,4 +265,8 @@ public HoloEasy getHoloEasyLib() {
     public PacketEventsHook getPacketEventsHook() {
         return packetEventsHook;
     }
+
+    public FoliaLib getFoliaLib() {
+        return foliaLib;
+    }
 }
diff --git a/src/main/java/fr/aerwyn81/headblocks/commands/list/Debug.java b/src/main/java/fr/aerwyn81/headblocks/commands/list/Debug.java
index 0192daa..ddce488 100644
--- a/src/main/java/fr/aerwyn81/headblocks/commands/list/Debug.java
+++ b/src/main/java/fr/aerwyn81/headblocks/commands/list/Debug.java
@@ -58,22 +58,28 @@ public boolean perform(CommandSender sender, String[] args) {
                     return true;
                 }
 
-                var applied = HeadUtils.applyTextureToBlock(blockLocation.getBlock(), args[2]);
-
-                if (applied) {
-                    try {
-                        StorageService.createOrUpdateHead(headLoc.getUuid(), args[2]);
-                    } catch (InternalException e) {
-                        LogUtil.error("Error with storage, head new texture not saved: {0}", e.getMessage());
-                        applied = false;
+                // Block operations need location-aware scheduling
+                // Note: On Folia, this will be async, so the result check happens after scheduling
+                var applied = new boolean[]{false};
+                HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(blockLocation, task -> {
+                    applied[0] = HeadUtils.applyTextureToBlock(blockLocation.getBlock(), args[2]);
+                    
+                    // Send result message from the region thread
+                    if (applied[0]) {
+                        try {
+                            StorageService.createOrUpdateHead(headLoc.getUuid(), args[2]);
+                            sender.sendMessage(MessageUtils.colorize(LanguageService.getPrefix() + " &aTexture applied!"));
+                        } catch (InternalException e) {
+                            LogUtil.error("Error with storage, head new texture not saved: {0}", e.getMessage());
+                            sender.sendMessage(MessageUtils.colorize(LanguageService.getPrefix() + " &cError trying to apply the texture, check logs."));
+                        }
+                    } else {
+                        sender.sendMessage(MessageUtils.colorize(LanguageService.getPrefix() + " &cError trying to apply the texture, check logs."));
                     }
-                }
-
-                if (applied) {
-                    sender.sendMessage(MessageUtils.colorize(LanguageService.getPrefix() + " &aTexture applied!"));
-                } else {
-                    sender.sendMessage(MessageUtils.colorize(LanguageService.getPrefix() + " &cError trying to apply the texture, check logs."));
-                }
+                });
+                
+                // On Paper/Spigot, operation happens immediately, so we can return
+                // On Folia, operation is scheduled and message is sent from within the callback above
                 return true;
             }
             case "give" -> {
diff --git a/src/main/java/fr/aerwyn81/headblocks/commands/list/Export.java b/src/main/java/fr/aerwyn81/headblocks/commands/list/Export.java
index f4d992d..57a88bb 100644
--- a/src/main/java/fr/aerwyn81/headblocks/commands/list/Export.java
+++ b/src/main/java/fr/aerwyn81/headblocks/commands/list/Export.java
@@ -38,16 +38,20 @@ public boolean perform(CommandSender sender, String[] args) {
 
         sender.sendMessage(MessageUtils.colorize(LanguageService.getMessage("Messages.ExportInProgress")));
 
-        Bukkit.getScheduler().runTaskAsynchronously(HeadBlocks.getInstance(), () -> {
+        HeadBlocks.getInstance().getFoliaLib().getScheduler().runAsync(task -> {
             try {
                 ExportSQLHelper.generateFile(typeDatabase, fileName);
                 Thread.sleep(10000);
             } catch (Exception ex) {
-                sender.sendMessage(MessageUtils.colorize(LanguageService.getMessage("Messages.ExportError") + ex.getMessage()));
+                HeadBlocks.getInstance().getFoliaLib().getScheduler().runNextTick(t -> {
+                    sender.sendMessage(MessageUtils.colorize(LanguageService.getMessage("Messages.ExportError") + ex.getMessage()));
+                });
             }
 
-            sender.sendMessage(MessageUtils.colorize(LanguageService.getMessage("Messages.ExportSuccess"))
-                    .replaceAll("%fileName%", fileName));
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runNextTick(t -> {
+                sender.sendMessage(MessageUtils.colorize(LanguageService.getMessage("Messages.ExportSuccess"))
+                        .replaceAll("%fileName%", fileName));
+            });
         });
 
         return true;
diff --git a/src/main/java/fr/aerwyn81/headblocks/commands/list/Tp.java b/src/main/java/fr/aerwyn81/headblocks/commands/list/Tp.java
index 066c593..f6c6537 100644
--- a/src/main/java/fr/aerwyn81/headblocks/commands/list/Tp.java
+++ b/src/main/java/fr/aerwyn81/headblocks/commands/list/Tp.java
@@ -1,5 +1,6 @@
 package fr.aerwyn81.headblocks.commands.list;
 
+import fr.aerwyn81.headblocks.HeadBlocks;
 import fr.aerwyn81.headblocks.commands.Cmd;
 import fr.aerwyn81.headblocks.commands.HBAnnotations;
 import org.bukkit.Bukkit;
@@ -25,7 +26,16 @@ public boolean perform(CommandSender sender, String[] args) {
                     Float.parseFloat(args[5]),
                     Float.parseFloat(args[6]));
 
-            player.teleport(loc);
+            // Use FoliaLib's async teleport for cross-platform compatibility
+            // On Folia: teleports asynchronously
+            // On Paper: teleports asynchronously (if supported)
+            // On Spigot: falls back to next tick teleport
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().teleportAsync(player, loc, null)
+                    .thenAccept(success -> {
+                        if (!success) {
+                            player.sendMessage("Teleportation failed!");
+                        }
+                    });
         } catch (Exception ignored) {
         }
 
diff --git a/src/main/java/fr/aerwyn81/headblocks/data/reward/Reward.java b/src/main/java/fr/aerwyn81/headblocks/data/reward/Reward.java
index de708cf..2223d5e 100644
--- a/src/main/java/fr/aerwyn81/headblocks/data/reward/Reward.java
+++ b/src/main/java/fr/aerwyn81/headblocks/data/reward/Reward.java
@@ -72,9 +72,12 @@ public void execute(Player player, HeadLocation headLocation) {
         var value = parsedValue;
         switch (type) {
             case MESSAGE -> player.sendMessage(parsedValue);
-            case COMMAND -> Bukkit.getScheduler().runTaskLater(plugin, () ->
+            case COMMAND -> plugin.getFoliaLib().getScheduler().runLater(task ->
                     plugin.getServer().dispatchCommand(plugin.getServer().getConsoleSender(), value), 1L);
             case BROADCAST -> plugin.getServer().broadcastMessage(parsedValue);
+            case UNKNOWN -> {
+                // Unknown reward type - do nothing
+            }
         }
     }
 }
diff --git a/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerChatEvent.java b/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerChatEvent.java
index c53c327..ab2fb7d 100644
--- a/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerChatEvent.java
+++ b/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerChatEvent.java
@@ -17,9 +17,10 @@ public void onPlayerChat(AsyncPlayerChatEvent event) {
         if (GuiService.getRewardsManager().hasPendingRewardInput(player)) {
             event.setCancelled(true);
 
-            player.getServer().getScheduler().runTask(HeadBlocks.getInstance(),
-                    () -> GuiService.getRewardsManager().processPendingRewardInput(player, event.getMessage())
-            );
+            // Use entity-aware scheduling for player operations
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtEntity(player, task -> {
+                GuiService.getRewardsManager().processPendingRewardInput(player, event.getMessage());
+            });
         }
     }
 }
diff --git a/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerInteractEvent.java b/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerInteractEvent.java
index 8830e7b..e8085d5 100644
--- a/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerInteractEvent.java
+++ b/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerInteractEvent.java
@@ -81,147 +81,154 @@ public void onPlayerInteract(PlayerInteractEvent e) {
         StorageService.getHeadsPlayer(player.getUniqueId()).whenComplete(p -> {
             var playerHeads = new ArrayList<>(p);
 
-            if (playerHeads.contains(headLocation.getUuid())) {
-                String message = PlaceholdersService.parse(player.getName(), player.getUniqueId(), headLocation, LanguageService.getMessage("Messages.AlreadyClaimHead"));
+            // Use entity-aware scheduling for player operations
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtEntity(player, task -> {
+                if (playerHeads.contains(headLocation.getUuid())) {
+                    String message = PlaceholdersService.parse(player.getName(), player.getUniqueId(), headLocation, LanguageService.getMessage("Messages.AlreadyClaimHead"));
 
-                if (!message.trim().isEmpty()) {
-                    player.sendMessage(message);
-                }
+                    if (!message.trim().isEmpty()) {
+                        player.sendMessage(message);
+                    }
 
-                if (ConfigService.isHeadClickEjectEnabled()) {
-                    var power = ConfigService.getHeadClickEjectPower();
+                    if (ConfigService.isHeadClickEjectEnabled()) {
+                        var power = ConfigService.getHeadClickEjectPower();
 
-                    var oppositeDir = player.getLocation().getDirection().multiply(-1).normalize();
-                    oppositeDir = oppositeDir.multiply(power).setY(0.3);
-                    player.setVelocity(oppositeDir);
-                }
+                        var oppositeDir = player.getLocation().getDirection().multiply(-1).normalize();
+                        oppositeDir = oppositeDir.multiply(power).setY(0.3);
+                        player.setVelocity(oppositeDir);
+                    }
 
-                // Already own song if not empty
-                String songName = ConfigService.getHeadClickAlreadyOwnSound();
-                if (!songName.trim().isEmpty()) {
-                    try {
-                        XSound.play(ConfigService.getHeadClickAlreadyOwnSound(), s -> s.forPlayers(player));
-                    } catch (Exception ex) {
-                        player.sendMessage(LanguageService.getMessage("Messages.ErrorCannotPlaySound"));
-                        LogUtil.error("Error cannot play sound on head click: {0}", ex.getMessage());
+                    // Already own song if not empty
+                    String songName = ConfigService.getHeadClickAlreadyOwnSound();
+                    if (!songName.trim().isEmpty()) {
+                        try {
+                            XSound.play(ConfigService.getHeadClickAlreadyOwnSound(), s -> s.forPlayers(player));
+                        } catch (Exception ex) {
+                            player.sendMessage(LanguageService.getMessage("Messages.ErrorCannotPlaySound"));
+                            LogUtil.error("Error cannot play sound on head click: {0}", ex.getMessage());
+                        }
+                    }
+
+                    // Already own particles if enabled - need location-aware scheduling
+                    if (ConfigService.isHeadClickParticlesEnabled()) {
+                        String particleName = ConfigService.getHeadClickParticlesAlreadyOwnType();
+                        int amount = ConfigService.getHeadClickParticlesAmount();
+                        ArrayList<String> colors = ConfigService.getHeadClickParticlesColors();
+
+                        try {
+                            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(clickedLocation, task2 -> {
+                                ParticlesUtils.spawn(clickedLocation, Particle.valueOf(particleName), amount, colors, player);
+                            });
+                        } catch (Exception ex) {
+                            LogUtil.error("Error particle name {0} cannot be parsed!", particleName);
+                        }
                     }
+
+                    // Trigger the event HeadClick with no success because the player already own the head
+                    Bukkit.getPluginManager().callEvent(new HeadClickEvent(headLocation.getUuid(), player, clickedLocation, false));
+                    return;
                 }
 
-                // Already own particles if enabled
-                if (ConfigService.isHeadClickParticlesEnabled()) {
-                    String particleName = ConfigService.getHeadClickParticlesAlreadyOwnType();
-                    int amount = ConfigService.getHeadClickParticlesAmount();
-                    ArrayList<String> colors = ConfigService.getHeadClickParticlesColors();
+                // Check head order
+                if (headLocation.getOrderIndex() != -1) {
+                    if (HeadService.getChargedHeadLocations().stream()
+                            .filter(h -> h.getUuid() != headLocation.getUuid() && !playerHeads.contains(h.getUuid()))
+                            .anyMatch(h -> h.getOrderIndex() <= headLocation.getOrderIndex())) {
+                        player.sendMessage(PlaceholdersService.parse(player.getName(), player.getUniqueId(), headLocation,
+                                LanguageService.getMessage("Messages.OrderClickError")
+                                        .replaceAll("%name%", headLocation.getNameOrUnnamed())));
+                        return;
+                    }
+                }
 
+                // Check hit count
+                if (headLocation.getHitCount() != -1) {
                     try {
-                        ParticlesUtils.spawn(clickedLocation, Particle.valueOf(particleName), amount, colors, player);
-                    } catch (Exception ex) {
-                        LogUtil.error("Error particle name {0} cannot be parsed!", particleName);
+                        var players = StorageService.getPlayers(headLocation.getUuid());
+
+                        if (players.size() == headLocation.getHitCount()) {
+                            player.sendMessage(LanguageService.getMessage("Messages.HitClickMax")
+                                    .replaceAll("%count%", headLocation.getDisplayedHitCount()));
+                            return;
+                        }
+                    } catch (InternalException ex) {
+                        LogUtil.error("Error retrieving players from storage when calculating hit count: {0}", ex.getMessage());
+                        return;
                     }
                 }
 
-                // Trigger the event HeadClick with no success because the player already own the head
-                Bukkit.getPluginManager().callEvent(new HeadClickEvent(headLocation.getUuid(), player, clickedLocation, false));
-                return;
-            }
+                playerHeads.add(headLocation.getUuid());
+
+                if (!RewardService.hasPlayerSlotsRequired(player, playerHeads)) {
+                    var message = LanguageService.getMessage("Messages.InventoryFullReward");
+                    if (!message.trim().isEmpty()) {
+                        player.sendMessage(message);
+                    }
 
-            // Check head order
-            if (headLocation.getOrderIndex() != -1) {
-                if (HeadService.getChargedHeadLocations().stream()
-                        .filter(h -> h.getUuid() != headLocation.getUuid() && !playerHeads.contains(h.getUuid()))
-                        .anyMatch(h -> h.getOrderIndex() <= headLocation.getOrderIndex())) {
-                    player.sendMessage(PlaceholdersService.parse(player.getName(), player.getUniqueId(), headLocation,
-                            LanguageService.getMessage("Messages.OrderClickError")
-                                    .replaceAll("%name%", headLocation.getNameOrUnnamed())));
                     return;
                 }
-            }
 
-            // Check hit count
-            if (headLocation.getHitCount() != -1) {
+                // Save player click in storage
                 try {
-                    var players = StorageService.getPlayers(headLocation.getUuid());
-
-                    if (players.size() == headLocation.getHitCount()) {
-                        player.sendMessage(LanguageService.getMessage("Messages.HitClickMax")
-                                .replaceAll("%count%", headLocation.getDisplayedHitCount()));
-                        return;
-                    }
+                    StorageService.addHead(player.getUniqueId(), headLocation.getUuid());
                 } catch (InternalException ex) {
-                    LogUtil.error("Error retrieving players from storage when calculating hit count: {0}", ex.getMessage());
+                    LogUtil.error("Error saving player found head in storage: {0}", ex.getMessage());
                     return;
                 }
-            }
-
-            playerHeads.add(headLocation.getUuid());
 
-            if (!RewardService.hasPlayerSlotsRequired(player, playerHeads)) {
-                var message = LanguageService.getMessage("Messages.InventoryFullReward");
-                if (!message.trim().isEmpty()) {
-                    player.sendMessage(message);
+                // Hide the head for this player if enabled
+                var packetEventsHook = HeadBlocks.getInstance().getPacketEventsHook();
+                if (packetEventsHook != null && packetEventsHook.isEnabled() && packetEventsHook.getHeadHidingListener() != null) {
+                    packetEventsHook.getHeadHidingListener().addFoundHead(player, headLocation.getUuid());
                 }
 
-                return;
-            }
-
-            // Save player click in storage
-            try {
-                StorageService.addHead(player.getUniqueId(), headLocation.getUuid());
-            } catch (InternalException ex) {
-                LogUtil.error("Error saving player found head in storage: {0}", ex.getMessage());
-                return;
-            }
+                // Give reward if triggerRewards is used
+                RewardService.giveReward(player, playerHeads, headLocation);
 
-            // Hide the head for this player if enabled
-            var packetEventsHook = HeadBlocks.getInstance().getPacketEventsHook();
-            if (packetEventsHook != null && packetEventsHook.isEnabled() && packetEventsHook.getHeadHidingListener() != null) {
-                packetEventsHook.getHeadHidingListener().addFoundHead(player, headLocation.getUuid());
-            }
-
-            // Give reward if triggerRewards is used
-            RewardService.giveReward(player, playerHeads, headLocation);
-
-            // Give special head rewards
-            for (var reward : headLocation.getRewards()) {
-                reward.execute(player, headLocation);
-            }
+                // Give special head rewards
+                for (var reward : headLocation.getRewards()) {
+                    reward.execute(player, headLocation);
+                }
 
-            // Success song if not empty
-            String songName = ConfigService.getHeadClickNotOwnSound();
-            if (!songName.trim().isEmpty()) {
-                try {
-                    XSound.play(songName, s -> s.forPlayers(player));
-                } catch (Exception ex) {
-                    LogUtil.error("Error cannot play sound on head click! Cannot parse provided name...");
+                // Success song if not empty
+                String songName = ConfigService.getHeadClickNotOwnSound();
+                if (!songName.trim().isEmpty()) {
+                    try {
+                        XSound.play(songName, s -> s.forPlayers(player));
+                    } catch (Exception ex) {
+                        LogUtil.error("Error cannot play sound on head click! Cannot parse provided name...");
+                    }
                 }
-            }
 
-            // Send title to the player if enabled
-            if (ConfigService.isHeadClickTitleEnabled()) {
-                String firstLine = PlaceholdersService.parse(player.getName(), player.getUniqueId(), headLocation, ConfigService.getHeadClickTitleFirstLine());
-                String subTitle = PlaceholdersService.parse(player.getName(), player.getUniqueId(), headLocation, ConfigService.getHeadClickTitleSubTitle());
-                int fadeIn = ConfigService.getHeadClickTitleFadeIn();
-                int stay = ConfigService.getHeadClickTitleStay();
-                int fadeOut = ConfigService.getHeadClickTitleFadeOut();
+                // Send title to the player if enabled
+                if (ConfigService.isHeadClickTitleEnabled()) {
+                    String firstLine = PlaceholdersService.parse(player.getName(), player.getUniqueId(), headLocation, ConfigService.getHeadClickTitleFirstLine());
+                    String subTitle = PlaceholdersService.parse(player.getName(), player.getUniqueId(), headLocation, ConfigService.getHeadClickTitleSubTitle());
+                    int fadeIn = ConfigService.getHeadClickTitleFadeIn();
+                    int stay = ConfigService.getHeadClickTitleStay();
+                    int fadeOut = ConfigService.getHeadClickTitleFadeOut();
 
-                player.sendTitle(firstLine, subTitle, fadeIn, stay, fadeOut);
-            }
+                    player.sendTitle(firstLine, subTitle, fadeIn, stay, fadeOut);
+                }
 
-            // Fire firework if enabled
-            if (ConfigService.isFireworkEnabled()) {
-                List<Color> colors = ConfigService.getHeadClickFireworkColors();
-                List<Color> fadeColors = ConfigService.getHeadClickFireworkFadeColors();
-                boolean isFlickering = ConfigService.isFireworkFlickerEnabled();
-                int power = ConfigService.getHeadClickFireworkPower();
+                // Fire firework if enabled - need location-aware scheduling
+                if (ConfigService.isFireworkEnabled()) {
+                    List<Color> colors = ConfigService.getHeadClickFireworkColors();
+                    List<Color> fadeColors = ConfigService.getHeadClickFireworkFadeColors();
+                    boolean isFlickering = ConfigService.isFireworkFlickerEnabled();
+                    int power = ConfigService.getHeadClickFireworkPower();
 
-                Location loc = power == 0 ? clickedLocation.clone() : clickedLocation.clone().add(0, 0.5, 0);
+                    Location loc = power == 0 ? clickedLocation.clone() : clickedLocation.clone().add(0, 0.5, 0);
 
-                FireworkUtils.launchFirework(loc, isFlickering,
-                        colors.isEmpty(), colors, fadeColors.isEmpty(), fadeColors, power, block.getType() == Material.PLAYER_WALL_HEAD);
-            }
+                    HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(loc, task2 -> {
+                        FireworkUtils.launchFirework(loc, isFlickering,
+                                colors.isEmpty(), colors, fadeColors.isEmpty(), fadeColors, power, block.getType() == Material.PLAYER_WALL_HEAD);
+                    });
+                }
 
-            // Trigger the event HeadClick with success
-            Bukkit.getPluginManager().callEvent(new HeadClickEvent(headLocation.getUuid(), player, clickedLocation, true));
+                // Trigger the event HeadClick with success
+                Bukkit.getPluginManager().callEvent(new HeadClickEvent(headLocation.getUuid(), player, clickedLocation, true));
+            });
         });
     }
 }
diff --git a/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerPlaceBlockEvent.java b/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerPlaceBlockEvent.java
index 6a4dd3e..3273f6d 100644
--- a/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerPlaceBlockEvent.java
+++ b/src/main/java/fr/aerwyn81/headblocks/events/OnPlayerPlaceBlockEvent.java
@@ -54,8 +54,7 @@ public void onPlayerPlaceBlock(BlockPlaceEvent e) {
             return;
         }
 
-        Location headLocation = headBlock.getLocation();
-        headLocation = headLocation.clone().add(0.5, 0, 0.5);
+        final Location headLocation = headBlock.getLocation().clone().add(0.5, 0, 0.5);
 
         if (HeadService.getHeadAt(headLocation) != null) {
             e.setCancelled(true);
@@ -86,11 +85,14 @@ public void onPlayerPlaceBlock(BlockPlaceEvent e) {
             return;
         }
 
-        if (VersionUtils.isNewerOrEqualsTo(VersionUtils.v1_20_R5)) {
-            ParticlesUtils.spawn(headLocation, Particle.valueOf("HAPPY_VILLAGER"), 10, null, player);
-        } else {
-            ParticlesUtils.spawn(headLocation, Particle.VILLAGER_HAPPY, 10, null, player);
-        }
+        // Particles need location-aware scheduling
+        HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(headLocation, task -> {
+            if (VersionUtils.isNewerOrEqualsTo(VersionUtils.v1_20_R5)) {
+                ParticlesUtils.spawn(headLocation, Particle.valueOf("HAPPY_VILLAGER"), 10, null, player);
+            } else {
+                ParticlesUtils.spawn(headLocation, Particle.VILLAGER_HAPPY, 10, null, player);
+            }
+        });
 
         player.sendMessage(LocationUtils.parseLocationPlaceholders(LanguageService.getMessage("Messages.HeadPlaced"), headLocation));
 
diff --git a/src/main/java/fr/aerwyn81/headblocks/holograms/types/AdvancedHologram.java b/src/main/java/fr/aerwyn81/headblocks/holograms/types/AdvancedHologram.java
index cb725f6..892a0c0 100644
--- a/src/main/java/fr/aerwyn81/headblocks/holograms/types/AdvancedHologram.java
+++ b/src/main/java/fr/aerwyn81/headblocks/holograms/types/AdvancedHologram.java
@@ -30,19 +30,27 @@ public void hide(Player player) {
 
     @Override
     public void delete() {
-        Bukkit.getScheduler().runTaskAsynchronously(HeadBlocks.getInstance(), () -> {
-            var pool = getPool();
-            if (pool != null) {
-                hologram.hide(getPool());
-            }
-        });
+        // Holograms are location-based, use location-aware scheduling
+        // Note: HoloEasy operations may need to be on region thread
+        // TODO: Verify HoloEasy Folia compatibility - if issues occur, may need adjustments
+        var location = hologram != null ? hologram.getLocation() : null;
+        if (location != null) {
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(location, task -> {
+                var pool = getPool();
+                if (pool != null) {
+                    hologram.hide(getPool());
+                }
+            });
+        }
     }
 
     @Override
     public IHologram create(String name, Location location, List<String> lines) {
         hologram = new Hologram(HeadBlocks.getInstance().getHoloEasyLib(), location);
 
-        Bukkit.getScheduler().runTaskAsynchronously(HeadBlocks.getInstance(), () -> {
+        // Holograms are location-based, use location-aware scheduling
+        // TODO: Verify HoloEasy Folia compatibility - if issues occur, may need adjustments
+        HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(location, task -> {
             ConfigService.getHologramsAdvancedLines().forEach(l -> hologram.getLines().add(
                     new DisplayTextLine(hologram, player ->
                     {
@@ -81,11 +89,15 @@ public boolean isVisible(Player player) {
     }
 
     public void refresh(Player player) {
-        Bukkit.getScheduler().runTaskAsynchronously(HeadBlocks.getInstance(), () -> {
-            for (Line<?> line : hologram.getLines()) {
-                line.update(player);
-            }
-        });
+        // Holograms are location-based, use location-aware scheduling
+        var location = hologram != null ? hologram.getLocation() : null;
+        if (location != null) {
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(location, task -> {
+                for (Line<?> line : hologram.getLines()) {
+                    line.update(player);
+                }
+            });
+        }
     }
 
     private IHologramPool<Hologram> getPool() {
diff --git a/src/main/java/fr/aerwyn81/headblocks/holograms/types/BasicHologram.java b/src/main/java/fr/aerwyn81/headblocks/holograms/types/BasicHologram.java
index bf37dc3..6c23e1e 100644
--- a/src/main/java/fr/aerwyn81/headblocks/holograms/types/BasicHologram.java
+++ b/src/main/java/fr/aerwyn81/headblocks/holograms/types/BasicHologram.java
@@ -18,16 +18,25 @@ public class BasicHologram implements IHologram {
 
     @Override
     public void show(Player player) {
+        if (hologram == null || !hologram.isValid()) {
+            return;
+        }
         player.showEntity(plugin, hologram);
     }
 
     @Override
     public void hide(Player player) {
+        if (hologram == null || !hologram.isValid()) {
+            return;
+        }
         player.hideEntity(plugin, hologram);
     }
 
     @Override
     public void delete() {
+        if (hologram == null || !hologram.isValid()) {
+            return;
+        }
         hologram.remove();
     }
 
@@ -39,11 +48,14 @@ public IHologram create(String name, Location location, List<String> lines) {
             return this;
         }
 
-        hologram = world.spawn(location, TextDisplay.class, entity -> {
-            lines.forEach(l -> entity.setText(MessageUtils.colorize(l)));
-            entity.setVisibleByDefault(false);
-            entity.setPersistent(false);
-            entity.setBillboard(Display.Billboard.CENTER);
+        // Entity spawning must be location-aware
+        HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(location, task -> {
+            hologram = world.spawn(location, TextDisplay.class, entity -> {
+                lines.forEach(l -> entity.setText(MessageUtils.colorize(l)));
+                entity.setVisibleByDefault(false);
+                entity.setPersistent(false);
+                entity.setBillboard(Display.Billboard.CENTER);
+            });
         });
 
         return this;
@@ -51,6 +63,9 @@ public IHologram create(String name, Location location, List<String> lines) {
 
     @Override
     public boolean isVisible(Player player) {
+        if (hologram == null || !hologram.isValid()) {
+            return false;
+        }
         return player.canSee(hologram);
     }
 
diff --git a/src/main/java/fr/aerwyn81/headblocks/hooks/HeadHidingPacketListener.java b/src/main/java/fr/aerwyn81/headblocks/hooks/HeadHidingPacketListener.java
index 36472b2..3666795 100644
--- a/src/main/java/fr/aerwyn81/headblocks/hooks/HeadHidingPacketListener.java
+++ b/src/main/java/fr/aerwyn81/headblocks/hooks/HeadHidingPacketListener.java
@@ -92,14 +92,20 @@ public void onPlayerJoin(Player player) {
             if (foundHeads != null) {
                 playerFoundHeadsCache.put(player.getUniqueId(), foundHeads);
 
-                Bukkit.getScheduler().runTaskLater(HeadBlocks.getInstance(), () -> {
-                    for (var headUuid : foundHeads) {
-                        var headLocation = HeadService.getHeadByUUID(headUuid);
-                        if (headLocation != null && player.getWorld().equals(headLocation.getLocation().getWorld())) {
-                            player.sendBlockChange(headLocation.getLocation(),
-                                    org.bukkit.Material.STRUCTURE_VOID.createBlockData());
+                // Use entity-aware scheduling for player operations
+                HeadBlocks.getInstance().getFoliaLib().getScheduler().runLater(task -> {
+                    HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtEntity(player, task2 -> {
+                        for (var headUuid : foundHeads) {
+                            var headLocation = HeadService.getHeadByUUID(headUuid);
+                            if (headLocation != null && player.getWorld().equals(headLocation.getLocation().getWorld())) {
+                                // Block change operations need location-aware scheduling
+                                var loc = headLocation.getLocation();
+                                HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(loc, task3 -> {
+                                    player.sendBlockChange(loc, org.bukkit.Material.STRUCTURE_VOID.createBlockData());
+                                });
+                            }
                         }
-                    }
+                    });
                 }, 20L);
             }
         });
@@ -120,8 +126,13 @@ public void addFoundHead(Player player, UUID headUuid) {
 
         var headLocation = HeadService.getHeadByUUID(headUuid);
         if (headLocation != null && player.getWorld().equals(headLocation.getLocation().getWorld())) {
-            player.sendBlockChange(headLocation.getLocation(),
-                    org.bukkit.Material.STRUCTURE_VOID.createBlockData());
+            // Use entity + location-aware scheduling
+            var loc = headLocation.getLocation();
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtEntity(player, task -> {
+                HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(loc, task2 -> {
+                    player.sendBlockChange(loc, org.bukkit.Material.STRUCTURE_VOID.createBlockData());
+                });
+            });
         }
     }
 
@@ -135,13 +146,18 @@ public void removeFoundHead(Player player, UUID headUuid) {
         if (headLocation != null && player.getWorld().equals(headLocation.getLocation().getWorld())) {
             var location = headLocation.getLocation();
 
-            Bukkit.getScheduler().runTaskLater(HeadBlocks.getInstance(), () -> {
-                player.sendBlockChange(location, location.getBlock().getBlockData());
-                var world = location.getWorld();
-                if (world != null) {
-                    var blockState = location.getBlock().getState();
-                    blockState.update(true, false);
-                }
+            // Use entity + location-aware scheduling
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runLater(task -> {
+                HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtEntity(player, task2 -> {
+                    HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(location, task3 -> {
+                        player.sendBlockChange(location, location.getBlock().getBlockData());
+                        var world = location.getWorld();
+                        if (world != null) {
+                            var blockState = location.getBlock().getState();
+                            blockState.update(true, false);
+                        }
+                    });
+                });
             }, 1L);
         }
     }
@@ -156,19 +172,24 @@ public void showAllPreviousHeads(Player player) {
         playerFoundHeadsCache.remove(player.getUniqueId());
 
         if (previouslyHiddenHeads != null && !previouslyHiddenHeads.isEmpty()) {
-            Bukkit.getScheduler().runTaskLater(HeadBlocks.getInstance(), () -> {
-                for (var headUuid : previouslyHiddenHeads) {
-                    var headLocation = HeadService.getHeadByUUID(headUuid);
-                    if (headLocation != null && player.getWorld().equals(headLocation.getLocation().getWorld())) {
-                        var location = headLocation.getLocation();
-                        player.sendBlockChange(location, location.getBlock().getBlockData());
-                        var world = location.getWorld();
-                        if (world != null) {
-                            var blockState = location.getBlock().getState();
-                            blockState.update(true, false);
+            // Use entity + location-aware scheduling
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runLater(task -> {
+                HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtEntity(player, task2 -> {
+                    for (var headUuid : previouslyHiddenHeads) {
+                        var headLocation = HeadService.getHeadByUUID(headUuid);
+                        if (headLocation != null && player.getWorld().equals(headLocation.getLocation().getWorld())) {
+                            var location = headLocation.getLocation();
+                            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(location, task3 -> {
+                                player.sendBlockChange(location, location.getBlock().getBlockData());
+                                var world = location.getWorld();
+                                if (world != null) {
+                                    var blockState = location.getBlock().getState();
+                                    blockState.update(true, false);
+                                }
+                            });
                         }
                     }
-                }
+                });
             }, 1L);
         }
     }
diff --git a/src/main/java/fr/aerwyn81/headblocks/runnables/GlobalTask.java b/src/main/java/fr/aerwyn81/headblocks/runnables/GlobalTask.java
index c171710..457e979 100644
--- a/src/main/java/fr/aerwyn81/headblocks/runnables/GlobalTask.java
+++ b/src/main/java/fr/aerwyn81/headblocks/runnables/GlobalTask.java
@@ -12,12 +12,11 @@
 import org.bukkit.Location;
 import org.bukkit.Particle;
 import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitRunnable;
 
 import java.util.Collections;
 import java.util.Random;
 
-public class GlobalTask extends BukkitRunnable {
+public class GlobalTask {
 
     private static final int CHUNK_SIZE = 16;
     private static int VIEW_RADIUS_CHUNKS = 1;
@@ -28,25 +27,25 @@ public GlobalTask() {
         VIEW_RADIUS_CHUNKS = (int) Math.ceil(ConfigService.getHologramParticlePlayerViewDistance() / (double) CHUNK_SIZE);
     }
 
-    @Override
-    public void run() {
+    /**
+     * Handle a single head location - called from region-aware context
+     */
+    public static void handleHeadLocation(HeadLocation headLocation) {
         if (HeadBlocks.isReloadInProgress)
             return;
 
-        HeadService.getChargedHeadLocations().forEach(headLocation -> {
-            var location = headLocation.getLocation();
-            if (location.getWorld() == null || !location.getWorld().isChunkLoaded(location.getBlockX() >> 4, location.getBlockZ() >> 4))
-                return;
+        var location = headLocation.getLocation();
+        if (location.getWorld() == null || !location.getWorld().isChunkLoaded(location.getBlockX() >> 4, location.getBlockZ() >> 4))
+            return;
 
-            if (ConfigService.isSpinEnabled() && ConfigService.isSpinLinked()) {
-                HeadService.rotateHead(headLocation);
-            }
+        if (ConfigService.isSpinEnabled() && ConfigService.isSpinLinked()) {
+            HeadService.rotateHead(headLocation);
+        }
 
-            handleHologramAndParticles(headLocation);
-        });
+        handleHologramAndParticles(headLocation);
     }
 
-    private void spawnParticles(Location location, boolean isFound, Player player) {
+    private static void spawnParticles(Location location, boolean isFound, Player player) {
         if (isFound && ConfigService.hideFoundHeads())
             return;
 
@@ -67,11 +66,11 @@ private void spawnParticles(Location location, boolean isFound, Player player) {
         } catch (Exception ex) {
             LogUtil.error("Cannot spawn particle {0}... {1}", particle.name(), ex.getMessage());
             LogUtil.error("To prevent log spamming, particles is disabled until reload");
-            this.cancel();
+            // Note: Task cancellation is now handled by HeadBlocks.startInternalTaskTimer()
         }
     }
 
-    private void handleHologramAndParticles(HeadLocation headLocation) {
+    private static void handleHologramAndParticles(HeadLocation headLocation) {
         int rangeParticles = ConfigService.getHologramParticlePlayerViewDistance();
         int rangeHint = ConfigService.getHintDistanceBlocks();
 
@@ -141,7 +140,7 @@ private void handleHologramAndParticles(HeadLocation headLocation) {
                         }
                     } catch (InternalException ex) {
                         LogUtil.error("Error while trying to communicate with the storage : {0}", ex.getMessage());
-                        this.cancel();
+                        // Note: Task cancellation is now handled by HeadBlocks.startInternalTaskTimer()
                     }
                     continue;
                 }
@@ -151,7 +150,7 @@ private void handleHologramAndParticles(HeadLocation headLocation) {
         }
     }
 
-    private String getHintDirectionArrow(Location playerLoc, Location targetLoc) {
+    private static String getHintDirectionArrow(Location playerLoc, Location targetLoc) {
         if (playerLoc.distance(targetLoc) < 1.5) {
             return "●";
         }
diff --git a/src/main/java/fr/aerwyn81/headblocks/services/HeadService.java b/src/main/java/fr/aerwyn81/headblocks/services/HeadService.java
index c93436f..fda3995 100644
--- a/src/main/java/fr/aerwyn81/headblocks/services/HeadService.java
+++ b/src/main/java/fr/aerwyn81/headblocks/services/HeadService.java
@@ -25,7 +25,6 @@
 import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.inventory.meta.SkullMeta;
 import org.bukkit.persistence.PersistentDataType;
-import org.bukkit.scheduler.BukkitTask;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
@@ -33,7 +32,9 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
 public class HeadService {
@@ -44,7 +45,9 @@ public class HeadService {
     private static HashMap<UUID, HeadMove> headMoves;
     private static ArrayList<HeadLocation> headLocations;
 
-    private static HashMap<UUID, BukkitTask> tasksHeadSpin;
+    // Track which heads should be spinning (Set-based for FoliaLib compatibility)
+    // Tasks check this set before executing - if head is removed, task becomes no-op
+    private static Set<UUID> activeSpinningHeads;
 
     public static String HB_KEY = "HB_HEAD";
 
@@ -54,7 +57,7 @@ public static void initialize(File file) {
         heads = new ArrayList<>();
         headLocations = new ArrayList<>();
         headMoves = new HashMap<>();
-        tasksHeadSpin = new HashMap<>();
+        activeSpinningHeads = ConcurrentHashMap.newKeySet();
 
         load();
     }
@@ -65,7 +68,8 @@ public static void load() {
         heads.clear();
         headLocations.clear();
         headMoves.clear();
-        tasksHeadSpin.values().forEach(BukkitTask::cancel);
+        activeSpinningHeads.clear();
+        // Cancel all tasks (including spinning tasks) - handled by HeadBlocks.onDisable()
 
         loadHeads();
         loadLocations();
@@ -162,9 +166,24 @@ private static void addHeadToSpin(HeadLocation headLoc, int offset) {
             return;
         }
 
-        var task = Bukkit.getScheduler().runTaskTimer(HeadBlocks.getInstance(),
-                () -> rotateHead(headLoc), 5L * offset, ConfigService.getSpinSpeed());
-        tasksHeadSpin.put(headLoc.getUuid(), task);
+        // Track this head as actively spinning
+        activeSpinningHeads.add(headLoc.getUuid());
+
+        // Schedule spinning task with FoliaLib
+        // On Folia: runs on the region thread for that location
+        // On Paper/Spigot: runs on main thread
+        Location loc = headLoc.getLocation();
+        HeadBlocks.getInstance().getFoliaLib().getScheduler().runTimer(() -> {
+            // Check if this head should still spin (very fast O(1) lookup)
+            if (!activeSpinningHeads.contains(headLoc.getUuid())) {
+                return; // Task keeps running but does nothing (minimal overhead)
+            }
+
+            // Only execute if head is still active - schedule on region thread
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(loc, task -> {
+                rotateHead(headLoc);
+            });
+        }, 5L * offset, ConfigService.getSpinSpeed());
     }
 
     public static UUID saveHeadLocation(Location location, String texture) throws InternalException {
@@ -202,7 +221,14 @@ public static void removeHeadLocation(HeadLocation headLocation, boolean withDel
         if (headLocation != null) {
             StorageService.removeHead(headLocation.getUuid(), withDelete);
 
-            headLocation.getLocation().getBlock().setType(Material.AIR);
+            // Remove from spinning set - task will naturally stop executing
+            activeSpinningHeads.remove(headLocation.getUuid());
+
+            // Block operations must be region-aware
+            Location loc = headLocation.getLocation();
+            HeadBlocks.getInstance().getFoliaLib().getScheduler().runAtLocation(loc, task -> {
+                loc.getBlock().setType(Material.AIR);
+            });
 
             if (ConfigService.isHologramsEnabled()) {
                 HologramService.removeHolograms(headLocation.getLocation());
@@ -214,11 +240,6 @@ public static void removeHeadLocation(HeadLocation headLocation, boolean withDel
             saveConfig();
 
             headMoves.entrySet().removeIf(hM -> headLocation.getUuid().equals(hM.getKey()));
-            var spinTask = tasksHeadSpin.get(headLocation.getUuid());
-            if (spinTask != null) {
-                spinTask.cancel();
-                tasksHeadSpin.remove(headLocation.getUuid());
-            }
         }
     }
 
@@ -362,42 +383,57 @@ public static HeadLocation resolveHeadIdentifier(String headIdentifier) {
     }
 
     public static void changeHeadLocation(UUID hUuid, @NotNull Block oldBlock, Block newBlock) {
+        // Capture block states before scheduling (must be done on current thread)
         Skull oldSkull = (Skull) oldBlock.getState();
         Rotatable skullRotation = (Rotatable) oldSkull.getBlockData();
+        var oldOwnerProfile = oldSkull.getOwnerProfile();
+        var oldNbtTileEntity = new NBTTileEntity(oldSkull);
+
+        Location newLoc = newBlock.getLocation();
+        Location oldLoc = oldBlock.getLocation();
+        HeadBlocks plugin = HeadBlocks.getInstance();
+
+        // All block operations must be region-aware
+        // Schedule new block operations first
+        plugin.getFoliaLib().getScheduler().runAtLocation(newLoc, task -> {
+            newBlock.setType(Material.PLAYER_HEAD);
+
+            Skull newSkull = (Skull) newBlock.getState();
+
+            Rotatable rotatable = (Rotatable) newSkull.getBlockData();
+            rotatable.setRotation(skullRotation.getRotation());
+            newSkull.setBlockData(rotatable);
+
+            if (VersionUtils.isNewerOrEqualsTo(VersionUtils.v1_20_R5)) {
+                NBT.modify(newSkull, nbt -> {
+                    nbt.mergeCompound(oldNbtTileEntity);
+                });
+            } else {
+                new NBTTileEntity(newSkull).mergeCompound(oldNbtTileEntity);
+            }
+            newSkull.setOwnerProfile(oldOwnerProfile);
 
-        newBlock.setType(Material.PLAYER_HEAD);
-
-        Skull newSkull = (Skull) newBlock.getState();
-
-        Rotatable rotatable = (Rotatable) newSkull.getBlockData();
-        rotatable.setRotation(skullRotation.getRotation());
-        newSkull.setBlockData(rotatable);
-
-        if (VersionUtils.isNewerOrEqualsTo(VersionUtils.v1_20_R5)) {
-            NBT.modify(newSkull, nbt -> {
-                nbt.mergeCompound(new NBTTileEntity(oldSkull));
-            });
-        } else {
-            new NBTTileEntity(newSkull).mergeCompound(new NBTTileEntity(oldSkull));
-        }
-        newSkull.setOwnerProfile(oldSkull.getOwnerProfile());
-
-        newSkull.update(true);
+            newSkull.update(true);
 
-        oldBlock.setType(Material.AIR);
+            // Update head location data (non-block operations, safe to do here)
+            var headLocation = getHeadByUUID(hUuid);
+            var indexOfOld = headLocations.indexOf(headLocation);
 
-        var headLocation = getHeadByUUID(hUuid);
-        var indexOfOld = headLocations.indexOf(headLocation);
+            headLocation.setLocation(newBlock.getLocation());
+            saveHeadInConfig(headLocation);
 
-        headLocation.setLocation(newBlock.getLocation());
-        saveHeadInConfig(headLocation);
+            headLocations.set(indexOfOld, headLocation);
 
-        headLocations.set(indexOfOld, headLocation);
+            HologramService.removeHolograms(oldBlock.getLocation());
+            HologramService.createHolograms(newBlock.getLocation());
 
-        HologramService.removeHolograms(oldBlock.getLocation());
-        HologramService.createHolograms(newBlock.getLocation());
+            addHeadToSpin(headLocation, 1);
+        });
 
-        addHeadToSpin(headLocation, 1);
+        // Then schedule old block removal on its region
+        plugin.getFoliaLib().getScheduler().runAtLocation(oldLoc, task -> {
+            oldBlock.setType(Material.AIR);
+        });
     }
 
     public static void rotateHead(HeadLocation headLocation) {
diff --git a/src/main/java/fr/aerwyn81/headblocks/services/RewardService.java b/src/main/java/fr/aerwyn81/headblocks/services/RewardService.java
index 89578e4..861b317 100644
--- a/src/main/java/fr/aerwyn81/headblocks/services/RewardService.java
+++ b/src/main/java/fr/aerwyn81/headblocks/services/RewardService.java
@@ -28,10 +28,10 @@ public static void giveReward(Player p, List<UUID> playerHeads, HeadLocation hea
                     p.sendMessage(PlaceholdersService.parse(p, headLocation, messages));
                 }
 
-                Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                plugin.getFoliaLib().getScheduler().runLater(task -> {
                     if (tieredReward.isRandom()) {
                         String randomCommand = tieredReward.getCommands().get(new Random().nextInt(tieredReward.getCommands().size()));
-                        Bukkit.getScheduler().runTaskLater(plugin, () ->
+                        plugin.getFoliaLib().getScheduler().runLater(task2 ->
                                 plugin.getServer().dispatchCommand(plugin.getServer().getConsoleSender(), PlaceholdersService.parse(p.getName(), p.getUniqueId(), headLocation, randomCommand)), 1L);
                     } else {
                         List<String> commands = tieredReward.getCommands();
@@ -68,10 +68,10 @@ public static void giveReward(Player p, List<UUID> playerHeads, HeadLocation hea
 
         if (isRandomCommand) {
             String randomCommand = ConfigService.getHeadClickCommands().get(new Random().nextInt(ConfigService.getHeadClickCommands().size()));
-            Bukkit.getScheduler().runTaskLater(plugin, () ->
+            plugin.getFoliaLib().getScheduler().runLater(task ->
                     plugin.getServer().dispatchCommand(plugin.getServer().getConsoleSender(), PlaceholdersService.parse(p.getName(), p.getUniqueId(), headLocation, randomCommand)), 1L);
         } else {
-            Bukkit.getScheduler().runTaskLater(plugin, () -> ConfigService.getHeadClickCommands().forEach(reward ->
+            plugin.getFoliaLib().getScheduler().runLater(task -> ConfigService.getHeadClickCommands().forEach(reward ->
                     plugin.getServer().dispatchCommand(plugin.getServer().getConsoleSender(), PlaceholdersService.parse(p.getName(), p.getUniqueId(), headLocation, reward))), 1L);
         }
     }
diff --git a/src/main/java/fr/aerwyn81/headblocks/utils/bukkit/FireworkUtils.java b/src/main/java/fr/aerwyn81/headblocks/utils/bukkit/FireworkUtils.java
index a55ce1b..cc81e06 100644
--- a/src/main/java/fr/aerwyn81/headblocks/utils/bukkit/FireworkUtils.java
+++ b/src/main/java/fr/aerwyn81/headblocks/utils/bukkit/FireworkUtils.java
@@ -12,6 +12,20 @@
 
 public class FireworkUtils {
 
+    /**
+     * Launch a firework at a location.
+     * IMPORTANT: This method must be called from a region-aware context (e.g., from runAtLocation).
+     * Entity spawning must be on the region thread, not asynchronously.
+     * 
+     * @param loc Location to launch firework at
+     * @param isFlickering Whether the firework should flicker
+     * @param isColorsRandom Whether to use random colors
+     * @param colors List of colors (if not random)
+     * @param isFadeColorsRandom Whether to use random fade colors
+     * @param fadeColors List of fade colors (if not random)
+     * @param power Firework power
+     * @param isWalled Whether this is a wall head
+     */
     public static void launchFirework(Location loc, boolean isFlickering, boolean isColorsRandom, List<Color> colors, boolean isFadeColorsRandom, List<Color> fadeColors, int power, boolean isWalled) {
         if (loc.getWorld() == null) {
             return;
diff --git a/src/main/java/fr/aerwyn81/headblocks/utils/bukkit/ParticlesUtils.java b/src/main/java/fr/aerwyn81/headblocks/utils/bukkit/ParticlesUtils.java
index 5ec1f6a..02fc9c5 100644
--- a/src/main/java/fr/aerwyn81/headblocks/utils/bukkit/ParticlesUtils.java
+++ b/src/main/java/fr/aerwyn81/headblocks/utils/bukkit/ParticlesUtils.java
@@ -1,7 +1,6 @@
 package fr.aerwyn81.headblocks.utils.bukkit;
 
 import fr.aerwyn81.headblocks.HeadBlocks;
-import org.bukkit.Bukkit;
 import org.bukkit.Color;
 import org.bukkit.Location;
 import org.bukkit.Particle;
@@ -11,6 +10,17 @@
 
 public class ParticlesUtils {
 
+    /**
+     * Spawn particles at a location for a player.
+     * IMPORTANT: This method must be called from a region-aware context (e.g., from runAtLocation).
+     * Particles must be spawned on the region thread, not asynchronously.
+     * 
+     * @param loc Location to spawn particles at
+     * @param particle Particle type
+     * @param amount Amount of particles
+     * @param colors Colors for REDSTONE particles (can be null)
+     * @param player Player to show particles to
+     */
     public static void spawn(Location loc, Particle particle, int amount, ArrayList<String> colors, Player player) {
         double size = amount == 1 ? 0 : .25f;
         Location location = loc.clone().add(0, .75f, 0);
@@ -33,17 +43,13 @@ public static void spawn(Location loc, Particle particle, int amount, ArrayList<
             }
         }
 
-        Bukkit.getScheduler().runTaskAsynchronously(HeadBlocks.getInstance(), () -> {
-            if (!dustOptions.isEmpty()) {
-                Bukkit.getScheduler().runTaskAsynchronously(HeadBlocks.getInstance(), () -> {
-                    dustOptions.forEach(dustOpt ->
-                            player.spawnParticle(particle, location, amount, size, size, size, dustOpt));
-                });
-
-                return;
-            }
-
+        // Particles must be spawned on the region thread (not async)
+        // Caller should ensure this is called from runAtLocation context
+        if (!dustOptions.isEmpty()) {
+            dustOptions.forEach(dustOpt ->
+                    player.spawnParticle(particle, location, amount, size, size, size, dustOpt));
+        } else {
             player.spawnParticle(particle, location, amount, size, size, size, 0);
-        });
+        }
     }
 }
diff --git a/src/main/java/fr/aerwyn81/headblocks/utils/internal/Metrics.java b/src/main/java/fr/aerwyn81/headblocks/utils/internal/Metrics.java
index 517db12..f7ac243 100644
--- a/src/main/java/fr/aerwyn81/headblocks/utils/internal/Metrics.java
+++ b/src/main/java/fr/aerwyn81/headblocks/utils/internal/Metrics.java
@@ -103,9 +103,15 @@ public Metrics(Plugin plugin, int serviceId) {
                         enabled,
                         this::appendPlatformData,
                         this::appendServiceData,
-                        isFolia
-                                ? null
-                                : submitDataTask -> Bukkit.getScheduler().runTask(plugin, submitDataTask),
+                        // Use FoliaLib scheduler for cross-platform compatibility
+                        submitDataTask -> {
+                            if (plugin instanceof fr.aerwyn81.headblocks.HeadBlocks headBlocks) {
+                                headBlocks.getFoliaLib().getScheduler().runNextTick(task -> submitDataTask.run());
+                            } else {
+                                // Fallback for non-HeadBlocks plugins (shouldn't happen)
+                                Bukkit.getScheduler().runTask(plugin, submitDataTask);
+                            }
+                        },
                         plugin::isEnabled,
                         (message, error) -> this.plugin.getLogger().log(Level.WARNING, message, error),
                         (message) -> this.plugin.getLogger().log(Level.INFO, message),
diff --git a/src/main/java/fr/aerwyn81/headblocks/utils/runnables/BukkitFutureResult.java b/src/main/java/fr/aerwyn81/headblocks/utils/runnables/BukkitFutureResult.java
index 8126513..01b8aba 100644
--- a/src/main/java/fr/aerwyn81/headblocks/utils/runnables/BukkitFutureResult.java
+++ b/src/main/java/fr/aerwyn81/headblocks/utils/runnables/BukkitFutureResult.java
@@ -1,5 +1,6 @@
 package fr.aerwyn81.headblocks.utils.runnables;
 
+import fr.aerwyn81.headblocks.HeadBlocks;
 import org.bukkit.plugin.Plugin;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -32,7 +33,15 @@ public void whenComplete(@NotNull Consumer<? super T> callback, Consumer<Throwab
     }
 
     public void whenComplete(@NotNull Plugin plugin, @NotNull Consumer<? super T> callback, Consumer<Throwable> throwableConsumer) {
-        var executor = (Executor) r -> plugin.getServer().getScheduler().runTask(plugin, r);
+        // Use FoliaLib scheduler for cross-platform compatibility (Folia/Paper/Spigot)
+        var executor = (Executor) r -> {
+            if (plugin instanceof HeadBlocks headBlocks) {
+                headBlocks.getFoliaLib().getScheduler().runNextTick(task -> r.run());
+            } else {
+                // Fallback for non-HeadBlocks plugins (shouldn't happen, but safety)
+                plugin.getServer().getScheduler().runTask(plugin, r);
+            }
+        };
         this.future.thenAcceptAsync(callback, executor).exceptionally(throwable -> {
             throwableConsumer.accept(throwable);
             return null;