diff --git a/.gitignore b/.gitignore
index 1292ca1e6..7971d3fb2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,12 @@ build
 # other
 eclipse
 run
+runs/
+.worktrees/
+resume.txt
+.agents
+.codex
+
 
 # Files from Forge MDK
 forge*changelog.txt
diff --git a/README.md b/README.md
new file mode 100644
index 000000000..961485507
--- /dev/null
+++ b/README.md
@@ -0,0 +1,7 @@
+# Passive Skill Tree
+
+Passive skill tree mod for Minecraft.
+
+This repository is a fork port made by marneilx to update Passive Skill Tree to Minecraft 1.21.1 on NeoForge.
+
+Original mod page: https://www.curseforge.com/minecraft/mc-mods/passive-skill-tree
diff --git a/build.gradle b/build.gradle
index b405f2838..b5231f262 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,159 +1,94 @@
 plugins {
+    id 'java-library'
+    id 'maven-publish'
     id 'eclipse'
     id 'idea'
-    id 'maven-publish'
-    id 'net.minecraftforge.gradle' version '[6.0,6.2)'
-    id 'org.spongepowered.mixin' version '0.7-SNAPSHOT'
-    id 'org.parchmentmc.librarian.forgegradle' version '1.+'
+    id 'net.neoforged.gradle.userdev' version '7.1.26'
 }
 
 version = mod_version
 group = mod_group_id
 
 base {
-    archivesName = "${mod_file_name}"
+    archivesName = mod_file_name
 }
 
-java.toolchain.languageVersion = JavaLanguageVersion.of(17)
-
-println "Java: ${System.getProperty 'java.version'}, JVM: ${System.getProperty 'java.vm.version'} (${System.getProperty 'java.vendor'}), Arch: ${System.getProperty 'os.arch'}"
-minecraft {
-    mappings channel: mapping_channel, version: mapping_version
-
-    copyIdeResources = true
-
-    runs {
-        client {
-            workingDirectory project.file('run')
-
-            arg "-mixin.config=${mod_id}.mixins.json"
-
-            property 'forge.logging.markers', 'REGISTRIES'
-            property 'forge.logging.console.level', 'debug'
-            property 'forge.enabledGameTestNamespaces', mod_id
-
-			property 'mixin.env.remapRefMap', 'true'
-			property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg"
-
-            mods {
-                "${mod_id}" {
-                    source sourceSets.main
-                }
-            }
-        }
-
-        server {
-            workingDirectory project.file('run')
-
-            arg "-mixin.config=${mod_id}.mixins.json"
-
-            property 'forge.logging.markers', 'REGISTRIES'
-            property 'forge.logging.console.level', 'debug'
-            property 'forge.enabledGameTestNamespaces', mod_id
-
-			property 'mixin.env.remapRefMap', 'true'
-			property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg"
-
-            mods {
-                "${mod_id}" {
-                    source sourceSets.main
-                }
-            }
-
-
-        }
-
-        gameTestServer {
-            workingDirectory project.file('run')
-
-            property 'forge.logging.markers', 'REGISTRIES'
-            property 'forge.logging.console.level', 'debug'
-            property 'forge.enabledGameTestNamespaces', mod_id
-
-            mods {
-                "${mod_id}" {
-                    source sourceSets.main
-                }
-            }
+repositories {
+    maven {
+        url "https://www.cursemaven.com"
+        content {
+            includeGroup "curse.maven"
         }
+    }
+    mavenCentral()
+}
 
-        data {
-            workingDirectory project.file('run')
+tasks.named('wrapper', Wrapper).configure {
+    distributionType = Wrapper.DistributionType.BIN
+}
 
-            arg "-mixin.config=${mod_id}.mixins.json"
+java.toolchain.languageVersion = JavaLanguageVersion.of(21)
 
-            property 'forge.logging.markers', 'REGISTRIES'
-            property 'forge.logging.console.level', 'debug'
+sourceSets.main.resources {
+    srcDir('src/generated/resources')
+}
 
-            args '--mod', mod_id, '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
+println "Java: ${System.getProperty 'java.version'}, JVM: ${System.getProperty 'java.vm.version'} (${System.getProperty 'java.vendor'}), Arch: ${System.getProperty 'os.arch'}"
 
-            mods {
-                "${mod_id}" {
-                    source sourceSets.main
-                }
-            }
-        }
+runs {
+    configureEach {
+        workingDirectory project.layout.projectDirectory.dir('runs').dir(name)
+        modSource project.sourceSets.main
     }
-}
 
-sourceSets.main.resources { srcDir 'src/generated/resources' }
-
-repositories {
-    maven {
-        url "https://www.cursemaven.com"
-        content {
-            includeGroup "curse.maven"
-        }
+    data {
+        arguments.addAll '--mod', mod_id, '--all',
+                '--output', file('src/generated/resources/').absolutePath,
+                '--existing', file('src/main/resources/').absolutePath
     }
 }
 
-dependencies {
-    minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"
-    // mixin
-    annotationProcessor 'org.spongepowered:mixin:0.8.4:processor'
-    implementation(annotationProcessor("io.github.llamalad7:mixinextras-common:0.3.2"))
-    implementation(jarJar("io.github.llamalad7:mixinextras-forge:0.3.2")) {
-        jarJar.ranged(it, "[0.3.2,)")
-    }
-    // curios
-    implementation fg.deobf("curse.maven:curios-309927:6418456")
-    // attribute fix
-	implementation fg.deobf("curse.maven:attributefix-280510:4648448")
-    // max health fix
-	implementation fg.deobf("curse.maven:max-health-fix-492246:4648479")
-    // dummy target
-	implementation fg.deobf("curse.maven:mmmmmmmmmmmm-225738:4602101")
-	implementation fg.deobf("curse.maven:selene-499980:4656567")
-    // jei
-	implementation fg.deobf("curse.maven:jei-238222:4644453")
-    // apple skin
-	implementation fg.deobf("curse.maven:appleskin-248787:4605078")
-    // apotheosis
-    implementation fg.deobf("curse.maven:placebo-283644:5414631")
-    implementation fg.deobf("curse.maven:apothic-attributes-898963:5529789")
-    // spells and spellbooks
-    implementation fg.deobf("curse.maven:irons-spells-n-spellbooks-855414:7605614")
-    implementation fg.deobf("curse.maven:geckolib-388172:7553267")
-    implementation fg.deobf("curse.maven:playeranimator-658587:4587214")
+configurations {
+    runtimeClasspath.extendsFrom localRuntime
 }
 
-mixin {
-    add sourceSets.main, "${mod_id}.refmap.json"
+dependencies {
+    implementation "net.neoforged:neoforge:${neo_version}"
+    compileOnly "org.spongepowered:mixin:0.8.5"
+    annotationProcessor "org.spongepowered:mixin:0.8.5:processor"
+    compileOnly "io.github.llamalad7:mixinextras-common:0.5.3"
+    implementation "curse.maven:curios-309927:6529130"
+    implementation "curse.maven:attributefix-280510:7115922"
+    implementation "curse.maven:max-health-fix-492246:5824111"
+    runtimeOnly "curse.maven:bookshelf-228525:7606240"
+    runtimeOnly "curse.maven:prickle-1023259:6961457"
+    implementation "curse.maven:selene-499980:8065893"
+    implementation "curse.maven:jei-238222:7416540"
+    implementation "curse.maven:appleskin-248787:7854442"
+    implementation "curse.maven:placebo-283644:6926281"
+    implementation "curse.maven:apothic-attributes-898963:7445079"
+    implementation "curse.maven:irons-spells-n-spellbooks-855414:7907341"
+    runtimeOnly "curse.maven:irons-lib-1492763:7907336"
+    implementation "curse.maven:geckolib-388172:7707149"
+    implementation "curse.maven:playeranimator-658587:6024462"
 }
 
-def resourceTargets = ['META-INF/mods.toml', 'pack.mcmeta']
-def replaceProperties = [
-        minecraft_version: minecraft_version, minecraft_version_range: minecraft_version_range,
-        forge_version: forge_version, forge_version_range: forge_version_range,
+tasks.withType(ProcessResources).configureEach {
+    def replaceProperties = [
+        minecraft_version: minecraft_version,
+        minecraft_version_range: minecraft_version_range,
+        neo_version: neo_version,
         loader_version_range: loader_version_range,
-        mod_id: mod_id, mod_name: mod_name, mod_license: mod_license, mod_version: mod_version,
-        mod_authors: mod_authors, mod_description: mod_description
-]
-processResources {
+        mod_id: mod_id,
+        mod_name: mod_name,
+        mod_license: mod_license,
+        mod_version: mod_version,
+        mod_authors: mod_authors,
+        mod_description: mod_description
+    ]
     inputs.properties replaceProperties
-    replaceProperties.put 'project', project
 
-    filesMatching(resourceTargets) {
+    filesMatching(['META-INF/neoforge.mods.toml', 'pack.mcmeta']) {
         expand replaceProperties
     }
 }
@@ -167,14 +102,11 @@ jar {
                 "Implementation-Title"    : project.name,
                 "Implementation-Version"  : project.jar.archiveVersion,
                 "Implementation-Vendor"   : mod_authors,
-                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
-                "MixinConfigs"            : "${mod_id}.mixins.json"
+                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
         ])
     }
 }
 
-jar.finalizedBy('reobfJar')
-
 tasks.withType(JavaCompile).configureEach {
     options.encoding = 'UTF-8'
 }
diff --git a/docs/superpowers/plans/2026-05-15-passive-skill-tree-neoforge-1211-port.md b/docs/superpowers/plans/2026-05-15-passive-skill-tree-neoforge-1211-port.md
new file mode 100644
index 000000000..3a027f07a
--- /dev/null
+++ b/docs/superpowers/plans/2026-05-15-passive-skill-tree-neoforge-1211-port.md
@@ -0,0 +1,515 @@
+# Passive Skill Tree NeoForge 1.21.1 Port Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:subagent-driven-development` (recommended) or `superpowers:executing-plans` to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Port Passive Skill Tree from Minecraft 1.20.1 Forge to Minecraft 1.21.1 NeoForge with full feature parity.
+
+**Architecture:** Treat this as a staged platform migration, not a rewrite. First move the build onto the NeoForge 1.21.1 toolchain, then swap Forge persistence/networking/runtime hooks for NeoForge equivalents, then fix the vanilla 1.21.1 API breaks, and finally refresh compat and generated data so the runtime behavior matches the old mod.
+
+**Tech Stack:** Java 21, NeoForge 1.21.1, NeoGradle / Gradle 9.2.1, Sponge Mixin, NeoForge data attachments, NeoForge payload networking, JUnit 5 for regression tests, Curse Maven dependencies.
+
+---
+
+### Task 1: Move the project onto the NeoForge 1.21.1 toolchain
+
+**Files:**
+- Modify `build.gradle`
+- Modify `settings.gradle`
+- Modify `gradle.properties`
+- Modify `gradle/wrapper/gradle-wrapper.properties`
+- Create `src/main/resources/META-INF/neoforge.mods.toml`
+- Delete `src/main/resources/META-INF/mods.toml`
+- Modify `src/main/resources/pack.mcmeta`
+
+- [ ] **Step 1: Replace the Forge build bootstrap with the NeoForge MDK shape**
+
+```gradle
+plugins {
+    id 'java-library'
+    id 'maven-publish'
+    id 'net.neoforged.gradle.userdev' version '7.1.27'
+    id 'org.spongepowered.mixin' version '0.7-SNAPSHOT'
+}
+
+java.toolchain.languageVersion = JavaLanguageVersion.of(21)
+
+dependencies {
+    implementation "net.neoforged:neoforge:${neo_version}"
+}
+```
+
+Set `minecraft_version=1.21.1`, `neo_version=21.1.229`, and `mod_file_name=PassiveSkillTree-1.21.1-BETA` in `gradle.properties`. Update `settings.gradle` to use `maven.neoforged.net/releases`, and update the wrapper to Gradle `9.2.1`.
+
+- [ ] **Step 2: Replace `mods.toml` with NeoForge metadata**
+
+```toml
+modLoader="javafml"
+loaderVersion="${loader_version_range}"
+license="${mod_license}"
+
+[[mods]]
+modId="${mod_id}"
+version="${mod_version}"
+displayName="${mod_name}"
+authors="${mod_authors}"
+description='''${mod_description}'''
+
+[[dependencies.${mod_id}]]
+modId="neoforge"
+mandatory=true
+versionRange="[${neo_version},)"
+ordering="NONE"
+side="BOTH"
+```
+
+Keep the existing required `minecraft` and `attributefix` dependency blocks, and keep `curios` optional.
+
+- [ ] **Step 3: Update the resource pack metadata**
+
+```json
+{
+  "pack": {
+    "description": { "text": "${mod_id} resources" },
+    "pack_format": 34
+  }
+}
+```
+
+Keep the same description expansion, just change the 1.20.1 pack format to the 1.21.1 value.
+
+- [ ] **Step 4: Run the build once to prove the failure moved from the toolchain into source-level API errors**
+
+Run: `bash gradlew compileJava`
+
+Expected: the wrapper and dependency resolution should work; any failure should now be actual source migration errors, not the Java 26 / Gradle 8.1.1 cache failure seen before.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add build.gradle settings.gradle gradle.properties gradle/wrapper/gradle-wrapper.properties src/main/resources/META-INF/neoforge.mods.toml src/main/resources/pack.mcmeta src/main/resources/META-INF/mods.toml
+git commit -m "build: bootstrap NeoForge 1.21.1"
+```
+
+### Task 2: Lock down player-skill persistence with a small regression test
+
+**Files:**
+- Modify `build.gradle`
+- Create `src/main/java/daripher/skilltree/capability/skill/PlayerSkillsCodec.java`
+- Modify `src/main/java/daripher/skilltree/capability/skill/PlayerSkills.java`
+- Create `src/test/java/daripher/skilltree/capability/skill/PlayerSkillsCodecTest.java`
+
+- [ ] **Step 1: Add the failing test first**
+
+```java
+package daripher.skilltree.capability.skill;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.UUID;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.StringTag;
+import org.junit.jupiter.api.Test;
+
+class PlayerSkillsCodecTest {
+  @Test
+  void staleTreeVersion_refundsOnePointPerStoredSkill_andMarksReset() {
+    CompoundTag tag = new CompoundTag();
+    tag.putUUID("TreeVersion", UUID.fromString("00000000-0000-0000-0000-000000000000"));
+    tag.putInt("Points", 3);
+    ListTag skills = new ListTag();
+    skills.add(StringTag.valueOf("skilltree:hunter_1"));
+    skills.add(StringTag.valueOf("skilltree:hunter_2"));
+    tag.put("Skills", skills);
+
+    PlayerSkills state = new PlayerSkills();
+    PlayerSkillsCodec.read(state, tag);
+
+    assertEquals(5, state.getSkillPoints());
+    assertTrue(state.isTreeReset());
+    assertTrue(state.getPlayerSkills().isEmpty());
+  }
+}
+```
+
+- [ ] **Step 2: Run the test and watch it fail for the right reason**
+
+Run: `bash gradlew test --tests daripher.skilltree.capability.skill.PlayerSkillsCodecTest -v`
+
+Expected: the test should fail because `PlayerSkillsCodec` does not exist yet, or because the codec methods are not wired yet. Do not accept a green run here.
+
+- [ ] **Step 3: Extract the pure persistence logic into `PlayerSkillsCodec`**
+
+```java
+public final class PlayerSkillsCodec {
+  private PlayerSkillsCodec() {}
+
+  public static CompoundTag write(PlayerSkills skills) { /* serialize points, reset flag, tree version, and learned skills */ }
+
+  public static void read(PlayerSkills skills, CompoundTag tag) { /* preserve the current tree-version invalidation behavior */ }
+}
+```
+
+Make `PlayerSkills` delegate to this helper so the persistence rules stay in one place and can be tested without touching NeoForge runtime code.
+
+- [ ] **Step 4: Re-run the test until it passes cleanly**
+
+Run: `bash gradlew test --tests daripher.skilltree.capability.skill.PlayerSkillsCodecTest -v`
+
+Expected: PASS with no new warnings from the test harness.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add build.gradle src/main/java/daripher/skilltree/capability/skill/PlayerSkillsCodec.java src/main/java/daripher/skilltree/capability/skill/PlayerSkills.java src/test/java/daripher/skilltree/capability/skill/PlayerSkillsCodecTest.java
+git commit -m "test: lock down player skill persistence"
+```
+
+### Task 3: Replace the player capability with a NeoForge attachment
+
+**Files:**
+- Create `src/main/java/daripher/skilltree/init/PSTAttachments.java`
+- Modify `src/main/java/daripher/skilltree/SkillTreeMod.java`
+- Modify `src/main/java/daripher/skilltree/capability/skill/PlayerSkillsProvider.java`
+- Modify all call sites that still read through `PlayerSkillsProvider` if the helper method names change
+
+- [ ] **Step 1: Register the attachment type**
+
+```java
+public final class PSTAttachments {
+  public static final DeferredRegister<AttachmentType<?>> REGISTRY =
+      DeferredRegister.create(NeoForgeRegistries.ATTACHMENT_TYPES, SkillTreeMod.MOD_ID);
+
+  public static final Supplier<AttachmentType<PlayerSkills>> PLAYER_SKILLS =
+      REGISTRY.register(
+          "player_skills",
+          () -> AttachmentType.serializable(PlayerSkills::new).copyOnDeath().build());
+
+  private PSTAttachments() {}
+}
+```
+
+Register this deferred register from `SkillTreeMod` on the mod event bus next to the existing item, recipe, menu, and loot registries.
+
+- [ ] **Step 2: Rework `PlayerSkillsProvider` into attachment-backed access helpers**
+
+Keep the public `get(Player)` / `hasSkills(Player)` helpers, but make them read from the attachment instead of `CapabilityManager`, `LazyOptional`, or `ICapabilitySerializable`.
+
+```java
+public static @NotNull IPlayerSkills get(Player player) {
+  return player.getData(PSTAttachments.PLAYER_SKILLS.get());
+}
+```
+
+Keep the existing login, clone, and join event hooks, but make them use attachment-backed data and preserve the current tree-reset message and bonus reapplication flow.
+
+- [ ] **Step 3: Re-run a build after removing the capability APIs**
+
+Run: `bash gradlew compileJava`
+
+Expected: no remaining references to `CapabilityManager`, `CapabilityToken`, `LazyOptional`, `ICapabilitySerializable`, or `AttachCapabilitiesEvent` in the player-skill storage path.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/main/java/daripher/skilltree/init/PSTAttachments.java src/main/java/daripher/skilltree/SkillTreeMod.java src/main/java/daripher/skilltree/capability/skill/PlayerSkillsProvider.java
+git commit -m "refactor: move player skills to attachments"
+```
+
+### Task 4: Convert the network layer to NeoForge payloads
+
+**Files:**
+- Modify `src/main/java/daripher/skilltree/network/NetworkDispatcher.java`
+- Modify `src/main/java/daripher/skilltree/network/message/SyncServerDataMessage.java`
+- Modify `src/main/java/daripher/skilltree/network/message/SyncPlayerSkillsMessage.java`
+- Modify `src/main/java/daripher/skilltree/network/message/LearnSkillMessage.java`
+- Modify `src/main/java/daripher/skilltree/network/message/GainSkillPointMessage.java`
+- Modify `src/main/java/daripher/skilltree/network/NetworkHelper.java`
+- Modify `src/main/java/daripher/skilltree/client/widget/SkillTreeWidgets.java`
+- Modify `src/main/java/daripher/skilltree/item/AmnesiaScrollItem.java`
+- Modify `src/main/java/daripher/skilltree/item/WisdomScrollItem.java`
+- Modify `src/main/java/daripher/skilltree/command/PSTCommands.java`
+
+- [ ] **Step 1: Replace `SimpleChannel` registration with payload registration**
+
+```java
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Bus.MOD)
+public final class NetworkDispatcher {
+  @SubscribeEvent
+  public static void register(final RegisterPayloadHandlersEvent event) {
+    PayloadRegistrar registrar = event.registrar("1");
+    registrar.playToClient(SyncServerDataMessage.TYPE, SyncServerDataMessage.STREAM_CODEC, SyncServerDataMessage::handle);
+    registrar.playToClient(SyncPlayerSkillsMessage.TYPE, SyncPlayerSkillsMessage.STREAM_CODEC, SyncPlayerSkillsMessage::handle);
+    registrar.playToServer(LearnSkillMessage.TYPE, LearnSkillMessage.STREAM_CODEC, LearnSkillMessage::handle);
+    registrar.playToServer(GainSkillPointMessage.TYPE, GainSkillPointMessage.STREAM_CODEC, GainSkillPointMessage::handle);
+  }
+}
+```
+
+Keep the current message names if that makes the call-site migration smaller, but make each message a `CustomPacketPayload`.
+
+- [ ] **Step 2: Convert the four message classes to payload records or payload objects**
+
+Use the existing `NetworkHelper` methods for the custom data fields so the wire format stays stable. A minimal payload shape looks like this:
+
+```java
+public record LearnSkillMessage(ResourceLocation skillId) implements CustomPacketPayload {
+  public static final Type<LearnSkillMessage> TYPE =
+      new Type<>(ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "learn_skill"));
+  public static final StreamCodec<FriendlyByteBuf, LearnSkillMessage> STREAM_CODEC = /* wrap existing encode/decode */;
+
+  @Override
+  public Type<? extends CustomPacketPayload> type() { return TYPE; }
+
+  public static void handle(LearnSkillMessage message, IPayloadContext context) { /* server-side validation */ }
+}
+```
+
+Do the same for the sync payloads and the gain-skill-point request.
+
+- [ ] **Step 3: Update every send site to the NeoForge `PacketDistributor` helpers**
+
+Replace:
+
+```java
+NetworkDispatcher.network_channel.sendToServer(new LearnSkillMessage(skill));
+```
+
+with the NeoForge payload send helper:
+
+```java
+PacketDistributor.sendToServer(new LearnSkillMessage(skill));
+```
+
+Replace player-targeted sends with `PacketDistributor.sendToPlayer(player, new SyncPlayerSkillsMessage(player));`.
+
+- [ ] **Step 4: Smoke test the new transport on both sides**
+
+Run:
+
+```bash
+bash gradlew runClient
+bash gradlew runServer
+```
+
+Expected: the client can still open the skill UI and the dedicated server starts without network registration or payload codec errors.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/main/java/daripher/skilltree/network/NetworkDispatcher.java src/main/java/daripher/skilltree/network/message/SyncServerDataMessage.java src/main/java/daripher/skilltree/network/message/SyncPlayerSkillsMessage.java src/main/java/daripher/skilltree/network/message/LearnSkillMessage.java src/main/java/daripher/skilltree/network/message/GainSkillPointMessage.java src/main/java/daripher/skilltree/network/NetworkHelper.java src/main/java/daripher/skilltree/client/widget/SkillTreeWidgets.java src/main/java/daripher/skilltree/item/AmnesiaScrollItem.java src/main/java/daripher/skilltree/item/WisdomScrollItem.java src/main/java/daripher/skilltree/command/PSTCommands.java
+git commit -m "refactor: move networking to NeoForge payloads"
+```
+
+### Task 5: Port the server-side 1.21.1 API breaks
+
+**Files:**
+- Modify `src/main/java/daripher/skilltree/data/serializers/SerializationHelper.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTTags.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTBlocks.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTItems.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTRecipeSerializers.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTRecipeTypes.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTLootModifiers.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTDamageTypes.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTMobEffects.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTPotions.java`
+- Modify `src/main/java/daripher/skilltree/recipe/**`
+- Modify `src/main/java/daripher/skilltree/skill/**` server-side bonus, requirement, and predicate classes
+- Modify `src/main/java/daripher/skilltree/data/reloader/**`
+- Modify `src/main/java/daripher/skilltree/event/PSTEvents.java`
+- Modify `src/main/java/daripher/skilltree/command/PSTCommands.java`
+- Modify `src/main/java/daripher/skilltree/entity/player/PlayerHelper.java`
+
+- [ ] **Step 1: Replace old Forge registry and resource-location calls with the 1.21.1 equivalents**
+
+Use `BuiltInRegistries` / NeoForge registries where the code currently hard-depends on `ForgeRegistries`, and convert string-based `new ResourceLocation(...)` calls to `ResourceLocation.fromNamespaceAndPath(...)` where the 1.21.1 API prefers it.
+
+- [ ] **Step 2: Fix the attribute and recipe serialization surfaces**
+
+`SerializationHelper`, the recipe builders, and the skill bonus serializers should preserve the current wire/data format unless 1.21.1 forces a new shape. If the attribute modifier ID format has to change, keep the old UUID/name fields readable so existing skill JSON still loads.
+
+- [ ] **Step 3: Resolve the event/package mismatches that show up during compile**
+
+Fix the imports and method signatures for the event classes touched by:
+- grindstone logic
+- reload listeners
+- anvil logic
+- tooltip logic
+- movement input logic
+- living damage / heal / attack logic
+
+- [ ] **Step 4: Re-run compilation**
+
+Run: `bash gradlew compileJava`
+
+Expected: this should now fail only on remaining client/mixin/compat issues, not on the core server/data layer.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/main/java/daripher/skilltree/data/serializers/SerializationHelper.java src/main/java/daripher/skilltree/init/PSTTags.java src/main/java/daripher/skilltree/init/PSTBlocks.java src/main/java/daripher/skilltree/init/PSTItems.java src/main/java/daripher/skilltree/init/PSTRecipeSerializers.java src/main/java/daripher/skilltree/init/PSTRecipeTypes.java src/main/java/daripher/skilltree/init/PSTLootModifiers.java src/main/java/daripher/skilltree/init/PSTDamageTypes.java src/main/java/daripher/skilltree/init/PSTMobEffects.java src/main/java/daripher/skilltree/init/PSTPotions.java src/main/java/daripher/skilltree/recipe src/main/java/daripher/skilltree/skill src/main/java/daripher/skilltree/data/reloader src/main/java/daripher/skilltree/event/PSTEvents.java src/main/java/daripher/skilltree/command/PSTCommands.java src/main/java/daripher/skilltree/entity/player/PlayerHelper.java
+git commit -m "refactor: port server gameplay APIs to 1.21.1"
+```
+
+### Task 6: Port the client, GUI, and mixin surface
+
+**Files:**
+- Modify `src/main/java/daripher/skilltree/client/init/PSTKeybinds.java`
+- Modify `src/main/java/daripher/skilltree/init/PSTMenuTypes.java`
+- Modify `src/main/java/daripher/skilltree/client/screen/**`
+- Modify `src/main/java/daripher/skilltree/client/widget/**`
+- Modify `src/main/java/daripher/skilltree/client/tooltip/TooltipHelper.java`
+- Modify `src/main/java/daripher/skilltree/mixin/**`
+- Modify `src/main/resources/skilltree.mixins.json`
+
+- [ ] **Step 1: Replace the old client menu registration path with `RegisterMenuScreensEvent`**
+
+```java
+@SubscribeEvent
+public static void registerScreens(RegisterMenuScreensEvent event) {
+  event.register(ARTISAN_WORKBENCH.get(), WorkbenchScreen::new);
+}
+```
+
+Move keybind registration to the NeoForge client event bus and keep the screen/widget classes client-only.
+
+- [ ] **Step 2: Update the mixin config for the Java 21 runtime**
+
+```json
+{
+  "required": true,
+  "minVersion": "0.8",
+  "compatibilityLevel": "JAVA_21"
+}
+```
+
+Then fix the accessor and injector signatures in:
+- `AbstractArrowAccessor`
+- `ClientAdvancementsAccessor`
+- `EditBoxAccessor`
+- `MobEffectInstanceAccessor`
+- `ArmorSlotMixin`
+- `ItemStackMixin`
+- `LivingEntityMixin`
+- `MobEffectMixin`
+- `PlayerMixin`
+- `ThrownPotionMixin`
+
+- [ ] **Step 3: Run the client smoke test and fix whatever still fails to render or register**
+
+Run: `bash gradlew runClient`
+
+Expected: the skill tree UI opens, keybinds register, menus/screens open, and the mixins apply without classloading errors.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/main/java/daripher/skilltree/client/init/PSTKeybinds.java src/main/java/daripher/skilltree/init/PSTMenuTypes.java src/main/java/daripher/skilltree/client/screen src/main/java/daripher/skilltree/client/widget src/main/java/daripher/skilltree/client/tooltip/TooltipHelper.java src/main/java/daripher/skilltree/mixin src/main/resources/skilltree.mixins.json
+git commit -m "refactor: port client ui and mixins to 1.21.1"
+```
+
+### Task 7: Refresh datagen, tag namespaces, and optional compat dependencies
+
+**Files:**
+- Modify `src/main/java/daripher/skilltree/data/generation/**`
+- Modify `src/main/java/daripher/skilltree/init/PSTTags.java`
+- Modify `src/main/java/daripher/skilltree/compat/**`
+- Modify `build.gradle`
+- Modify `src/main/resources/META-INF/neoforge.mods.toml`
+- Replace generated resources under `src/generated/resources/**`
+
+- [ ] **Step 1: Move shared tags and damage tags into the NeoForge namespaces**
+
+```java
+public class PSTTags {
+  public static class DamageTypes {
+    public static final TagKey<DamageType> IS_MAGIC =
+        TagKey.create(Registries.DAMAGE_TYPE, new ResourceLocation("neoforge", "is_magic"));
+  }
+
+  public static class Items {
+    public static final TagKey<Item> JEWELRY =
+        ItemTags.create(new ResourceLocation("c", "curios/jewelry"));
+    public static final TagKey<Item> MELEE_WEAPON = ItemTags.create(new ResourceLocation("skilltree", "melee_weapon"));
+    public static final TagKey<Item> RANGED_WEAPON = ItemTags.create(new ResourceLocation("skilltree", "ranged_weapon"));
+    public static final TagKey<Item> LEATHER_ARMOR = ItemTags.create(new ResourceLocation("skilltree", "armors/leather"));
+  }
+}
+```
+
+Update the item and damage tags providers so the generated files land in `data/c/...` and `data/neoforge/...` instead of the old Forge paths.
+
+- [ ] **Step 2: Regenerate the data outputs**
+
+Run: `bash gradlew runData`
+
+Replace the generated outputs under `src/generated/resources/` so these files match the NeoForge namespace layout:
+- `data/neoforge/loot_modifiers/global_loot_modifiers.json`
+- `data/neoforge/tags/damage_type/is_magic.json`
+- `data/c/tags/items/tools.json` and any other shared item tags produced by the providers
+
+- [ ] **Step 3: Re-scope the optional dependency declarations**
+
+In `build.gradle`, keep direct API mods available to the compiler, but move purely runtime companions to the NeoForge 1.21.1 runtime setup:
+- `compileOnly` / `localRuntime` for API-backed integrations used in source
+- `localRuntime` for optional helpers that are only needed to run the mod in a dev instance
+- preserve the existing required/optional split in `neoforge.mods.toml`
+
+Refresh the 1.21.1 NeoForge versions for:
+- Curios
+- AttributeFix
+- Max Health Fix
+- Apothic Attributes
+- Iron’s Spells and Spellbooks
+- JEI
+- AppleSkin
+- Selene, Placebo, Geckolib, and PlayerAnimator where the build still needs them
+
+- [ ] **Step 4: Run the full verification set**
+
+Run:
+
+```bash
+bash gradlew compileJava
+bash gradlew test
+bash gradlew runClient
+bash gradlew runServer
+bash gradlew runData
+```
+
+Expected: the project builds cleanly, the UI opens, the dedicated server starts, and the generated resources match the new NeoForge namespaces.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/main/java/daripher/skilltree/data/generation src/main/java/daripher/skilltree/init/PSTTags.java src/main/java/daripher/skilltree/compat build.gradle src/main/resources/META-INF/neoforge.mods.toml src/generated/resources
+git commit -m "refactor: refresh datagen and compat for NeoForge"
+```
+
+### Task 8: Final pass and branch completion
+
+**Files:**
+- All files touched in the tasks above
+
+- [ ] **Step 1: Do one last clean status check**
+
+Run: `git status --short`
+
+Expected: only the intended port files remain changed.
+
+- [ ] **Step 2: Re-run the highest-risk checks after the last merge of changes**
+
+Run:
+
+```bash
+bash gradlew compileJava
+bash gradlew test
+```
+
+Expected: both pass without reintroducing Forge imports, capability leftovers, or broken tests.
+
+- [ ] **Step 3: Prepare the branch for handoff**
+
+Summarize the final changed file groups and note any remaining follow-up work, if any, before calling the port complete.
+
diff --git a/docs/superpowers/specs/2026-05-15-passive-skill-tree-neoforge-1211-port-design.md b/docs/superpowers/specs/2026-05-15-passive-skill-tree-neoforge-1211-port-design.md
new file mode 100644
index 000000000..2bf51dbdd
--- /dev/null
+++ b/docs/superpowers/specs/2026-05-15-passive-skill-tree-neoforge-1211-port-design.md
@@ -0,0 +1,145 @@
+# Passive Skill Tree NeoForge 1.21.1 Port Design
+
+## Summary
+Port Passive Skill Tree from Minecraft 1.20.1 Forge to Minecraft 1.21.1 NeoForge while preserving full feature parity.
+
+The mod should keep the current gameplay surface intact: skill trees, point progression, player skill persistence, skill UI, editor UI, data-driven skills/recipes/loot modifiers, commands, and optional compat integrations.
+
+## Goals
+- Build and run on Minecraft 1.21.1 NeoForge.
+- Preserve core gameplay and save data behavior.
+- Preserve optional compat support for the modded ecosystem already used by the project.
+- Keep existing JSON/data-driven content usable with minimal disruption.
+
+## Non-Goals
+- No gameplay redesign.
+- No content rebalance unless a 1.21.1 API break forces a targeted fix.
+- No multi-loader abstraction work.
+
+## Migration Strategy
+Use a staged full-parity port:
+1. Update the build and NeoForge toolchain.
+2. Migrate Forge platform APIs to NeoForge equivalents.
+3. Replace player capability storage with NeoForge attachment-based storage.
+4. Replace SimpleChannel networking with NeoForge payload networking.
+5. Update vanilla 1.21.1 API breakpoints and mixin targets.
+6. Restore optional compat modules and verify they still load.
+
+This keeps the scope full-featured, but avoids mixing every classpath and runtime break into one unreadable failure.
+
+## Platform Changes
+- Move from ForgeGradle to the NeoForge userdev/NeoGradle setup used by 1.21.1 MDKs.
+- Target Java 21.
+- Update the wrapper to a NeoForge-compatible Gradle version.
+- Replace `META-INF/mods.toml` with `META-INF/neoforge.mods.toml`.
+- Update metadata properties and dependency declarations for NeoForge 1.21.1.
+
+## Core Runtime Changes
+
+### Player skill state
+Replace the Forge player capability provider with a NeoForge entity attachment for `PlayerSkills`.
+
+Why:
+- `PlayerSkills` already serializes to NBT.
+- The data is persistent per-player state and maps cleanly to an attachment.
+- Player respawn handling can stay behaviorally identical by copying or restoring the saved skill state on clone.
+
+Required behavior:
+- Persist learned skills, skill points, and tree reset state.
+- Preserve the current tree-version invalidation behavior.
+- Preserve the current “refund points and mark reset” fallback when the tree version or skill IDs are invalid.
+
+### Networking
+Replace the current `SimpleChannel` message stack with NeoForge payload registration.
+
+Required payloads:
+- server sync data
+- player skill sync
+- learn skill request
+- gain skill point request
+
+Rules:
+- server validates every client-originated request
+- payload handlers stay side-safe
+- client UI still receives the same sync information it expects today
+
+### Registries and events
+Keep the existing `PST*` registration classes where possible, but swap their Forge-specific APIs to NeoForge equivalents.
+
+The following areas need attention:
+- mod bootstrap and event bus wiring
+- deferred registry usage
+- config registration
+- reload listeners
+- client keybind registration
+- loot modifier registration
+- recipe, menu, block/item, effect, and tag registration
+
+## 1.21.1 API Breakpoints
+Update the code where 1.21.1 vanilla or NeoForge signatures changed:
+- `ResourceLocation` construction and parsing usage
+- attribute modifier handling
+- recipe and menu APIs
+- item stack and component/data handling
+- event classes and event package names
+- mixin targets and accessor names
+- client screen/widget bindings
+
+The migration should preserve the current data formats where possible, with adapters only where the version change requires them.
+
+## Compat Modules
+Preserve the current optional integrations, but swap them to the 1.21.1 NeoForge versions already available in the ecosystem.
+
+Current compat surface to keep:
+- Curios
+- AttributeFix / max health handling
+- Apothic Attributes
+- Iron’s Spells and Spellbooks
+- JEI
+- AppleSkin
+- the current development/runtime support dependencies already present in the build, including Selene, mmmmmmmmmmmm, Placebo, Geckolib, and PlayerAnimator
+
+Dependency policy should mirror the current mod:
+- required integrations stay required when the existing metadata says they are required
+- optional compat stays optional
+- dev/runtime support libs stay present for testing and local launch, but do not become hard dependencies unless the code truly needs them
+
+## Data Flow
+1. Server loads skill trees, skills, recipes, loot modifiers, tags, and configs.
+2. Player joins and receives persistent skill state from the attachment-backed storage.
+3. Server syncs trees and player data to the client.
+4. Client sends learn/reset/editor actions through payloads.
+5. Server validates the request, mutates saved skill state, applies or removes bonuses, then resyncs.
+6. Gameplay listeners and compat hooks apply the active bonuses during combat, crafting, movement, potion, damage, and loot events.
+
+## Error Handling
+- Missing optional compat mods should not crash the base mod.
+- Missing required mods should fail through mod metadata, not late during gameplay.
+- Invalid skill IDs or malformed data should log clearly and fail safe on the server.
+- Dedicated server startup must not touch client-only classes.
+
+## Verification
+Acceptance criteria:
+- project compiles on the NeoForge 1.21.1 toolchain
+- client launches and opens the skill tree UI
+- dedicated server launches without classloading failures
+- learned skills persist across relog and death
+- learn/reset/sync requests work over the new payload channel
+- optional compat modules compile and load with their 1.21.1 NeoForge dependencies
+- datagen outputs remain valid for the existing data model
+
+Recommended check order:
+1. `compileJava`
+2. client smoke run
+3. dedicated server smoke run
+4. data generation / resource validation
+5. targeted gameplay checks for learn skill, reset tree, and compat-triggered bonuses
+
+## References
+- NeoForge getting started: https://docs.neoforged.net/docs/1.21.1/gettingstarted/
+- NeoForge mod files: https://docs.neoforged.net/docs/1.21.4/gettingstarted/modfiles/
+- NeoForge data attachments: https://docs.neoforged.net/docs/1.21.1/datastorage/attachments/
+- NeoForge networking payloads: https://docs.neoforged.net/docs/1.21.1/networking/payload/
+- Curios 1.21.1 NeoForge files: https://www.curseforge.com/minecraft/mc-mods/curios/files/all?page=1&version=1.21.1
+- AttributeFix 1.21.1 NeoForge files: https://www.curseforge.com/minecraft/mc-mods/attributefix/files/all?page=1&version=1.21.1
+- Apothic Attributes 1.21.1 NeoForge files: https://www.curseforge.com/minecraft/mc-mods/apothic-attributes/files/all?page=1&pageSize=20&version=1.21.1
diff --git a/gradle.properties b/gradle.properties
index 612a3cb1a..f0ec7a8f5 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,18 +1,17 @@
 org.gradle.jvmargs=-Xmx3G
 org.gradle.daemon=false
 
-minecraft_version=1.20.1
-minecraft_version_range=[1.20.1,1.21)
-forge_version=47.4.0
-forge_version_range=[47,)
-loader_version_range=[47,)
+minecraft_version=1.21.1
+minecraft_version_range=[1.21.1,1.21.2)
+neo_version=21.1.228
+loader_version_range=[1,)
 
-mapping_channel=parchment
-mapping_version=2023.09.03-1.20.1
+neogradle.subsystems.parchment.minecraftVersion=1.21.1
+neogradle.subsystems.parchment.mappingsVersion=2024.11.17
 
 mod_id=skilltree
 mod_name=Passive Skill Tree
-mod_file_name=PassiveSkillTree-1.20.1-BETA
+mod_file_name=PassiveSkillTree-1.21.1-NeoForge-BETA
 mod_license=GNU GENERAL PUBLIC LICENSE
 mod_version=0.7.6c
 mod_group_id=daripher.skilltree
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 37aef8d3f..cd4b7aa89 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/settings.gradle b/settings.gradle
index 995ba247c..38951cbbf 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,10 +1,7 @@
 pluginManagement {
     repositories {
         gradlePluginPortal()
-        maven {
-            name = 'MinecraftForge'
-            url = 'https://maven.minecraftforge.net/'
-        }
+        maven { url = 'https://maven.neoforged.net/releases' }
         maven { url = 'https://repo.spongepowered.org/repository/maven-public/' }
         maven { url = 'https://maven.parchmentmc.org' }
     }
@@ -12,4 +9,4 @@ pluginManagement {
 
 plugins {
     id 'org.gradle.toolchains.foojay-resolver-convention' version '0.5.0'
-}
\ No newline at end of file
+}
diff --git a/src/generated/resources/.cache/67667cb51994a49b68e560431391360e3828f1f8 b/src/generated/resources/.cache/67667cb51994a49b68e560431391360e3828f1f8
new file mode 100644
index 000000000..55992d3be
--- /dev/null
+++ b/src/generated/resources/.cache/67667cb51994a49b68e560431391360e3828f1f8
@@ -0,0 +1,2 @@
+// 1.21.1	2026-07-17T03:35:03.297362132	Languages: ru_ru for mod: skilltree
+fd50ba482726d77cf1751e22126471d97546f4d7 assets/skilltree/lang/ru_ru.json
diff --git a/src/generated/resources/.cache/7dbdaff3a029567dee918985a82fb9fa3198261b b/src/generated/resources/.cache/7dbdaff3a029567dee918985a82fb9fa3198261b
new file mode 100644
index 000000000..5652c9434
--- /dev/null
+++ b/src/generated/resources/.cache/7dbdaff3a029567dee918985a82fb9fa3198261b
@@ -0,0 +1,2 @@
+// 1.21.1	2026-07-17T03:35:03.296193239	Languages: en_us for mod: skilltree
+9428b709192d4df5f6763b31d88bcf9ce7acf17f assets/skilltree/lang/en_us.json
diff --git a/src/generated/resources/assets/skilltree/lang/en_us.json b/src/generated/resources/assets/skilltree/lang/en_us.json
index c4f54a26f..ad089633f 100644
--- a/src/generated/resources/assets/skilltree/lang/en_us.json
+++ b/src/generated/resources/assets/skilltree/lang/en_us.json
@@ -110,11 +110,11 @@
   "item_condition.skilltree.potion.harmful.plural": "Harmful Potions",
   "item_condition.skilltree.potion.neutral": "Neutral Potion",
   "item_condition.skilltree.potion.neutral.plural": "Neutral Potions",
+  "item_tag.curios:jewelry": "Jewelry",
   "item_tag.curios:necklace": "Necklace",
   "item_tag.curios:necklace.plural": "Necklaces",
   "item_tag.curios:ring": "Ring",
   "item_tag.curios:ring.plural": "Rings",
-  "item_tag.forge:curios/jewelry": "Jewelry",
   "item_tag.skilltree:armors/leather": "Leather Armor",
   "item_tag.skilltree:armors/leather.plural": "Leather Armor",
   "key.categories.skilltree": "Passive Skill Tree",
diff --git a/src/generated/resources/assets/skilltree/lang/ru_ru.json b/src/generated/resources/assets/skilltree/lang/ru_ru.json
index f4529de13..5a2865516 100644
--- a/src/generated/resources/assets/skilltree/lang/ru_ru.json
+++ b/src/generated/resources/assets/skilltree/lang/ru_ru.json
@@ -182,6 +182,11 @@
   "item_condition.skilltree.potion.neutral.adjective": "ое Нейтральное Зелье",
   "item_condition.skilltree.potion.neutral.plural": "Нейтральные Зелья",
   "item_condition.skilltree.potion.neutral.plural.adjective": "ые Нейтральные Зелья",
+  "item_tag.curios:jewelry": "Бижутерия",
+  "item_tag.curios:jewelry.plural": "Бижутерия",
+  "item_tag.curios:jewelry.plural.adjective": "ая Бижутерия",
+  "item_tag.curios:jewelry.type": "ая Бижутерия",
+  "item_tag.curios:jewelry.where": "Бижутерии",
   "item_tag.curios:necklace": "Ожерелье",
   "item_tag.curios:necklace.plural": "Ожерелья",
   "item_tag.curios:necklace.plural.adjective": "ые Ожерелья",
@@ -191,11 +196,6 @@
   "item_tag.curios:ring.plural.adjective": "ые Кольца",
   "item_tag.curios:ring.type": "ое Кольцо",
   "item_tag.curios:ring.where": "Кольцах",
-  "item_tag.forge:curios/jewelry": "Бижутерия",
-  "item_tag.forge:curios/jewelry.plural": "Бижутерия",
-  "item_tag.forge:curios/jewelry.plural.adjective": "ая Бижутерия",
-  "item_tag.forge:curios/jewelry.type": "ая Бижутерия",
-  "item_tag.forge:curios/jewelry.where": "Бижутерии",
   "item_tag.skilltree:armors/leather": "Кожаная броня",
   "item_tag.skilltree:armors/leather.plural": "Кожаная броня",
   "key.categories.skilltree": "Древо пассивных умений",
diff --git a/src/generated/resources/data/forge/tags/items/tools.json b/src/generated/resources/data/c/tags/item/tools.json
similarity index 61%
rename from src/generated/resources/data/forge/tags/items/tools.json
rename to src/generated/resources/data/c/tags/item/tools.json
index 931e27684..679e53c42 100644
--- a/src/generated/resources/data/forge/tags/items/tools.json
+++ b/src/generated/resources/data/c/tags/item/tools.json
@@ -1,7 +1,7 @@
 {
   "values": [
     {
-      "id": "#forge:tools/knives",
+      "id": "#c:tools/knives",
       "required": false
     }
   ]
diff --git a/src/generated/resources/data/forge/loot_modifiers/global_loot_modifiers.json b/src/generated/resources/data/neoforge/loot_modifiers/global_loot_modifiers.json
similarity index 100%
rename from src/generated/resources/data/forge/loot_modifiers/global_loot_modifiers.json
rename to src/generated/resources/data/neoforge/loot_modifiers/global_loot_modifiers.json
diff --git a/src/generated/resources/data/forge/tags/damage_type/is_magic.json b/src/generated/resources/data/neoforge/tags/damage_type/is_magic.json
similarity index 100%
rename from src/generated/resources/data/forge/tags/damage_type/is_magic.json
rename to src/generated/resources/data/neoforge/tags/damage_type/is_magic.json
diff --git a/src/generated/resources/data/skilltree/advancements/recipes/misc/workbench.json b/src/generated/resources/data/skilltree/advancement/recipes/misc/workbench.json
similarity index 74%
rename from src/generated/resources/data/skilltree/advancements/recipes/misc/workbench.json
rename to src/generated/resources/data/skilltree/advancement/recipes/misc/workbench.json
index 7313e2b94..b5e3d73d7 100644
--- a/src/generated/resources/data/skilltree/advancements/recipes/misc/workbench.json
+++ b/src/generated/resources/data/skilltree/advancement/recipes/misc/workbench.json
@@ -5,9 +5,7 @@
       "conditions": {
         "items": [
           {
-            "items": [
-              "minecraft:smithing_table"
-            ]
+            "items": "minecraft:smithing_table"
           }
         ]
       },
@@ -22,14 +20,13 @@
   },
   "requirements": [
     [
-      "has_smithing_table",
-      "has_the_recipe"
+      "has_the_recipe",
+      "has_smithing_table"
     ]
   ],
   "rewards": {
     "recipes": [
       "skilltree:workbench"
     ]
-  },
-  "sends_telemetry_event": false
+  }
 }
\ No newline at end of file
diff --git a/src/generated/resources/data/skilltree/loot_tables/blocks/workbench.json b/src/generated/resources/data/skilltree/loot_table/blocks/workbench.json
similarity index 100%
rename from src/generated/resources/data/skilltree/loot_tables/blocks/workbench.json
rename to src/generated/resources/data/skilltree/loot_table/blocks/workbench.json
diff --git a/src/generated/resources/data/skilltree/recipes/workbench.json b/src/generated/resources/data/skilltree/recipe/workbench.json
similarity index 60%
rename from src/generated/resources/data/skilltree/recipes/workbench.json
rename to src/generated/resources/data/skilltree/recipe/workbench.json
index d9b2b39cb..e5dc10d53 100644
--- a/src/generated/resources/data/skilltree/recipes/workbench.json
+++ b/src/generated/resources/data/skilltree/recipe/workbench.json
@@ -6,13 +6,13 @@
       "item": "minecraft:smithing_table"
     },
     "C": {
-      "tag": "forge:ingots/copper"
+      "tag": "c:ingots/copper"
     },
     "G": {
-      "tag": "forge:ingots/gold"
+      "tag": "c:ingots/gold"
     },
     "I": {
-      "tag": "forge:ingots/iron"
+      "tag": "c:ingots/iron"
     }
   },
   "pattern": [
@@ -21,7 +21,7 @@
     "CCC"
   ],
   "result": {
-    "item": "skilltree:workbench"
-  },
-  "show_notification": true
+    "count": 1,
+    "id": "skilltree:workbench"
+  }
 }
\ No newline at end of file
diff --git a/src/generated/resources/data/skilltree/tags/items/armors/leather.json b/src/generated/resources/data/skilltree/tags/item/armors/leather.json
similarity index 100%
rename from src/generated/resources/data/skilltree/tags/items/armors/leather.json
rename to src/generated/resources/data/skilltree/tags/item/armors/leather.json
diff --git a/src/generated/resources/data/skilltree/tags/items/melee_weapon.json b/src/generated/resources/data/skilltree/tags/item/melee_weapon.json
similarity index 71%
rename from src/generated/resources/data/skilltree/tags/items/melee_weapon.json
rename to src/generated/resources/data/skilltree/tags/item/melee_weapon.json
index d32b3b3cb..ef44b05b4 100644
--- a/src/generated/resources/data/skilltree/tags/items/melee_weapon.json
+++ b/src/generated/resources/data/skilltree/tags/item/melee_weapon.json
@@ -2,6 +2,6 @@
   "values": [
     "#minecraft:swords",
     "#minecraft:axes",
-    "#forge:tools/tridents"
+    "#c:tools/spear"
   ]
 }
\ No newline at end of file
diff --git a/src/generated/resources/data/skilltree/tags/item/ranged_weapon.json b/src/generated/resources/data/skilltree/tags/item/ranged_weapon.json
new file mode 100644
index 000000000..23f0816a5
--- /dev/null
+++ b/src/generated/resources/data/skilltree/tags/item/ranged_weapon.json
@@ -0,0 +1,6 @@
+{
+  "values": [
+    "#c:tools/bow",
+    "#c:tools/crossbow"
+  ]
+}
\ No newline at end of file
diff --git a/src/generated/resources/data/skilltree/tags/items/ranged_weapon.json b/src/generated/resources/data/skilltree/tags/items/ranged_weapon.json
deleted file mode 100644
index fc931e62c..000000000
--- a/src/generated/resources/data/skilltree/tags/items/ranged_weapon.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "values": [
-    "#forge:tools/bows",
-    "#forge:tools/crossbows"
-  ]
-}
\ No newline at end of file
diff --git a/src/main/java/daripher/skilltree/SkillTreeMod.java b/src/main/java/daripher/skilltree/SkillTreeMod.java
index b8e91da8c..2ced2a6b3 100644
--- a/src/main/java/daripher/skilltree/SkillTreeMod.java
+++ b/src/main/java/daripher/skilltree/SkillTreeMod.java
@@ -7,11 +7,11 @@
 import daripher.skilltree.config.ServerConfig;
 import daripher.skilltree.init.*;
 import daripher.skilltree.init.predicate.*;
-import net.minecraftforge.eventbus.api.IEventBus;
-import net.minecraftforge.fml.ModList;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.config.ModConfig;
-import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import net.neoforged.bus.api.IEventBus;
+import net.neoforged.fml.ModContainer;
+import net.neoforged.fml.ModList;
+import net.neoforged.fml.common.Mod;
+import net.neoforged.fml.config.ModConfig;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -20,14 +20,15 @@ public class SkillTreeMod {
     public static final String MOD_ID = "skilltree";
     public static final Logger LOGGER = LogManager.getLogger(SkillTreeMod.MOD_ID);
 
-    public SkillTreeMod(FMLJavaModLoadingContext context) {
-        registerModRegistries(context);
-        registerConfigs(context);
+    public SkillTreeMod(IEventBus eventBus, ModContainer modContainer) {
+        registerModRegistries(eventBus);
+        registerConfigs(modContainer);
         registerCompatibilities();
     }
 
-    private static void registerModRegistries(FMLJavaModLoadingContext context) {
-        IEventBus eventBus = context.getModEventBus();
+    private static void registerModRegistries(IEventBus eventBus) {
+        PSTRegistries.bootstrap();
+        PSTAttachments.REGISTRY.register(eventBus);
         PSTItems.REGISTRY.register(eventBus);
         PSTMobEffects.REGISTRY.register(eventBus);
         PSTCreativeTabs.REGISTRY.register(eventBus);
@@ -50,9 +51,9 @@ private static void registerModRegistries(FMLJavaModLoadingContext context) {
         PSTMobEffectPredicates.REGISTRY.register(eventBus);
     }
 
-    private static void registerConfigs(FMLJavaModLoadingContext context) {
-        context.registerConfig(ModConfig.Type.SERVER, ServerConfig.SPEC);
-        context.registerConfig(ModConfig.Type.CLIENT, ClientConfig.SPEC);
+    private static void registerConfigs(ModContainer modContainer) {
+        modContainer.registerConfig(ModConfig.Type.SERVER, ServerConfig.SPEC);
+        modContainer.registerConfig(ModConfig.Type.CLIENT, ClientConfig.SPEC);
     }
 
     private static void registerCompatibilities() {
diff --git a/src/main/java/daripher/skilltree/attribute/AttributesHelper.java b/src/main/java/daripher/skilltree/attribute/AttributesHelper.java
index e4c0c20a3..3d93c0187 100644
--- a/src/main/java/daripher/skilltree/attribute/AttributesHelper.java
+++ b/src/main/java/daripher/skilltree/attribute/AttributesHelper.java
@@ -1,12 +1,13 @@
 package daripher.skilltree.attribute;
 
 import daripher.skilltree.SkillTreeMod;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.ai.attributes.Attribute;
 import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
 import net.minecraft.world.entity.ai.attributes.DefaultAttributes;
-import net.minecraftforge.registries.ForgeRegistries;
+import daripher.skilltree.util.ForgeRegistries;
 
 import java.util.Collection;
 import java.util.List;
@@ -18,7 +19,10 @@ public static Collection<Attribute> playerAttributesList() {
             return List.of();
         }
         AttributeSupplier attributeSupplier = DefaultAttributes.getSupplier(EntityType.PLAYER);
-        return ForgeRegistries.ATTRIBUTES.getValues().stream().filter(attributeSupplier::hasAttribute).toList();
+        return ForgeRegistries.ATTRIBUTES.getValues().stream()
+                .filter(attribute -> attributeSupplier.hasAttribute(
+                        BuiltInRegistries.ATTRIBUTE.wrapAsHolder(attribute)))
+                .toList();
     }
 
     public static String getName(Attribute attribute) {
diff --git a/src/main/java/daripher/skilltree/block/WorkbenchBlock.java b/src/main/java/daripher/skilltree/block/WorkbenchBlock.java
index 72d8f0ae3..67e47f9f6 100644
--- a/src/main/java/daripher/skilltree/block/WorkbenchBlock.java
+++ b/src/main/java/daripher/skilltree/block/WorkbenchBlock.java
@@ -5,10 +5,12 @@
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResult;
+import net.minecraft.world.ItemInteractionResult;
 import net.minecraft.world.MenuProvider;
 import net.minecraft.world.SimpleMenuProvider;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.inventory.ContainerLevelAccess;
+import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.SoundType;
@@ -29,13 +31,34 @@ public WorkbenchBlock() {
 
     @SuppressWarnings("deprecation")
     @Override
-    public @NotNull InteractionResult use(@NotNull BlockState blockState, Level level, @NotNull BlockPos blockPos, @NotNull Player player, @NotNull InteractionHand interactionHand, @NotNull BlockHitResult blockHitResult) {
-        if (level.isClientSide) {
-            return InteractionResult.SUCCESS;
-        } else {
+    protected @NotNull ItemInteractionResult useItemOn(
+            @NotNull ItemStack stack,
+            @NotNull BlockState blockState,
+            Level level,
+            @NotNull BlockPos blockPos,
+            @NotNull Player player,
+            @NotNull InteractionHand interactionHand,
+            @NotNull BlockHitResult blockHitResult) {
+        openWorkbench(blockState, level, blockPos, player);
+        return ItemInteractionResult.sidedSuccess(level.isClientSide);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    protected @NotNull InteractionResult useWithoutItem(
+            @NotNull BlockState blockState,
+            Level level,
+            @NotNull BlockPos blockPos,
+            @NotNull Player player,
+            @NotNull BlockHitResult blockHitResult) {
+        openWorkbench(blockState, level, blockPos, player);
+        return InteractionResult.sidedSuccess(level.isClientSide);
+    }
+
+    private void openWorkbench(
+            BlockState blockState, Level level, BlockPos blockPos, Player player) {
+        if (!level.isClientSide) {
             player.openMenu(blockState.getMenuProvider(level, blockPos));
-            // add custom stat awarded for block usage?
-            return InteractionResult.CONSUME;
         }
     }
 
diff --git a/src/main/java/daripher/skilltree/capability/skill/IPlayerSkills.java b/src/main/java/daripher/skilltree/capability/skill/IPlayerSkills.java
index 26e7fa2c9..9d86c50d7 100644
--- a/src/main/java/daripher/skilltree/capability/skill/IPlayerSkills.java
+++ b/src/main/java/daripher/skilltree/capability/skill/IPlayerSkills.java
@@ -4,10 +4,8 @@
 import net.minecraft.core.NonNullList;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraftforge.common.capabilities.AutoRegisterCapability;
-import net.minecraftforge.common.util.INBTSerializable;
+import net.neoforged.neoforge.common.util.INBTSerializable;
 
-@AutoRegisterCapability
 public interface IPlayerSkills extends INBTSerializable<CompoundTag> {
     NonNullList<PassiveSkill> getPlayerSkills();
 
diff --git a/src/main/java/daripher/skilltree/capability/skill/PlayerSkills.java b/src/main/java/daripher/skilltree/capability/skill/PlayerSkills.java
index b511eba72..2986d1687 100644
--- a/src/main/java/daripher/skilltree/capability/skill/PlayerSkills.java
+++ b/src/main/java/daripher/skilltree/capability/skill/PlayerSkills.java
@@ -2,6 +2,7 @@
 
 import daripher.skilltree.data.reloader.SkillsReloader;
 import daripher.skilltree.skill.PassiveSkill;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.core.NonNullList;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
@@ -77,7 +78,7 @@ public void resetTree(ServerPlayer player) {
     }
 
     @Override
-    public CompoundTag serializeNBT() {
+    public CompoundTag serializeNBT(HolderLookup.Provider provider) {
         CompoundTag tag = new CompoundTag();
         tag.putUUID("TreeVersion", TREE_VERSION);
         tag.putInt("Points", skillPoints);
@@ -89,7 +90,7 @@ public CompoundTag serializeNBT() {
     }
 
     @Override
-    public void deserializeNBT(CompoundTag tag) {
+    public void deserializeNBT(HolderLookup.Provider provider, CompoundTag tag) {
         skills.clear();
         UUID treeVersion = tag.hasUUID("TreeVersion") ? tag.getUUID("TreeVersion") : null;
         skillPoints = tag.getInt("Points");
diff --git a/src/main/java/daripher/skilltree/capability/skill/PlayerSkillsProvider.java b/src/main/java/daripher/skilltree/capability/skill/PlayerSkillsProvider.java
index 371d78477..c01a9351b 100644
--- a/src/main/java/daripher/skilltree/capability/skill/PlayerSkillsProvider.java
+++ b/src/main/java/daripher/skilltree/capability/skill/PlayerSkillsProvider.java
@@ -1,67 +1,42 @@
 package daripher.skilltree.capability.skill;
 
 import daripher.skilltree.SkillTreeMod;
-import daripher.skilltree.network.NetworkDispatcher;
+import daripher.skilltree.init.PSTAttachments;
 import daripher.skilltree.network.message.SyncPlayerSkillsMessage;
 import daripher.skilltree.network.message.SyncServerDataMessage;
 import net.minecraft.ChatFormatting;
-import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.common.capabilities.Capability;
-import net.minecraftforge.common.capabilities.CapabilityManager;
-import net.minecraftforge.common.capabilities.CapabilityToken;
-import net.minecraftforge.common.capabilities.ICapabilitySerializable;
-import net.minecraftforge.common.util.LazyOptional;
-import net.minecraftforge.event.AttachCapabilitiesEvent;
-import net.minecraftforge.event.entity.EntityJoinLevelEvent;
-import net.minecraftforge.event.entity.player.PlayerEvent;
-import net.minecraftforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import net.minecraftforge.network.PacketDistributor;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.neoforge.event.entity.EntityJoinLevelEvent;
+import net.neoforged.neoforge.event.entity.player.PlayerEvent;
+import net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent;
+import net.neoforged.neoforge.network.PacketDistributor;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 @EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
-public class PlayerSkillsProvider implements ICapabilitySerializable<CompoundTag> {
-    private static final ResourceLocation CAPABILITY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "player_skills");
-    private static final Capability<IPlayerSkills> CAPABILITY = CapabilityManager.get(new CapabilityToken<>() {
-    });
-    private final LazyOptional<IPlayerSkills> optionalCapability = LazyOptional.of(PlayerSkills::new);
-
-    @SubscribeEvent
-    public static void attachCapability(AttachCapabilitiesEvent<Entity> event) {
-        if (!(event.getObject() instanceof Player)) {
-            return;
-        }
-        PlayerSkillsProvider provider = new PlayerSkillsProvider();
-        event.addCapability(CAPABILITY_ID, provider);
-    }
-
+public class PlayerSkillsProvider {
     @SubscribeEvent
-    public static void persistThroughDeath(PlayerEvent.Clone event) {
+    public static void copySkills(PlayerEvent.Clone event) {
         if (event.getEntity().level().isClientSide) {
             return;
         }
-        event.getOriginal().reviveCaps();
-        IPlayerSkills originalData = get(event.getOriginal());
-        IPlayerSkills cloneData = get(event.getEntity());
-        cloneData.deserializeNBT(originalData.serializeNBT());
-        event.getOriginal().invalidateCaps();
+        PlayerSkills originalData = get(event.getOriginal());
+        PlayerSkills cloneData = get(event.getEntity());
+        cloneData.deserializeNBT(
+                event.getEntity().level().registryAccess(),
+                originalData.serializeNBT(event.getOriginal().level().registryAccess()));
     }
 
     @SubscribeEvent
-    public static void syncSkills(PlayerLoggedInEvent event) {
+    public static void syncServerData(PlayerLoggedInEvent event) {
         if (event.getEntity().level().isClientSide) {
             return;
         }
-        NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) event.getEntity()), new SyncServerDataMessage());
+        sendServerData((ServerPlayer) event.getEntity());
     }
 
     @SubscribeEvent(priority = EventPriority.LOWEST)
@@ -74,47 +49,38 @@ public static void restoreSkillsAttributeModifiers(EntityJoinLevelEvent event) {
 
     @SubscribeEvent
     public static void sendTreeResetMessage(EntityJoinLevelEvent event) {
-        if (!(event.getEntity() instanceof Player player)) {
-            return;
-        }
-        if (event.getEntity().level().isClientSide) {
+        if (!(event.getEntity() instanceof Player player) || player.level().isClientSide) {
             return;
         }
         IPlayerSkills capability = get(player);
         if (capability.isTreeReset()) {
-            player.sendSystemMessage(Component.translatable("skilltree.message.reset").withStyle(ChatFormatting.YELLOW));
+            player.sendSystemMessage(
+                    Component.translatable("skilltree.message.reset")
+                            .withStyle(ChatFormatting.YELLOW));
             capability.setTreeReset(false);
         }
     }
 
     @SubscribeEvent
     public static void syncPlayerSkills(EntityJoinLevelEvent event) {
-        if (!(event.getEntity() instanceof ServerPlayer player)) {
-            return;
+        if (event.getEntity() instanceof ServerPlayer player) {
+            sendPlayerSkills(player);
         }
-        NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> player), new SyncPlayerSkillsMessage(player));
     }
 
-    public static @NotNull IPlayerSkills get(Player player) {
-        return player.getCapability(CAPABILITY).orElseThrow(NullPointerException::new);
+    public static void sendServerData(ServerPlayer player) {
+        PacketDistributor.sendToPlayer(player, new SyncServerDataMessage());
     }
 
-    public static boolean hasSkills(@NotNull Player player) {
-        return player.getCapability(CAPABILITY).isPresent();
+    public static void sendPlayerSkills(ServerPlayer player) {
+        PacketDistributor.sendToPlayer(player, new SyncPlayerSkillsMessage(player));
     }
 
-    @Override
-    public <T> @NotNull LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
-        return cap == CAPABILITY ? optionalCapability.cast() : LazyOptional.empty();
+    public static @NotNull PlayerSkills get(Player player) {
+        return player.getData(PSTAttachments.PLAYER_SKILLS.get());
     }
 
-    @Override
-    public CompoundTag serializeNBT() {
-        return optionalCapability.orElseThrow(NullPointerException::new).serializeNBT();
-    }
-
-    @Override
-    public void deserializeNBT(CompoundTag compoundTag) {
-        optionalCapability.orElseThrow(NullPointerException::new).deserializeNBT(compoundTag);
+    public static boolean hasSkills(@NotNull Player player) {
+        return player.hasData(PSTAttachments.PLAYER_SKILLS.get());
     }
 }
diff --git a/src/main/java/daripher/skilltree/client/event/PoisonedWeaponClientEvents.java b/src/main/java/daripher/skilltree/client/event/PoisonedWeaponClientEvents.java
index efc4221f4..0fc8ae7e7 100644
--- a/src/main/java/daripher/skilltree/client/event/PoisonedWeaponClientEvents.java
+++ b/src/main/java/daripher/skilltree/client/event/PoisonedWeaponClientEvents.java
@@ -9,15 +9,15 @@
 import net.minecraft.network.chat.Style;
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.event.entity.player.ItemTooltipEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.neoforge.event.entity.player.ItemTooltipEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID, value = Dist.CLIENT)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID, value = Dist.CLIENT)
 public class PoisonedWeaponClientEvents {
     @SubscribeEvent
     public static void addPoisonedWeaponTooltip(ItemTooltipEvent event) {
@@ -42,7 +42,7 @@ private static void addEffectTooltip(List<Component> tooltip, MobEffectInstance
         Style style = TooltipHelper.getSkillBonusStyle(true);
         Component effectNameTooltip = TooltipHelper.getEffectTooltip(mobEffectInstance);
         MutableComponent effectTooltip;
-        if (!mobEffectInstance.getEffect().isInstantenous()) {
+        if (!mobEffectInstance.getEffect().value().isInstantenous()) {
             int duration = mobEffectInstance.getDuration();
             Component durationTooltip = getDurationTooltip(duration);
             effectTooltip = Component.translatable("skilltree.poisoned_weapon.effect", effectNameTooltip, durationTooltip);
diff --git a/src/main/java/daripher/skilltree/client/network/ClientNetworkPayloadHandlers.java b/src/main/java/daripher/skilltree/client/network/ClientNetworkPayloadHandlers.java
new file mode 100644
index 000000000..6cff7b0fc
--- /dev/null
+++ b/src/main/java/daripher/skilltree/client/network/ClientNetworkPayloadHandlers.java
@@ -0,0 +1,14 @@
+package daripher.skilltree.client.network;
+
+import daripher.skilltree.client.screen.SkillTreeScreen;
+import net.minecraft.client.Minecraft;
+
+public class ClientNetworkPayloadHandlers {
+  public static void refreshSkillTreeScreen(int skillPoints) {
+    Minecraft minecraft = Minecraft.getInstance();
+    if (minecraft.screen instanceof SkillTreeScreen screen) {
+      screen.updateSkillPoints(skillPoints);
+      screen.init();
+    }
+  }
+}
diff --git a/src/main/java/daripher/skilltree/client/screen/SkillTreeEditorScreen.java b/src/main/java/daripher/skilltree/client/screen/SkillTreeEditorScreen.java
index 316a571e1..188b694c1 100644
--- a/src/main/java/daripher/skilltree/client/screen/SkillTreeEditorScreen.java
+++ b/src/main/java/daripher/skilltree/client/screen/SkillTreeEditorScreen.java
@@ -12,7 +12,7 @@
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.client.gui.screens.achievement.StatsUpdateListener;
+import daripher.skilltree.client.screen.StatsUpdateListener;
 import net.minecraft.client.multiplayer.ClientPacketListener;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.protocol.game.ServerboundClientCommandPacket;
@@ -89,7 +89,7 @@ private void calculateMaxScroll() {
 
     @Override
     public void render(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
-        renderBackground(graphics);
+        renderBackground(graphics, mouseX, mouseY, partialTick);
         skillButtons.render(graphics, mouseX, mouseY, partialTick);
         renderOverlay(graphics);
         editorWidgets.render(graphics, mouseX, mouseY, partialTick);
@@ -137,7 +137,8 @@ private void renderOverlay(GuiGraphics graphics) {
     }
 
     @Override
-    public void renderBackground(GuiGraphics graphics) {
+    public void renderBackground(
+            GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         ResourceLocation texture = ResourceLocation.parse("skilltree:textures/screen/skill_tree_background.png");
         PoseStack poseStack = graphics.pose();
         poseStack.pushPose();
@@ -158,8 +159,10 @@ public boolean mouseReleased(double mouseX, double mouseY, int button) {
     }
 
     @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
-        return editorWidgets.mouseScrolled(mouseX, mouseY, amount) || skillButtons.mouseScrolled(mouseX, mouseY, amount);
+    public boolean mouseScrolled(
+            double mouseX, double mouseY, double scrollX, double scrollY) {
+        return editorWidgets.mouseScrolled(mouseX, mouseY, scrollX, scrollY)
+                || skillButtons.mouseScrolled(mouseX, mouseY, scrollX, scrollY);
     }
 
     @Override
diff --git a/src/main/java/daripher/skilltree/client/screen/SkillTreeScreen.java b/src/main/java/daripher/skilltree/client/screen/SkillTreeScreen.java
index f15c6e6f3..87928c943 100644
--- a/src/main/java/daripher/skilltree/client/screen/SkillTreeScreen.java
+++ b/src/main/java/daripher/skilltree/client/screen/SkillTreeScreen.java
@@ -12,7 +12,7 @@
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.client.gui.screens.achievement.StatsUpdateListener;
+import daripher.skilltree.client.screen.StatsUpdateListener;
 import net.minecraft.client.multiplayer.ClientPacketListener;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.network.chat.Component;
@@ -94,7 +94,7 @@ private void calculateMaxScroll() {
     @Override
     public void render(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         renderAnimation += partialTick;
-        renderBackground(graphics);
+        renderBackground(graphics, mouseX, mouseY, partialTick);
         skillButtons.render(graphics, mouseX, mouseY, partialTick);
         renderOverlay(graphics);
         skillTreeWidgets.render(graphics, mouseX, mouseY, partialTick);
@@ -152,7 +152,8 @@ private void renderOverlay(GuiGraphics graphics) {
     }
 
     @Override
-    public void renderBackground(GuiGraphics graphics) {
+    public void renderBackground(
+            GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         ResourceLocation texture = ResourceLocation.parse("skilltree:textures/screen/skill_tree_background.png");
         PoseStack poseStack = graphics.pose();
         poseStack.pushPose();
@@ -174,8 +175,9 @@ public boolean mouseDragged(double mouseX, double mouseY, int mouseButton, doubl
     }
 
     @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
-        return skillButtons.mouseScrolled(mouseX, mouseY, amount);
+    public boolean mouseScrolled(
+            double mouseX, double mouseY, double scrollX, double scrollY) {
+        return skillButtons.mouseScrolled(mouseX, mouseY, scrollX, scrollY);
     }
 
     private @Nonnull LocalPlayer getLocalPlayer() {
diff --git a/src/main/java/daripher/skilltree/client/screen/SkillTreeSelectionScreen.java b/src/main/java/daripher/skilltree/client/screen/SkillTreeSelectionScreen.java
index 70c07d8b3..44f0f3225 100644
--- a/src/main/java/daripher/skilltree/client/screen/SkillTreeSelectionScreen.java
+++ b/src/main/java/daripher/skilltree/client/screen/SkillTreeSelectionScreen.java
@@ -47,7 +47,7 @@ private static List<PassiveSkillTree> getNonEmptySkillTrees() {
 
     @Override
     public void render(@NotNull GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTick) {
-        renderBackground(guiGraphics);
+        renderBackground(guiGraphics, mouseX, mouseY, partialTick);
         super.render(guiGraphics, mouseX, mouseY, partialTick);
         for (Renderable widget : renderables) {
             if (!(widget instanceof SkillTreeSelectionButton button)) {
@@ -61,7 +61,8 @@ public void render(@NotNull GuiGraphics guiGraphics, int mouseX, int mouseY, flo
     }
 
     @Override
-    public void renderBackground(GuiGraphics guiGraphics) {
+    public void renderBackground(
+            GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTick) {
         ResourceLocation texture = ResourceLocation.parse("skilltree:textures/screen/skill_tree_background.png");
         int size = SkillTreeScreen.BACKGROUND_SIZE;
         guiGraphics.blit(texture, (width - size) / 2, (height - size) / 2, 0, 0F, 0F, size, size, size, size);
diff --git a/src/main/java/daripher/skilltree/client/screen/StatsUpdateListener.java b/src/main/java/daripher/skilltree/client/screen/StatsUpdateListener.java
new file mode 100644
index 000000000..89ed6f926
--- /dev/null
+++ b/src/main/java/daripher/skilltree/client/screen/StatsUpdateListener.java
@@ -0,0 +1,5 @@
+package daripher.skilltree.client.screen;
+
+public interface StatsUpdateListener {
+  void onStatsUpdated();
+}
diff --git a/src/main/java/daripher/skilltree/client/screen/menu/WorkbenchScreen.java b/src/main/java/daripher/skilltree/client/screen/menu/WorkbenchScreen.java
index f08af3ee6..3bdf5468b 100644
--- a/src/main/java/daripher/skilltree/client/screen/menu/WorkbenchScreen.java
+++ b/src/main/java/daripher/skilltree/client/screen/menu/WorkbenchScreen.java
@@ -73,7 +73,7 @@ public void resize(@NotNull Minecraft minecraft, int width, int height) {
 
     @Override
     protected void renderBg(@NotNull GuiGraphics guiGraphics, float partialTicks, int mouseX, int mouseY) {
-        renderBackground(guiGraphics);
+        renderBackground(guiGraphics, mouseX, mouseY, partialTicks);
         guiGraphics.blit(BACKGROUND_TEXTURE, leftPos, topPos, 0, 0, imageWidth, imageHeight);
         renderScroll(guiGraphics);
         renderRecipes(guiGraphics, mouseX, mouseY);
@@ -299,7 +299,6 @@ protected void renderLabels(@NotNull GuiGraphics guiGraphics, int mouseX, int mo
     @Override
     protected void containerTick() {
         super.containerTick();
-        searchBox.tick();
     }
 
     @Override
@@ -356,11 +355,12 @@ public boolean mouseClicked(double mouseX, double mouseY, int button) {
     }
 
     @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double delta) {
+    public boolean mouseScrolled(
+            double mouseX, double mouseY, double scrollX, double scrollY) {
         if (isScrollBarActive()) {
-            amountScrolled = (int) Mth.clamp(amountScrolled - delta, 0, getMaxScroll());
+            amountScrolled = (int) Mth.clamp(amountScrolled - scrollY, 0, getMaxScroll());
         }
-        return super.mouseScrolled(mouseX, mouseY, delta);
+        return super.mouseScrolled(mouseX, mouseY, scrollX, scrollY);
     }
 
     private Pair<AbstractWorkbenchRecipe, Integer> getRecipeInSlot(int slot) {
diff --git a/src/main/java/daripher/skilltree/client/tooltip/TooltipHelper.java b/src/main/java/daripher/skilltree/client/tooltip/TooltipHelper.java
index 08922012c..2e9e0e48d 100644
--- a/src/main/java/daripher/skilltree/client/tooltip/TooltipHelper.java
+++ b/src/main/java/daripher/skilltree/client/tooltip/TooltipHelper.java
@@ -17,6 +17,7 @@
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.component.ItemAttributeModifiers;
 import net.minecraft.world.item.crafting.RecipeManager;
 import org.jetbrains.annotations.NotNull;
 
@@ -42,10 +43,10 @@ public class TooltipHelper {
 
     public static Component getEffectTooltip(MobEffectInstance effect) {
         Component effectDescription;
-        if (effect.getEffect() instanceof SkillBonusEffect skillEffect) {
+        if (effect.getEffect().value() instanceof SkillBonusEffect skillEffect) {
             effectDescription = skillEffect.getBonus().copy().multiply(effect.getAmplifier() + 1).getSimpleTooltip().setStyle(Style.EMPTY);
         } else {
-            effectDescription = effect.getEffect().getDisplayName();
+            effectDescription = effect.getEffect().value().getDisplayName();
             if (effect.getAmplifier() == 0) {
                 return effectDescription;
             }
@@ -57,9 +58,9 @@ public static Component getEffectTooltip(MobEffectInstance effect) {
 
     public static Component getOperationName(AttributeModifier.Operation operation) {
         return Component.literal(switch (operation) {
-            case ADDITION -> "Addition";
-            case MULTIPLY_BASE -> "Multiply Base";
-            case MULTIPLY_TOTAL -> "Multiply Total";
+            case ADD_VALUE -> "Addition";
+            case ADD_MULTIPLIED_BASE -> "Multiply Base";
+            case ADD_MULTIPLIED_TOTAL -> "Multiply Total";
         });
     }
 
@@ -81,7 +82,7 @@ public static void consumeTranslated(String descriptionId, Consumer<MutableCompo
 
     public static MutableComponent getSkillBonusTooltip(Component bonusDescription, double amount, AttributeModifier.Operation operation) {
         float multiplier = 1;
-        if (operation != AttributeModifier.Operation.ADDITION) {
+        if (operation != AttributeModifier.Operation.ADD_VALUE) {
             multiplier = 100;
         }
         double visibleAmount = amount * multiplier;
@@ -95,7 +96,7 @@ public static MutableComponent getSkillBonusTooltip(Component bonusDescription,
     }
 
     public static String formatNumber(double number) {
-        String formatted = ItemStack.ATTRIBUTE_MODIFIER_FORMAT.format(number);
+        String formatted = ItemAttributeModifiers.ATTRIBUTE_MODIFIER_FORMAT.format(number);
         if (formatted.endsWith(".0")) {
             formatted = formatted.substring(0, formatted.length() - 2);
         }
@@ -245,8 +246,12 @@ public static Component getRecipeTooltip(ResourceLocation recipeId) {
         ClientLevel level = Minecraft.getInstance().level;
         Objects.requireNonNull(level);
         RecipeManager recipeManager = level.getRecipeManager();
-        List<AbstractWorkbenchRecipe> recipes = recipeManager.getAllRecipesFor(PSTRecipeTypes.WORKBENCH);
-        AbstractWorkbenchRecipe recipe = recipes.stream().filter(r -> r.getId().equals(recipeId)).findAny().orElse(null);
+        AbstractWorkbenchRecipe recipe = recipeManager
+                .getAllRecipesFor(PSTRecipeTypes.WORKBENCH.get()).stream()
+                .filter(holder -> holder.id().equals(recipeId))
+                .map(holder -> (AbstractWorkbenchRecipe) holder.value())
+                .findAny()
+                .orElse(null);
         if (recipe == null) {
             return Component.literal("Unknown Recipe: " + recipeId.toString()).withStyle(ChatFormatting.RED);
         }
@@ -257,8 +262,12 @@ public static String getRecipeDescriptionId(ResourceLocation recipeId) {
         ClientLevel level = Minecraft.getInstance().level;
         Objects.requireNonNull(level);
         RecipeManager recipeManager = level.getRecipeManager();
-        List<AbstractWorkbenchRecipe> recipes = recipeManager.getAllRecipesFor(PSTRecipeTypes.WORKBENCH);
-        AbstractWorkbenchRecipe recipe = recipes.stream().filter(r -> r.getId().equals(recipeId)).findAny().orElse(null);
+        AbstractWorkbenchRecipe recipe = recipeManager
+                .getAllRecipesFor(PSTRecipeTypes.WORKBENCH.get()).stream()
+                .filter(holder -> holder.id().equals(recipeId))
+                .map(holder -> (AbstractWorkbenchRecipe) holder.value())
+                .findAny()
+                .orElse(null);
         if (recipe == null) {
             return "Unknown Recipe: " + recipeId.toString();
         }
diff --git a/src/main/java/daripher/skilltree/client/widget/ScrollableComponentList.java b/src/main/java/daripher/skilltree/client/widget/ScrollableComponentList.java
index b0432ca18..ad5f10f43 100644
--- a/src/main/java/daripher/skilltree/client/widget/ScrollableComponentList.java
+++ b/src/main/java/daripher/skilltree/client/widget/ScrollableComponentList.java
@@ -59,12 +59,13 @@ private void renderScrollBar(@NotNull GuiGraphics graphics) {
     }
 
     @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+    public boolean mouseScrolled(
+            double mouseX, double mouseY, double scrollX, double scrollY) {
         int maxScroll = components.size() - maxLines;
-        if (amount < 0 && scroll < maxScroll) {
+        if (scrollY < 0 && scroll < maxScroll) {
             scroll++;
         }
-        if (amount > 0 && scroll > 0) {
+        if (scrollY > 0 && scroll > 0) {
             scroll--;
         }
         return true;
diff --git a/src/main/java/daripher/skilltree/client/widget/SkillTreeWidgets.java b/src/main/java/daripher/skilltree/client/widget/SkillTreeWidgets.java
index cb82440d5..a88e58b5e 100644
--- a/src/main/java/daripher/skilltree/client/widget/SkillTreeWidgets.java
+++ b/src/main/java/daripher/skilltree/client/widget/SkillTreeWidgets.java
@@ -11,7 +11,6 @@
 import daripher.skilltree.config.ServerConfig;
 import daripher.skilltree.data.reloader.SkillsReloader;
 import daripher.skilltree.exp.ExpHelper;
-import daripher.skilltree.network.NetworkDispatcher;
 import daripher.skilltree.network.message.GainSkillPointMessage;
 import daripher.skilltree.network.message.LearnSkillMessage;
 import daripher.skilltree.skill.PassiveSkill;
@@ -30,6 +29,7 @@
 import net.minecraft.network.chat.Style;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.sounds.SoundEvents;
+import net.neoforged.neoforge.network.PacketDistributor;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
@@ -266,7 +266,7 @@ private void buySkillPoint() {
             return;
         }
         int cost = ServerConfig.getSkillPointCost(currentLevel);
-        NetworkDispatcher.network_channel.sendToServer(new GainSkillPointMessage());
+        PacketDistributor.sendToServer(new GainSkillPointMessage());
         player.giveExperiencePoints(-cost);
     }
 
@@ -312,7 +312,7 @@ protected void skillButtonPressed(SkillButton button) {
 
     protected void learnSkill(PassiveSkill skill) {
         learnedSkills.add(skill.getId());
-        NetworkDispatcher.network_channel.sendToServer(new LearnSkillMessage(skill));
+        PacketDistributor.sendToServer(new LearnSkillMessage(skill));
         rebuildWidgets();
     }
 
diff --git a/src/main/java/daripher/skilltree/client/widget/TextArea.java b/src/main/java/daripher/skilltree/client/widget/TextArea.java
index 725ec84cd..bdbe6d0a0 100644
--- a/src/main/java/daripher/skilltree/client/widget/TextArea.java
+++ b/src/main/java/daripher/skilltree/client/widget/TextArea.java
@@ -19,8 +19,9 @@ public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
     }
 
     @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double delta) {
-        return isFocused() && super.mouseScrolled(mouseX, mouseY, delta);
+    public boolean mouseScrolled(
+            double mouseX, double mouseY, double scrollX, double scrollY) {
+        return isFocused() && super.mouseScrolled(mouseX, mouseY, scrollX, scrollY);
     }
 
     @Override
@@ -36,6 +37,5 @@ public TextArea setResponder(@NotNull Consumer<String> responder) {
 
     @Override
     public void onWidgetTick() {
-        this.tick();
     }
 }
diff --git a/src/main/java/daripher/skilltree/client/widget/TextField.java b/src/main/java/daripher/skilltree/client/widget/TextField.java
index cc526857e..67e34841c 100644
--- a/src/main/java/daripher/skilltree/client/widget/TextField.java
+++ b/src/main/java/daripher/skilltree/client/widget/TextField.java
@@ -90,7 +90,7 @@ public void renderWidget(@NotNull GuiGraphics graphics, int mouseX, int mouseY,
         Font font = minecraft.font;
         String visibleText = font.plainSubstrByWidth(getValue().substring(accessor.getDisplayPos()), getInnerWidth());
         boolean isTextSplitByCursor = cursorVisiblePosition >= 0 && cursorVisiblePosition <= visibleText.length();
-        boolean isCursorVisible = isFocused() && accessor.getFrame() / 6 % 2 == 0 && isTextSplitByCursor;
+        boolean isCursorVisible = isFocused() && minecraft.gui.getGuiTicks() / 6 % 2 == 0 && isTextSplitByCursor;
         if (visibleText.isEmpty() && hint != null && !isFocused()) {
             visibleText = hint;
         }
@@ -153,7 +153,6 @@ public boolean mouseClicked(double mouseX, double mouseY, int button) {
 
     @Override
     public void onWidgetTick() {
-        this.tick();
     }
 
     public TextField setFocused() {
diff --git a/src/main/java/daripher/skilltree/client/widget/editor/SkillTreeEditor.java b/src/main/java/daripher/skilltree/client/widget/editor/SkillTreeEditor.java
index c215ef0ff..3bc056907 100644
--- a/src/main/java/daripher/skilltree/client/widget/editor/SkillTreeEditor.java
+++ b/src/main/java/daripher/skilltree/client/widget/editor/SkillTreeEditor.java
@@ -41,7 +41,7 @@
 import net.minecraft.world.effect.MobEffect;
 import net.minecraft.world.entity.ai.attributes.Attribute;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
-import net.minecraftforge.registries.ForgeRegistries;
+import daripher.skilltree.util.ForgeRegistries;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.lwjgl.glfw.GLFW;
@@ -77,13 +77,13 @@ public void init() {
     }
 
     @Override
-    public void render(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+    protected void renderWidget(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         skillMirrorer.render(graphics, mouseX, mouseY, partialTick);
         skillDragger.render(graphics, mouseX, mouseY, partialTick);
         if (height > 0) {
             graphics.fill(getX(), getY(), getX() + width, getY() + height, 0xDD000000);
         }
-        super.render(graphics, mouseX, mouseY, partialTick);
+        super.renderWidget(graphics, mouseX, mouseY, partialTick);
     }
 
     @Override
diff --git a/src/main/java/daripher/skilltree/client/widget/editor/menu/selection/SelectionList.java b/src/main/java/daripher/skilltree/client/widget/editor/menu/selection/SelectionList.java
index 5e969546c..9a30278d6 100644
--- a/src/main/java/daripher/skilltree/client/widget/editor/menu/selection/SelectionList.java
+++ b/src/main/java/daripher/skilltree/client/widget/editor/menu/selection/SelectionList.java
@@ -152,9 +152,10 @@ public void mouseMoved(double mouseX, double mouseY) {
     }
 
     @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double delta) {
+    public boolean mouseScrolled(
+            double mouseX, double mouseY, double scrollX, double scrollY) {
         if (isMouseOver(mouseX, mouseY)) {
-            setScroll(scroll - Mth.sign(delta));
+            setScroll(scroll - Mth.sign(scrollY));
             return true;
         }
         return false;
diff --git a/src/main/java/daripher/skilltree/client/widget/group/ScrollableZoomableWidgetGroup.java b/src/main/java/daripher/skilltree/client/widget/group/ScrollableZoomableWidgetGroup.java
index 36bbd2a43..51b9fb908 100644
--- a/src/main/java/daripher/skilltree/client/widget/group/ScrollableZoomableWidgetGroup.java
+++ b/src/main/java/daripher/skilltree/client/widget/group/ScrollableZoomableWidgetGroup.java
@@ -58,13 +58,14 @@ public boolean mouseDragged(double mouseX, double mouseY, int button, double dra
     }
 
     @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double delta) {
-        if (delta > 0 && zoom < 2F) {
+    public boolean mouseScrolled(
+            double mouseX, double mouseY, double scrollX, double scrollY) {
+        if (scrollY > 0 && zoom < 2F) {
             zoom += 0.05f;
             scrollX *= 1.05f;
             scrollY *= 1.05f;
         }
-        if (delta < 0 && zoom > 0.25F) {
+        if (scrollY < 0 && zoom > 0.25F) {
             zoom -= 0.05f;
             scrollX *= 0.95f;
             scrollY *= 0.95f;
diff --git a/src/main/java/daripher/skilltree/client/widget/group/WidgetGroup.java b/src/main/java/daripher/skilltree/client/widget/group/WidgetGroup.java
index ba6cb1d2e..be5805ee7 100644
--- a/src/main/java/daripher/skilltree/client/widget/group/WidgetGroup.java
+++ b/src/main/java/daripher/skilltree/client/widget/group/WidgetGroup.java
@@ -89,10 +89,11 @@ public boolean mouseReleased(double mouseX, double mouseY, int button) {
     }
 
     @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double delta) {
+    public boolean mouseScrolled(
+            double mouseX, double mouseY, double scrollX, double scrollY) {
         boolean result = false;
         for (T widget : widgetsCopy()) {
-            if (widget.mouseScrolled(mouseX, mouseY, delta)) {
+            if (widget.mouseScrolled(mouseX, mouseY, scrollX, scrollY)) {
                 result = true;
             }
         }
diff --git a/src/main/java/daripher/skilltree/command/PSTCommands.java b/src/main/java/daripher/skilltree/command/PSTCommands.java
index 20841e912..db7905273 100644
--- a/src/main/java/daripher/skilltree/command/PSTCommands.java
+++ b/src/main/java/daripher/skilltree/command/PSTCommands.java
@@ -12,8 +12,6 @@
 import daripher.skilltree.client.tooltip.TooltipHelper;
 import daripher.skilltree.data.reloader.SkillTreesReloader;
 import daripher.skilltree.data.reloader.SkillsReloader;
-import daripher.skilltree.network.NetworkDispatcher;
-import daripher.skilltree.network.message.SyncPlayerSkillsMessage;
 import net.minecraft.ChatFormatting;
 import net.minecraft.commands.CommandSourceStack;
 import net.minecraft.commands.Commands;
@@ -24,10 +22,9 @@
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraftforge.event.RegisterCommandsEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import net.minecraftforge.network.PacketDistributor;
+import net.neoforged.neoforge.event.RegisterCommandsEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.stream.Stream;
@@ -95,7 +92,7 @@ private static int executeResetCommand(CommandContext<CommandSourceStack> ctx) t
         IPlayerSkills skillsCapability = PlayerSkillsProvider.get(player);
         skillsCapability.resetTree(player);
         player.sendSystemMessage(Component.translatable("skilltree.message.reset_command").withStyle(ChatFormatting.YELLOW));
-        NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> player), new SyncPlayerSkillsMessage(player));
+        PlayerSkillsProvider.sendPlayerSkills(player);
         return 1;
     }
 
@@ -105,7 +102,7 @@ private static int executeAddPointsCommand(CommandContext<CommandSourceStack> ct
         IPlayerSkills skillsCapability = PlayerSkillsProvider.get(player);
         skillsCapability.setSkillPoints(amount + skillsCapability.getSkillPoints());
         player.sendSystemMessage(Component.translatable("skilltree.message.point_command").withStyle(ChatFormatting.YELLOW));
-        NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> player), new SyncPlayerSkillsMessage(player));
+        PlayerSkillsProvider.sendPlayerSkills(player);
         return 1;
     }
 
@@ -114,7 +111,7 @@ private static int executeSetPointsCommand(CommandContext<CommandSourceStack> ct
         int amount = IntegerArgumentType.getInteger(ctx, AMOUNT_ARGUMENT_NAME);
         IPlayerSkills skillsCapability = PlayerSkillsProvider.get(player);
         skillsCapability.setSkillPoints(amount);
-        NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> player), new SyncPlayerSkillsMessage(player));
+        PlayerSkillsProvider.sendPlayerSkills(player);
         return 1;
     }
 
@@ -123,7 +120,7 @@ private static int executeGrantSkillCommand(CommandContext<CommandSourceStack> c
         ResourceLocation skillId = ctx.getArgument(SKILL_ID_ARGUMENT_NAME, ResourceLocation.class);
         IPlayerSkills skillsCapability = PlayerSkillsProvider.get(player);
         if (skillsCapability.grantSkill(SkillsReloader.getSkillById(skillId))) {
-            NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> player), new SyncPlayerSkillsMessage(player));
+            PlayerSkillsProvider.sendPlayerSkills(player);
             Component skillName = TooltipHelper.getSkillTitle(skillId);
             player.sendSystemMessage(Component.translatable("skilltree.message.grant_skill_command", skillName)
                     .withStyle(ChatFormatting.YELLOW));
diff --git a/src/main/java/daripher/skilltree/command/client/PSTClientCommands.java b/src/main/java/daripher/skilltree/command/client/PSTClientCommands.java
index ec873cc8e..5fa859fbb 100644
--- a/src/main/java/daripher/skilltree/command/client/PSTClientCommands.java
+++ b/src/main/java/daripher/skilltree/command/client/PSTClientCommands.java
@@ -13,11 +13,11 @@
 import net.minecraft.commands.Commands;
 import net.minecraft.commands.SharedSuggestionProvider;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.RegisterClientCommandsEvent;
-import net.minecraftforge.event.TickEvent.ClientTickEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.neoforge.client.event.RegisterClientCommandsEvent;
+import net.neoforged.neoforge.client.event.ClientTickEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Locale;
@@ -39,7 +39,7 @@ public static void registerCommands(RegisterClientCommandsEvent event) {
     }
 
     @SubscribeEvent
-    public static void delayedCommandExecution(ClientTickEvent event) {
+    public static void delayedCommandExecution(ClientTickEvent.Post event) {
         if (timer > 0) {
             timer--;
             return;
diff --git a/src/main/java/daripher/skilltree/compat/attributeslib/AttributesLibCompatibility.java b/src/main/java/daripher/skilltree/compat/attributeslib/AttributesLibCompatibility.java
index d2254a8b0..d92802c3c 100644
--- a/src/main/java/daripher/skilltree/compat/attributeslib/AttributesLibCompatibility.java
+++ b/src/main/java/daripher/skilltree/compat/attributeslib/AttributesLibCompatibility.java
@@ -1,7 +1,7 @@
 package daripher.skilltree.compat.attributeslib;
 
 import daripher.skilltree.skill.PassiveSkill;
-import dev.shadowsoffire.attributeslib.client.ModifierSourceType;
+import dev.shadowsoffire.apothic_attributes.client.ModifierSourceType;
 
 public enum AttributesLibCompatibility {
     INSTANCE;
diff --git a/src/main/java/daripher/skilltree/compat/attributeslib/SkillModifierSource.java b/src/main/java/daripher/skilltree/compat/attributeslib/SkillModifierSource.java
index 1a8cf532c..0f226dedc 100644
--- a/src/main/java/daripher/skilltree/compat/attributeslib/SkillModifierSource.java
+++ b/src/main/java/daripher/skilltree/compat/attributeslib/SkillModifierSource.java
@@ -2,7 +2,7 @@
 
 import com.mojang.blaze3d.vertex.PoseStack;
 import daripher.skilltree.skill.PassiveSkill;
-import dev.shadowsoffire.attributeslib.client.ModifierSource;
+import dev.shadowsoffire.apothic_attributes.client.ModifierSource;
 import net.minecraft.client.gui.Font;
 import net.minecraft.client.gui.GuiGraphics;
 
diff --git a/src/main/java/daripher/skilltree/compat/attributeslib/SkillModifierSourceType.java b/src/main/java/daripher/skilltree/compat/attributeslib/SkillModifierSourceType.java
index 8ba02e189..1572210fc 100644
--- a/src/main/java/daripher/skilltree/compat/attributeslib/SkillModifierSourceType.java
+++ b/src/main/java/daripher/skilltree/compat/attributeslib/SkillModifierSourceType.java
@@ -3,8 +3,8 @@
 import daripher.skilltree.capability.skill.PlayerSkillsProvider;
 import daripher.skilltree.skill.PassiveSkill;
 import daripher.skilltree.skill.bonus.player.AttributeBonus;
-import dev.shadowsoffire.attributeslib.client.ModifierSource;
-import dev.shadowsoffire.attributeslib.client.ModifierSourceType;
+import dev.shadowsoffire.apothic_attributes.client.ModifierSource;
+import dev.shadowsoffire.apothic_attributes.client.ModifierSourceType;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import net.minecraft.world.entity.player.Player;
diff --git a/src/main/java/daripher/skilltree/compat/curios/CuriosCompatibility.java b/src/main/java/daripher/skilltree/compat/curios/CuriosCompatibility.java
index f69f81af5..e8c6d590d 100644
--- a/src/main/java/daripher/skilltree/compat/curios/CuriosCompatibility.java
+++ b/src/main/java/daripher/skilltree/compat/curios/CuriosCompatibility.java
@@ -8,11 +8,11 @@
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.eventbus.api.Event;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.common.NeoForge;
+import net.neoforged.neoforge.common.util.TriState;
+import net.neoforged.neoforge.registries.DeferredHolder;
 import top.theillusivec4.curios.api.CuriosApi;
-import top.theillusivec4.curios.api.event.CurioEquipEvent;
+import top.theillusivec4.curios.api.event.CurioCanEquipEvent;
 import top.theillusivec4.curios.api.type.capability.ICuriosItemHandler;
 
 import java.util.ArrayList;
@@ -22,10 +22,10 @@
 public enum CuriosCompatibility {
     INSTANCE;
 
-    public static final RegistryObject<SkillBonus.Serializer> CURIO_SLOTS_BONUS = PSTSkillBonuses.REGISTRY.register("curio_slots", CurioSlotsBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> CURIO_SLOTS_BONUS = PSTSkillBonuses.REGISTRY.register("curio_slots", CurioSlotsBonus.Serializer::new);
 
     public void register() {
-        MinecraftForge.EVENT_BUS.addListener(INSTANCE::applyCantUseItemBonus);
+        NeoForge.EVENT_BUS.addListener(INSTANCE::applyCantUseItemBonus);
     }
 
     public Stream<ItemStack> getCurios(LivingEntity living) {
@@ -39,13 +39,13 @@ public Stream<ItemStack> getCurios(LivingEntity living) {
     }
 
 
-    private void applyCantUseItemBonus(CurioEquipEvent event) {
+    private void applyCantUseItemBonus(CurioCanEquipEvent event) {
         if (!(event.getEntity() instanceof Player player)) {
             return;
         }
         for (PreventItemUsageBonus bonus : SkillBonusProvider.getSkillBonuses(player, PreventItemUsageBonus.class)) {
             if (bonus.getItemCondition().test(event.getStack())) {
-                event.setResult(Event.Result.DENY);
+                event.setEquipResult(TriState.FALSE);
                 return;
             }
         }
diff --git a/src/main/java/daripher/skilltree/compat/curios/skill/bonus/CurioSlotsBonus.java b/src/main/java/daripher/skilltree/compat/curios/skill/bonus/CurioSlotsBonus.java
index bd3604f27..f5538d4e7 100644
--- a/src/main/java/daripher/skilltree/compat/curios/skill/bonus/CurioSlotsBonus.java
+++ b/src/main/java/daripher/skilltree/compat/curios/skill/bonus/CurioSlotsBonus.java
@@ -3,6 +3,7 @@
 import com.google.common.collect.HashMultimap;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParseException;
+import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.client.tooltip.TooltipHelper;
 import daripher.skilltree.client.widget.editor.SkillTreeEditor;
 import daripher.skilltree.compat.curios.CuriosCompatibility;
@@ -13,6 +14,7 @@
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import top.theillusivec4.curios.api.CuriosApi;
@@ -42,7 +44,8 @@ public void onSkillLearned(ServerPlayer player, boolean firstTime) {
         if (firstTime) {
             CuriosApi.getCuriosInventory(player).ifPresent(inv -> {
                 HashMultimap<String, AttributeModifier> modifiers = HashMultimap.create();
-                AttributeModifier modifier = new AttributeModifier(modifierId, "SkillBonus", amount, AttributeModifier.Operation.ADDITION);
+                AttributeModifier modifier = new AttributeModifier(
+                        getModifierId(), amount, AttributeModifier.Operation.ADD_VALUE);
                 modifiers.put(slotName, modifier);
                 inv.addPermanentSlotModifiers(modifiers);
             });
@@ -53,7 +56,8 @@ public void onSkillLearned(ServerPlayer player, boolean firstTime) {
     public void onSkillRemoved(ServerPlayer player) {
         CuriosApi.getCuriosInventory(player).ifPresent(inv -> {
             HashMultimap<String, AttributeModifier> modifiers = HashMultimap.create();
-            AttributeModifier modifier = new AttributeModifier(modifierId, "SkillBonus", amount, AttributeModifier.Operation.ADDITION);
+            AttributeModifier modifier = new AttributeModifier(
+                    getModifierId(), amount, AttributeModifier.Operation.ADD_VALUE);
             modifiers.put(slotName, modifier);
             inv.removeSlotModifiers(modifiers);
         });
@@ -64,6 +68,11 @@ public SkillBonus.Serializer getSerializer() {
         return CuriosCompatibility.CURIO_SLOTS_BONUS.get();
     }
 
+    private ResourceLocation getModifierId() {
+        return ResourceLocation.fromNamespaceAndPath(
+                SkillTreeMod.MOD_ID, "curio_slots/" + modifierId);
+    }
+
     @Override
     public CurioSlotsBonus copy() {
         return new CurioSlotsBonus(slotName, amount, modifierId);
@@ -92,7 +101,8 @@ public MutableComponent getSimpleTooltip() {
         } else {
             slotDescription = TooltipHelper.getSlotTooltip(slotName);
         }
-        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(slotDescription, amount, AttributeModifier.Operation.ADDITION);
+        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(
+                slotDescription, amount, AttributeModifier.Operation.ADD_VALUE);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
     }
 
diff --git a/src/main/java/daripher/skilltree/compat/ironsspellbooks/IronsSpellbooksCompat.java b/src/main/java/daripher/skilltree/compat/ironsspellbooks/IronsSpellbooksCompat.java
index 8c505e332..2dcc692e2 100644
--- a/src/main/java/daripher/skilltree/compat/ironsspellbooks/IronsSpellbooksCompat.java
+++ b/src/main/java/daripher/skilltree/compat/ironsspellbooks/IronsSpellbooksCompat.java
@@ -11,8 +11,8 @@
 import io.redspace.ironsspellbooks.api.events.ModifySpellLevelEvent;
 import io.redspace.ironsspellbooks.api.magic.SpellSelectionManager;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.common.NeoForge;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.*;
 
@@ -20,13 +20,13 @@ public enum IronsSpellbooksCompat {
     INSTANCE;
 
     private static final Map<Player, List<UUID>> PLAYER_SPELLS_MAP = new HashMap<>();
-    public static final RegistryObject<SkillBonus.Serializer> GRANT_SPELL_BONUS = PSTSkillBonuses.REGISTRY.register("grant_spell", GrantSpellSkillBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> SPELL_LEVEL_BONUS = PSTSkillBonuses.REGISTRY.register("spell_level", SpellLevelSkillBonus.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> MANA_LEVEL_FUNCTION = PSTFloatFunctions.REGISTRY.register("mana_level", ManaLevelFunction.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> GRANT_SPELL_BONUS = PSTSkillBonuses.REGISTRY.register("grant_spell", GrantSpellSkillBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> SPELL_LEVEL_BONUS = PSTSkillBonuses.REGISTRY.register("spell_level", SpellLevelSkillBonus.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> MANA_LEVEL_FUNCTION = PSTFloatFunctions.REGISTRY.register("mana_level", ManaLevelFunction.Serializer::new);
 
     public void register() {
-        MinecraftForge.EVENT_BUS.addListener(INSTANCE::applyGrantSpellBonus);
-        MinecraftForge.EVENT_BUS.addListener(INSTANCE::applySpellLevelBonus);
+        NeoForge.EVENT_BUS.addListener(INSTANCE::applyGrantSpellBonus);
+        NeoForge.EVENT_BUS.addListener(INSTANCE::applySpellLevelBonus);
     }
 
     public void addPlayerSpell(Player player, UUID uuid) {
diff --git a/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/GrantSpellSkillBonus.java b/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/GrantSpellSkillBonus.java
index 3a806e3e8..4d857b38f 100644
--- a/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/GrantSpellSkillBonus.java
+++ b/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/GrantSpellSkillBonus.java
@@ -15,7 +15,6 @@
 import io.redspace.ironsspellbooks.api.spells.AbstractSpell;
 import io.redspace.ironsspellbooks.api.spells.SpellData;
 import io.redspace.ironsspellbooks.network.EquipmentChangedPacket;
-import io.redspace.ironsspellbooks.setup.PacketDistributor;
 import net.minecraft.ChatFormatting;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.player.LocalPlayer;
@@ -25,8 +24,9 @@
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.api.distmarker.OnlyIn;
+import net.neoforged.neoforge.network.PacketDistributor;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
diff --git a/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/SpellLevelSkillBonus.java b/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/SpellLevelSkillBonus.java
index 986c719a7..742612749 100644
--- a/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/SpellLevelSkillBonus.java
+++ b/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/SpellLevelSkillBonus.java
@@ -24,8 +24,8 @@
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.api.distmarker.OnlyIn;
 
 import javax.annotation.Nonnull;
 import java.util.List;
@@ -103,7 +103,7 @@ public SkillBonus<SpellLevelSkillBonus> merge(SkillBonus<?> other) {
     public MutableComponent getSimpleTooltip() {
         LocalPlayer clientPlayer = Minecraft.getInstance().player;
         Component spellName = SpellRegistry.getSpell(spellId).getDisplayName(clientPlayer);
-        AttributeModifier.Operation operation = AttributeModifier.Operation.ADDITION;
+        AttributeModifier.Operation operation = AttributeModifier.Operation.ADD_VALUE;
         MutableComponent tooltip = Component.translatable(getDescriptionId(), spellName);
         tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, bonusLevels, operation);
         tooltip = playerCondition.getTooltip(tooltip, Target.PLAYER);
diff --git a/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/function/ManaLevelFunction.java b/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/function/ManaLevelFunction.java
index 8f76f0e3e..fc427b594 100644
--- a/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/function/ManaLevelFunction.java
+++ b/src/main/java/daripher/skilltree/compat/ironsspellbooks/skill/bonus/function/ManaLevelFunction.java
@@ -31,7 +31,7 @@ public ManaLevelFunction(boolean percentage, boolean missing) {
     @Override
     public float apply(LivingEntity entity) {
         MagicData magicData = MagicData.getPlayerMagicData(entity);
-        float maxMana = (float) entity.getAttributeValue(AttributeRegistry.MAX_MANA.get());
+        float maxMana = (float) entity.getAttributeValue(AttributeRegistry.MAX_MANA);
         float value = magicData.getMana();
         if (missing) {
             value = maxMana - value;
diff --git a/src/main/java/daripher/skilltree/config/ClientConfig.java b/src/main/java/daripher/skilltree/config/ClientConfig.java
index 34cf6cc28..5e5ed9e70 100644
--- a/src/main/java/daripher/skilltree/config/ClientConfig.java
+++ b/src/main/java/daripher/skilltree/config/ClientConfig.java
@@ -3,12 +3,12 @@
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.skill.PassiveSkill;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.common.ForgeConfigSpec;
-import net.minecraftforge.common.ForgeConfigSpec.ConfigValue;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber.Bus;
-import net.minecraftforge.fml.event.config.ModConfigEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.fml.common.EventBusSubscriber.Bus;
+import net.neoforged.fml.event.config.ModConfigEvent;
+import net.neoforged.neoforge.common.ModConfigSpec;
+import net.neoforged.neoforge.common.ModConfigSpec.ConfigValue;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -17,8 +17,8 @@
 
 @EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Bus.MOD)
 public class ClientConfig {
-    public static final ForgeConfigSpec SPEC;
-    private static final ForgeConfigSpec.Builder BUILDER = new ForgeConfigSpec.Builder();
+    public static final ModConfigSpec SPEC;
+    private static final ModConfigSpec.Builder BUILDER = new ModConfigSpec.Builder();
     private static final ConfigValue<List<? extends String>> FAVORITE_SKILLS;
     private static final ConfigValue<? extends String> FAVORITE_COLOR_HEX;
     private static final ConfigValue<Boolean> SKILL_TREE_BACKGROUND_PARALLAX;
@@ -35,7 +35,7 @@ public class ClientConfig {
     }
 
     private static boolean isValidSkillId(Object o) {
-        return o instanceof String s && ResourceLocation.isValidResourceLocation(s);
+        return o instanceof String s && ResourceLocation.tryParse(s) != null;
     }
 
     private static boolean isValidHexColor(Object o) {
diff --git a/src/main/java/daripher/skilltree/config/ServerConfig.java b/src/main/java/daripher/skilltree/config/ServerConfig.java
index 3024da366..bf65a79be 100644
--- a/src/main/java/daripher/skilltree/config/ServerConfig.java
+++ b/src/main/java/daripher/skilltree/config/ServerConfig.java
@@ -1,20 +1,20 @@
 package daripher.skilltree.config;
 
 import daripher.skilltree.SkillTreeMod;
-import net.minecraftforge.common.ForgeConfigSpec;
-import net.minecraftforge.common.ForgeConfigSpec.ConfigValue;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber.Bus;
-import net.minecraftforge.fml.event.config.ModConfigEvent;
+import net.neoforged.neoforge.common.ModConfigSpec;
+import net.neoforged.neoforge.common.ModConfigSpec.ConfigValue;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.fml.common.EventBusSubscriber.Bus;
+import net.neoforged.fml.event.config.ModConfigEvent;
 
 import java.util.ArrayList;
 import java.util.List;
 
 @EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Bus.MOD)
 public class ServerConfig {
-    public static final ForgeConfigSpec SPEC;
-    private static final ForgeConfigSpec.Builder BUILDER = new ForgeConfigSpec.Builder();
+    public static final ModConfigSpec SPEC;
+    private static final ModConfigSpec.Builder BUILDER = new ModConfigSpec.Builder();
     private static final ConfigValue<Integer> MAX_SKILL_POINTS;
     private static final ConfigValue<Integer> FIRST_SKILL_COST;
     private static final ConfigValue<Integer> LAST_SKILL_COST;
@@ -77,7 +77,16 @@ static List<Integer> generateDefaultPointsCosts() {
     }
 
     @SubscribeEvent
-    static void load(ModConfigEvent event) {
+    static void load(ModConfigEvent.Loading event) {
+        loadValues(event);
+    }
+
+    @SubscribeEvent
+    static void reload(ModConfigEvent.Reloading event) {
+        loadValues(event);
+    }
+
+    private static void loadValues(ModConfigEvent event) {
         if (event.getConfig().getSpec() != SPEC) {
             return;
         }
diff --git a/src/main/java/daripher/skilltree/data/client/SkillTexturesData.java b/src/main/java/daripher/skilltree/data/client/SkillTexturesData.java
index 688242788..0b3a0cf9c 100644
--- a/src/main/java/daripher/skilltree/data/client/SkillTexturesData.java
+++ b/src/main/java/daripher/skilltree/data/client/SkillTexturesData.java
@@ -5,16 +5,16 @@
 import net.minecraft.server.packs.resources.Resource;
 import net.minecraft.server.packs.resources.ResourceManager;
 import net.minecraft.server.packs.resources.ResourceManagerReloadListener;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.RegisterClientReloadListenersEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.neoforge.client.event.RegisterClientReloadListenersEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD, value = Dist.CLIENT)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = EventBusSubscriber.Bus.MOD, value = Dist.CLIENT)
 public class SkillTexturesData implements ResourceManagerReloadListener {
     private static final Map<String, Set<ResourceLocation>> FOLDER_TO_TEXTURES = new HashMap<>();
 
diff --git a/src/main/java/daripher/skilltree/data/client/SkillTreeEditorData.java b/src/main/java/daripher/skilltree/data/client/SkillTreeEditorData.java
index dc5879e08..438de3ad4 100644
--- a/src/main/java/daripher/skilltree/data/client/SkillTreeEditorData.java
+++ b/src/main/java/daripher/skilltree/data/client/SkillTreeEditorData.java
@@ -13,7 +13,7 @@
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.fml.loading.FMLPaths;
+import net.neoforged.fml.loading.FMLPaths;
 
 import javax.annotation.Nullable;
 import java.io.File;
diff --git a/src/main/java/daripher/skilltree/data/generation/PSTBlockStatesProvider.java b/src/main/java/daripher/skilltree/data/generation/PSTBlockStatesProvider.java
index 63c742ac9..e5faccebd 100644
--- a/src/main/java/daripher/skilltree/data/generation/PSTBlockStatesProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/PSTBlockStatesProvider.java
@@ -5,11 +5,11 @@
 import net.minecraft.data.DataGenerator;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.block.Block;
-import net.minecraftforge.client.model.generators.BlockStateProvider;
-import net.minecraftforge.client.model.generators.ConfiguredModel;
-import net.minecraftforge.client.model.generators.ModelFile;
-import net.minecraftforge.common.data.ExistingFileHelper;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.client.model.generators.BlockStateProvider;
+import net.neoforged.neoforge.client.model.generators.ConfiguredModel;
+import net.neoforged.neoforge.client.model.generators.ModelFile;
+import net.neoforged.neoforge.common.data.ExistingFileHelper;
+import net.neoforged.neoforge.registries.DeferredHolder;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.Function;
@@ -24,7 +24,7 @@ protected void registerStatesAndModels() {
         simpleBlockState(PSTBlocks.WORKBENCH, this::orientableModelWithBottom);
     }
 
-    private void simpleBlockState(RegistryObject<Block> blockRegistryObject, Function<ResourceLocation, ModelFile> modelFileProvider) {
+    private void simpleBlockState(DeferredHolder<Block, ? extends Block> blockRegistryObject, Function<ResourceLocation, ModelFile> modelFileProvider) {
         ResourceLocation blockId = blockRegistryObject.getId();
         ModelFile modelFile = modelFileProvider.apply(blockId);
         ConfiguredModel configuredModel = new ConfiguredModel(modelFile);
diff --git a/src/main/java/daripher/skilltree/data/generation/PSTBlockTagsProvider.java b/src/main/java/daripher/skilltree/data/generation/PSTBlockTagsProvider.java
index a82f14429..8e9d0c879 100644
--- a/src/main/java/daripher/skilltree/data/generation/PSTBlockTagsProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/PSTBlockTagsProvider.java
@@ -3,8 +3,8 @@
 import daripher.skilltree.SkillTreeMod;
 import net.minecraft.core.HolderLookup;
 import net.minecraft.data.DataGenerator;
-import net.minecraftforge.common.data.BlockTagsProvider;
-import net.minecraftforge.common.data.ExistingFileHelper;
+import net.neoforged.neoforge.common.data.BlockTagsProvider;
+import net.neoforged.neoforge.common.data.ExistingFileHelper;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.concurrent.CompletableFuture;
diff --git a/src/main/java/daripher/skilltree/data/generation/PSTDamageTagsProvider.java b/src/main/java/daripher/skilltree/data/generation/PSTDamageTagsProvider.java
index 76b257a5a..7a70da21a 100644
--- a/src/main/java/daripher/skilltree/data/generation/PSTDamageTagsProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/PSTDamageTagsProvider.java
@@ -10,7 +10,7 @@
 import net.minecraft.tags.TagKey;
 import net.minecraft.world.damagesource.DamageType;
 import net.minecraft.world.damagesource.DamageTypes;
-import net.minecraftforge.common.data.ExistingFileHelper;
+import net.neoforged.neoforge.common.data.ExistingFileHelper;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
diff --git a/src/main/java/daripher/skilltree/data/generation/PSTDataGenerator.java b/src/main/java/daripher/skilltree/data/generation/PSTDataGenerator.java
index 96c513483..f757d7ce9 100644
--- a/src/main/java/daripher/skilltree/data/generation/PSTDataGenerator.java
+++ b/src/main/java/daripher/skilltree/data/generation/PSTDataGenerator.java
@@ -7,11 +7,11 @@
 import daripher.skilltree.data.generation.translation.PSTRussianTranslationProvider;
 import net.minecraft.core.HolderLookup;
 import net.minecraft.data.DataGenerator;
-import net.minecraftforge.common.data.ExistingFileHelper;
-import net.minecraftforge.data.event.GatherDataEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber.Bus;
+import net.neoforged.neoforge.common.data.ExistingFileHelper;
+import net.neoforged.neoforge.data.event.GatherDataEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.fml.common.EventBusSubscriber.Bus;
 
 import java.util.concurrent.CompletableFuture;
 
@@ -27,10 +27,15 @@ public static void onGatherData(GatherDataEvent event) {
         PSTBlockTagsProvider blockTagsProvider = new PSTBlockTagsProvider(dataGenerator, lookupProvider, existingFileHelper);
         dataGenerator.addProvider(includeServer, blockTagsProvider);
         dataGenerator.addProvider(includeServer, new PSTItemTagsProvider(dataGenerator, lookupProvider, blockTagsProvider, existingFileHelper));
-        dataGenerator.addProvider(includeServer, new PSTLootTablesProvider(dataGenerator));
-        dataGenerator.addProvider(includeServer, new PSTGlobalLootModifierProvider(dataGenerator));
+        dataGenerator.addProvider(
+                includeServer, new PSTLootTablesProvider(dataGenerator, lookupProvider));
+        dataGenerator.addProvider(
+                includeServer,
+                new PSTGlobalLootModifierProvider(dataGenerator, lookupProvider));
         dataGenerator.addProvider(includeServer, new PSTDamageTagsProvider(dataGenerator, lookupProvider, existingFileHelper));
-        dataGenerator.addProvider(includeServer, new PSTRecipesProvider(dataGenerator));
+        dataGenerator.addProvider(
+                includeServer,
+                new PSTRecipesProvider(dataGenerator.getPackOutput(), lookupProvider));
 
         boolean includeClient = event.includeClient();
         dataGenerator.addProvider(includeClient, new PSTEnglishTranslationProvider(dataGenerator));
diff --git a/src/main/java/daripher/skilltree/data/generation/PSTItemModelsProvider.java b/src/main/java/daripher/skilltree/data/generation/PSTItemModelsProvider.java
index d27103044..a2b1986a0 100644
--- a/src/main/java/daripher/skilltree/data/generation/PSTItemModelsProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/PSTItemModelsProvider.java
@@ -3,8 +3,8 @@
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.init.PSTItems;
 import net.minecraft.data.DataGenerator;
-import net.minecraftforge.client.model.generators.ItemModelProvider;
-import net.minecraftforge.common.data.ExistingFileHelper;
+import net.neoforged.neoforge.client.model.generators.ItemModelProvider;
+import net.neoforged.neoforge.common.data.ExistingFileHelper;
 
 public class PSTItemModelsProvider extends ItemModelProvider {
     public PSTItemModelsProvider(DataGenerator dataGenerator, ExistingFileHelper existingFileHelper) {
diff --git a/src/main/java/daripher/skilltree/data/generation/PSTItemTagsProvider.java b/src/main/java/daripher/skilltree/data/generation/PSTItemTagsProvider.java
index 746280885..52a909d97 100644
--- a/src/main/java/daripher/skilltree/data/generation/PSTItemTagsProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/PSTItemTagsProvider.java
@@ -8,16 +8,16 @@
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.tags.ItemTags;
 import net.minecraft.world.item.Items;
-import net.minecraftforge.common.Tags;
-import net.minecraftforge.common.data.BlockTagsProvider;
-import net.minecraftforge.common.data.ExistingFileHelper;
+import net.neoforged.neoforge.common.Tags;
+import net.neoforged.neoforge.common.data.BlockTagsProvider;
+import net.neoforged.neoforge.common.data.ExistingFileHelper;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.concurrent.CompletableFuture;
 
 public class PSTItemTagsProvider extends ItemTagsProvider {
-    public static final ResourceLocation KNIVES = ResourceLocation.fromNamespaceAndPath("forge", "tools/knives");
+    public static final ResourceLocation KNIVES = ResourceLocation.fromNamespaceAndPath("c", "tools/knives");
 
     public PSTItemTagsProvider(DataGenerator dataGenerator, CompletableFuture<HolderLookup.Provider> provider, BlockTagsProvider blockTagsProvider, @Nullable ExistingFileHelper fileHelper) {
         super(dataGenerator.getPackOutput(), provider, blockTagsProvider.contentsGetter(), SkillTreeMod.MOD_ID, fileHelper);
@@ -26,8 +26,10 @@ public PSTItemTagsProvider(DataGenerator dataGenerator, CompletableFuture<Holder
     @Override
     protected void addTags(HolderLookup.@NotNull Provider provider) {
         tag(Tags.Items.TOOLS).addOptionalTag(KNIVES);
-        tag(PSTTags.Items.MELEE_WEAPON).addTags(ItemTags.SWORDS, ItemTags.AXES, Tags.Items.TOOLS_TRIDENTS);
-        tag(PSTTags.Items.RANGED_WEAPON).addTags(Tags.Items.TOOLS_BOWS, Tags.Items.TOOLS_CROSSBOWS);
+        tag(PSTTags.Items.MELEE_WEAPON)
+                .addTags(ItemTags.SWORDS, ItemTags.AXES, Tags.Items.TOOLS_SPEAR);
+        tag(PSTTags.Items.RANGED_WEAPON)
+                .addTags(Tags.Items.TOOLS_BOW, Tags.Items.TOOLS_CROSSBOW);
         tag(PSTTags.Items.LEATHER_ARMOR).add(Items.LEATHER_BOOTS, Items.LEATHER_CHESTPLATE, Items.LEATHER_HELMET, Items.LEATHER_LEGGINGS);
     }
 }
diff --git a/src/main/java/daripher/skilltree/data/generation/PSTRecipesProvider.java b/src/main/java/daripher/skilltree/data/generation/PSTRecipesProvider.java
index 74c5a8603..8a8fc5460 100644
--- a/src/main/java/daripher/skilltree/data/generation/PSTRecipesProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/PSTRecipesProvider.java
@@ -2,32 +2,35 @@
 
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.init.PSTItems;
-import net.minecraft.data.DataGenerator;
-import net.minecraft.data.recipes.FinishedRecipe;
+import java.util.concurrent.CompletableFuture;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.data.PackOutput;
 import net.minecraft.data.recipes.RecipeCategory;
+import net.minecraft.data.recipes.RecipeOutput;
 import net.minecraft.data.recipes.RecipeProvider;
 import net.minecraft.data.recipes.ShapedRecipeBuilder;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.Items;
-import net.minecraftforge.common.Tags;
+import net.neoforged.neoforge.common.Tags;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.function.Consumer;
-
 public class PSTRecipesProvider extends RecipeProvider {
-    public PSTRecipesProvider(DataGenerator dataGenerator) {
-        super(dataGenerator.getPackOutput());
+    public PSTRecipesProvider(
+            PackOutput packOutput, CompletableFuture<HolderLookup.Provider> lookupProvider) {
+        super(packOutput, lookupProvider);
     }
 
     @Override
-    protected void buildRecipes(@NotNull Consumer<FinishedRecipe> consumer) {
-        addCraftingTableRecipes(consumer);
+    protected void buildRecipes(
+            @NotNull RecipeOutput recipeOutput,
+            @NotNull HolderLookup.Provider lookupProvider) {
+        addCraftingTableRecipes(recipeOutput);
     }
 
-    private static void addCraftingTableRecipes(@NotNull Consumer<FinishedRecipe> consumer) {
+    private static void addCraftingTableRecipes(@NotNull RecipeOutput recipeOutput) {
         ShapedRecipeBuilder.shaped(RecipeCategory.MISC, PSTItems.WORKBENCH.get()).define('I', Tags.Items.INGOTS_IRON)
                 .define('G', Tags.Items.INGOTS_GOLD).define('C', Tags.Items.INGOTS_COPPER).define('#', Items.SMITHING_TABLE).pattern("III")
-                .pattern("G#G").pattern("CCC").unlockedBy(getHasName(Items.SMITHING_TABLE), has(Items.SMITHING_TABLE)).save(consumer);
+                .pattern("G#G").pattern("CCC").unlockedBy(getHasName(Items.SMITHING_TABLE), has(Items.SMITHING_TABLE)).save(recipeOutput);
     }
 
     private static ResourceLocation modRecipeId(String path) {
diff --git a/src/main/java/daripher/skilltree/data/generation/loot/PSTBlockLoot.java b/src/main/java/daripher/skilltree/data/generation/loot/PSTBlockLoot.java
index 80a734cd8..f758f99b5 100644
--- a/src/main/java/daripher/skilltree/data/generation/loot/PSTBlockLoot.java
+++ b/src/main/java/daripher/skilltree/data/generation/loot/PSTBlockLoot.java
@@ -1,17 +1,18 @@
 package daripher.skilltree.data.generation.loot;
 
 import daripher.skilltree.init.PSTBlocks;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.data.loot.BlockLootSubProvider;
 import net.minecraft.world.flag.FeatureFlags;
 import net.minecraft.world.level.block.Block;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredHolder;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collections;
 
 public class PSTBlockLoot extends BlockLootSubProvider {
-    protected PSTBlockLoot() {
-        super(Collections.emptySet(), FeatureFlags.REGISTRY.allFlags());
+    protected PSTBlockLoot(HolderLookup.Provider lookupProvider) {
+        super(Collections.emptySet(), FeatureFlags.REGISTRY.allFlags(), lookupProvider);
     }
 
     @Override
@@ -21,6 +22,6 @@ protected void generate() {
 
     @Override
     protected @NotNull Iterable<Block> getKnownBlocks() {
-        return PSTBlocks.REGISTRY.getEntries().stream().map(RegistryObject::get)::iterator;
+        return PSTBlocks.REGISTRY.getEntries().stream().<Block>map(DeferredHolder::get)::iterator;
     }
 }
diff --git a/src/main/java/daripher/skilltree/data/generation/loot/PSTGlobalLootModifierProvider.java b/src/main/java/daripher/skilltree/data/generation/loot/PSTGlobalLootModifierProvider.java
index f0a5f58c9..8d75cc62d 100644
--- a/src/main/java/daripher/skilltree/data/generation/loot/PSTGlobalLootModifierProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/loot/PSTGlobalLootModifierProvider.java
@@ -2,12 +2,16 @@
 
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.loot.modifier.SkillBonusesLootModifier;
+import java.util.concurrent.CompletableFuture;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.data.DataGenerator;
-import net.minecraftforge.common.data.GlobalLootModifierProvider;
+import net.neoforged.neoforge.common.data.GlobalLootModifierProvider;
 
 public class PSTGlobalLootModifierProvider extends GlobalLootModifierProvider {
-    public PSTGlobalLootModifierProvider(DataGenerator generator) {
-        super(generator.getPackOutput(), SkillTreeMod.MOD_ID);
+    public PSTGlobalLootModifierProvider(
+            DataGenerator generator,
+            CompletableFuture<HolderLookup.Provider> lookupProvider) {
+        super(generator.getPackOutput(), lookupProvider, SkillTreeMod.MOD_ID);
     }
 
     @Override
diff --git a/src/main/java/daripher/skilltree/data/generation/loot/PSTLootTablesProvider.java b/src/main/java/daripher/skilltree/data/generation/loot/PSTLootTablesProvider.java
index f0fde2ee7..dfb11e3ae 100644
--- a/src/main/java/daripher/skilltree/data/generation/loot/PSTLootTablesProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/loot/PSTLootTablesProvider.java
@@ -1,8 +1,11 @@
 package daripher.skilltree.data.generation.loot;
 
 import net.minecraft.data.DataGenerator;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.data.loot.LootTableProvider;
+import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.storage.loot.BuiltInLootTables;
 import net.minecraft.world.level.storage.loot.LootTable;
 import net.minecraft.world.level.storage.loot.ValidationContext;
 import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets;
@@ -11,12 +14,19 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
 
 public class PSTLootTablesProvider extends LootTableProvider {
-    public static final Set<ResourceLocation> REQUIRED_TABLES = Set.of();
+    public static final Set<ResourceKey<LootTable>> REQUIRED_TABLES = Set.of();
 
-    public PSTLootTablesProvider(DataGenerator generator) {
-        super(generator.getPackOutput(), REQUIRED_TABLES, List.of(createBlockLootProvider()));
+    public PSTLootTablesProvider(
+            DataGenerator generator,
+            CompletableFuture<HolderLookup.Provider> lookupProvider) {
+        super(
+                generator.getPackOutput(),
+                REQUIRED_TABLES,
+                List.of(createBlockLootProvider()),
+                lookupProvider);
     }
 
     @NotNull
@@ -25,6 +35,9 @@ private static SubProviderEntry createBlockLootProvider() {
     }
 
     @Override
-    protected void validate(@NotNull Map<ResourceLocation, LootTable> map, @NotNull ValidationContext ctx) {
+    protected void validate(
+            @NotNull net.minecraft.core.WritableRegistry<LootTable> registry,
+            @NotNull ValidationContext ctx,
+            @NotNull net.minecraft.util.ProblemReporter.Collector problemReporter) {
     }
 }
diff --git a/src/main/java/daripher/skilltree/data/generation/translation/PSTEnglishTranslationProvider.java b/src/main/java/daripher/skilltree/data/generation/translation/PSTEnglishTranslationProvider.java
index 3192e25ce..6b7c34443 100644
--- a/src/main/java/daripher/skilltree/data/generation/translation/PSTEnglishTranslationProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/translation/PSTEnglishTranslationProvider.java
@@ -9,6 +9,8 @@
 import daripher.skilltree.init.predicate.PSTLivingEntityPredicates;
 import daripher.skilltree.skill.bonus.player.ExperienceGainMultiplierBonus;
 import daripher.skilltree.skill.bonus.player.LootAmountModifierBonus;
+import java.util.Optional;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.data.DataGenerator;
 import net.minecraft.world.item.Items;
 import net.minecraft.world.item.alchemy.Potion;
@@ -569,8 +571,9 @@ protected void addTranslations() {
     }
 
     protected void add(Potion potion, String name) {
-        add(potion.getName(Items.POTION.getDescriptionId() + ".effect."), "Potion of " + name);
-        add(potion.getName(Items.SPLASH_POTION.getDescriptionId() + ".effect."), "Splash Potion of " + name);
-        add(potion.getName(Items.LINGERING_POTION.getDescriptionId() + ".effect."), "Lingering Potion of " + name);
+        var potionHolder = Optional.of(BuiltInRegistries.POTION.wrapAsHolder(potion));
+        add(Potion.getName(potionHolder, Items.POTION.getDescriptionId() + ".effect."), "Potion of " + name);
+        add(Potion.getName(potionHolder, Items.SPLASH_POTION.getDescriptionId() + ".effect."), "Splash Potion of " + name);
+        add(Potion.getName(potionHolder, Items.LINGERING_POTION.getDescriptionId() + ".effect."), "Lingering Potion of " + name);
     }
 }
diff --git a/src/main/java/daripher/skilltree/data/generation/translation/PSTRussianTranslationProvider.java b/src/main/java/daripher/skilltree/data/generation/translation/PSTRussianTranslationProvider.java
index d803eabbd..16dd4f9e0 100644
--- a/src/main/java/daripher/skilltree/data/generation/translation/PSTRussianTranslationProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/translation/PSTRussianTranslationProvider.java
@@ -9,6 +9,8 @@
 import daripher.skilltree.init.predicate.PSTLivingEntityPredicates;
 import daripher.skilltree.skill.bonus.player.ExperienceGainMultiplierBonus;
 import daripher.skilltree.skill.bonus.player.LootAmountModifierBonus;
+import java.util.Optional;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.data.DataGenerator;
 import net.minecraft.world.item.Items;
 import net.minecraft.world.item.alchemy.Potion;
@@ -639,8 +641,9 @@ protected void addTranslations() {
     }
 
     protected void add(Potion potion, String name) {
-        add(potion.getName(Items.POTION.getDescriptionId() + ".effect."), "Зелье " + name);
-        add(potion.getName(Items.SPLASH_POTION.getDescriptionId() + ".effect."), "Взрывное зелье " + name);
-        add(potion.getName(Items.LINGERING_POTION.getDescriptionId() + ".effect."), "Туманное зелье " + name);
+        var potionHolder = Optional.of(BuiltInRegistries.POTION.wrapAsHolder(potion));
+        add(Potion.getName(potionHolder, Items.POTION.getDescriptionId() + ".effect."), "Зелье " + name);
+        add(Potion.getName(potionHolder, Items.SPLASH_POTION.getDescriptionId() + ".effect."), "Взрывное зелье " + name);
+        add(Potion.getName(potionHolder, Items.LINGERING_POTION.getDescriptionId() + ".effect."), "Туманное зелье " + name);
     }
 }
diff --git a/src/main/java/daripher/skilltree/data/generation/translation/PSTTranslationProvider.java b/src/main/java/daripher/skilltree/data/generation/translation/PSTTranslationProvider.java
index 9cd435bbb..5795ed94f 100644
--- a/src/main/java/daripher/skilltree/data/generation/translation/PSTTranslationProvider.java
+++ b/src/main/java/daripher/skilltree/data/generation/translation/PSTTranslationProvider.java
@@ -17,8 +17,8 @@
 import net.minecraft.world.entity.ai.attributes.Attribute;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraftforge.common.data.LanguageProvider;
-import net.minecraftforge.registries.ForgeRegistries;
+import net.neoforged.neoforge.common.data.LanguageProvider;
+import daripher.skilltree.util.ForgeRegistries;
 
 import java.util.Objects;
 
@@ -175,7 +175,8 @@ protected void add(ItemStackPredicate.Serializer serializer, String value) {
         add(key, value);
     }
 
-    protected void add(TagKey<Item> itemTag, String value) {
+    @Override
+    public void add(TagKey<?> itemTag, String value) {
         ResourceLocation id = itemTag.location();
         String key = "item_tag.%s".formatted(id.toString());
         add(key, value);
diff --git a/src/main/java/daripher/skilltree/data/reloader/SkillTreesReloader.java b/src/main/java/daripher/skilltree/data/reloader/SkillTreesReloader.java
index 15be18c73..a5648e65b 100644
--- a/src/main/java/daripher/skilltree/data/reloader/SkillTreesReloader.java
+++ b/src/main/java/daripher/skilltree/data/reloader/SkillTreesReloader.java
@@ -11,9 +11,9 @@
 import net.minecraft.server.packs.resources.ResourceManager;
 import net.minecraft.server.packs.resources.SimpleJsonResourceReloadListener;
 import net.minecraft.util.profiling.ProfilerFiller;
-import net.minecraftforge.event.AddReloadListenerEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
+import net.neoforged.neoforge.event.AddReloadListenerEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
diff --git a/src/main/java/daripher/skilltree/data/reloader/SkillsReloader.java b/src/main/java/daripher/skilltree/data/reloader/SkillsReloader.java
index 1ba8c5e4c..71ae7e843 100644
--- a/src/main/java/daripher/skilltree/data/reloader/SkillsReloader.java
+++ b/src/main/java/daripher/skilltree/data/reloader/SkillsReloader.java
@@ -10,6 +10,7 @@
 import daripher.skilltree.skill.PassiveSkill;
 import daripher.skilltree.skill.bonus.SkillBonus;
 import daripher.skilltree.skill.requirement.SkillRequirement;
+import net.minecraft.core.RegistryAccess;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.MutableComponent;
@@ -17,9 +18,9 @@
 import net.minecraft.server.packs.resources.ResourceManager;
 import net.minecraft.server.packs.resources.SimpleJsonResourceReloadListener;
 import net.minecraft.util.profiling.ProfilerFiller;
-import net.minecraftforge.event.AddReloadListenerEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
+import net.neoforged.neoforge.event.AddReloadListenerEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.NotNull;
 
 import javax.annotation.Nullable;
@@ -31,7 +32,10 @@ public class SkillsReloader extends SimpleJsonResourceReloadListener {
     public static final Gson GSON = new GsonBuilder().registerTypeAdapter(ResourceLocation.class, new ResourceLocation.Serializer())
             .registerTypeAdapter(SkillBonus.class, new SkillBonusSerializer())
             .registerTypeAdapter(SkillRequirement.class, new SkillRequirementSerializer())
-            .registerTypeAdapter(MutableComponent.class, new Component.Serializer()).setPrettyPrinting().create();
+            .registerTypeAdapter(
+                    MutableComponent.class,
+                    new Component.SerializerAdapter(RegistryAccess.EMPTY))
+            .setPrettyPrinting().create();
     private static final Map<ResourceLocation, PassiveSkill> SKILLS = new HashMap<>();
 
     public SkillsReloader() {
diff --git a/src/main/java/daripher/skilltree/data/serializers/SerializationHelper.java b/src/main/java/daripher/skilltree/data/serializers/SerializationHelper.java
index b1e669bb7..630f1086d 100644
--- a/src/main/java/daripher/skilltree/data/serializers/SerializationHelper.java
+++ b/src/main/java/daripher/skilltree/data/serializers/SerializationHelper.java
@@ -20,19 +20,20 @@
 import daripher.skilltree.skill.bonus.predicate.item.PotionStackPredicate;
 import daripher.skilltree.skill.bonus.predicate.living.LivingEntityPredicate;
 import daripher.skilltree.skill.bonus.predicate.living.NoneLivingEntityPredicate;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.effect.MobEffect;
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.entity.ai.attributes.Attribute;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
-import net.minecraftforge.registries.ForgeRegistries;
+import daripher.skilltree.util.ForgeRegistries;
 import org.jetbrains.annotations.NotNull;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import java.util.Locale;
 import java.util.Objects;
-import java.util.UUID;
 
 public class SerializationHelper {
     @NotNull
@@ -55,27 +56,26 @@ public static void serializeAttribute(JsonObject json, Attribute attribute) {
 
     @NotNull
     public static AttributeModifier deserializeAttributeModifier(JsonObject json) {
-        UUID id = UUID.fromString(json.get("id").getAsString());
-        String name = json.get("name").getAsString();
+        ResourceLocation id = deserializeModifierId(json.get("id").getAsString());
         double amount = json.get("amount").getAsDouble();
         AttributeModifier.Operation operation = deserializeOperation(json);
-        return new AttributeModifier(id, name, amount, operation);
+        return new AttributeModifier(id, amount, operation);
     }
 
     public static void serializeAttributeModifier(JsonObject json, AttributeModifier modifier) {
-        json.addProperty("id", modifier.getId().toString());
-        json.addProperty("name", modifier.getName());
-        json.addProperty("amount", modifier.getAmount());
-        serializeOperation(json, modifier.getOperation());
+        json.addProperty("id", modifier.id().toString());
+        json.addProperty("name", modifier.id().toString());
+        json.addProperty("amount", modifier.amount());
+        serializeOperation(json, modifier.operation());
     }
 
     @NotNull
     public static AttributeModifier.Operation deserializeOperation(JsonObject json) {
-        return AttributeModifier.Operation.fromValue(json.get("operation").getAsInt());
+        return AttributeModifier.Operation.BY_ID.apply(json.get("operation").getAsInt());
     }
 
     public static void serializeOperation(JsonObject json, AttributeModifier.Operation operation) {
-        json.addProperty("operation", operation.toValue());
+        json.addProperty("operation", operation.id());
     }
 
     public static @Nonnull LivingMultiplier deserializeLivingMultiplier(JsonObject json, String name) {
@@ -258,11 +258,14 @@ public static MobEffectInstance deserializeEffectInstance(JsonObject json) {
         MobEffect effect = deserializeMobEffect(json);
         int duration = json.get("duration").getAsInt();
         int amplifier = json.get("amplifier").getAsInt();
-        return new MobEffectInstance(Objects.requireNonNull(effect), duration, amplifier);
+        return new MobEffectInstance(
+                BuiltInRegistries.MOB_EFFECT.wrapAsHolder(Objects.requireNonNull(effect)),
+                duration,
+                amplifier);
     }
 
     public static void serializeEffectInstance(JsonObject json, MobEffectInstance effect) {
-        serializeMobEffect(json, effect.getEffect());
+        serializeMobEffect(json, effect.getEffect().value());
         json.addProperty("duration", effect.getDuration());
         json.addProperty("amplifier", effect.getAmplifier());
     }
@@ -302,27 +305,26 @@ public static void serializeAttribute(CompoundTag tag, Attribute attribute) {
 
     @NotNull
     public static AttributeModifier deserializeAttributeModifier(CompoundTag tag) {
-        UUID modifierId = UUID.fromString(tag.getString("id"));
-        String name = tag.getString("name");
+        ResourceLocation modifierId = deserializeModifierId(tag.getString("id"));
         double amount = tag.getDouble("amount");
         AttributeModifier.Operation operation = deserializeOperation(tag);
-        return new AttributeModifier(modifierId, name, amount, operation);
+        return new AttributeModifier(modifierId, amount, operation);
     }
 
     public static void serializeAttributeModifier(CompoundTag tag, AttributeModifier modifier) {
-        tag.putString("id", modifier.getId().toString());
-        tag.putString("name", modifier.getName());
-        tag.putDouble("amount", modifier.getAmount());
-        serializeOperation(tag, modifier.getOperation());
+        tag.putString("id", modifier.id().toString());
+        tag.putString("name", modifier.id().toString());
+        tag.putDouble("amount", modifier.amount());
+        serializeOperation(tag, modifier.operation());
     }
 
     @NotNull
     public static AttributeModifier.Operation deserializeOperation(CompoundTag tag) {
-        return AttributeModifier.Operation.fromValue(tag.getInt("operation"));
+        return AttributeModifier.Operation.BY_ID.apply(tag.getInt("operation"));
     }
 
     public static void serializeOperation(CompoundTag tag, AttributeModifier.Operation operation) {
-        tag.putInt("operation", operation.toValue());
+        tag.putInt("operation", operation.id());
     }
 
     public static @Nonnull LivingMultiplier deserializeLivingMultiplier(CompoundTag tag, String name) {
@@ -454,11 +456,12 @@ public static MobEffectInstance deserializeEffectInstance(CompoundTag tag) {
         MobEffect effect = Objects.requireNonNull(deserializeMobEffect(tag));
         int duration = tag.getInt("duration");
         int amplifier = tag.getInt("amplifier");
-        return new MobEffectInstance(effect, duration, amplifier);
+        return new MobEffectInstance(
+                BuiltInRegistries.MOB_EFFECT.wrapAsHolder(effect), duration, amplifier);
     }
 
     public static void serializeEffectInstance(CompoundTag tag, MobEffectInstance effect) {
-        serializeMobEffect(tag, effect.getEffect());
+        serializeMobEffect(tag, effect.getEffect().value());
         tag.putInt("duration", effect.getDuration());
         tag.putInt("amplifier", effect.getAmplifier());
     }
@@ -521,4 +524,13 @@ public static ItemBonus<?> deserializeItemBonus(CompoundTag tag) {
         Objects.requireNonNull(serializer);
         return serializer.deserialize(itemBonusTag);
     }
+
+    private static ResourceLocation deserializeModifierId(String rawId) {
+        ResourceLocation parsed = ResourceLocation.tryParse(rawId);
+        if (parsed != null && rawId.contains(":")) {
+            return parsed;
+        }
+        return ResourceLocation.fromNamespaceAndPath(
+                SkillTreeMod.MOD_ID, "modifier/" + rawId.toLowerCase(Locale.ROOT));
+    }
 }
diff --git a/src/main/java/daripher/skilltree/effect/LiquidFireEffect.java b/src/main/java/daripher/skilltree/effect/LiquidFireEffect.java
index fe124f626..230db8cb7 100644
--- a/src/main/java/daripher/skilltree/effect/LiquidFireEffect.java
+++ b/src/main/java/daripher/skilltree/effect/LiquidFireEffect.java
@@ -36,6 +36,6 @@ public void applyInstantenousEffect(@Nullable Entity source, @Nullable Entity in
             DamageSource damageSource = new DamageSource(damageType, source, indirectSource);
             target.hurt(damageSource, damage);
         }
-        target.setSecondsOnFire((int) damage / 2);
+        target.igniteForSeconds((int) damage / 2f);
     }
 }
diff --git a/src/main/java/daripher/skilltree/effect/SkillBonusEffect.java b/src/main/java/daripher/skilltree/effect/SkillBonusEffect.java
index f7f7e9575..faef446e5 100644
--- a/src/main/java/daripher/skilltree/effect/SkillBonusEffect.java
+++ b/src/main/java/daripher/skilltree/effect/SkillBonusEffect.java
@@ -18,31 +18,26 @@ public SkillBonusEffect(MobEffectCategory category, int color, SkillBonus<?> bon
     }
 
     @Override
-    public void removeAttributeModifiers(@NotNull LivingEntity entity, @NotNull AttributeMap attributeMap, int amplifier) {
-        super.removeAttributeModifiers(entity, attributeMap, amplifier);
-        if (entity instanceof ServerPlayer player) {
-            bonus.onSkillRemoved(player);
-        }
+    public void removeAttributeModifiers(@NotNull AttributeMap attributeMap) {
+        super.removeAttributeModifiers(attributeMap);
     }
 
     @Override
-    public void addAttributeModifiers(@NotNull LivingEntity entity, @NotNull AttributeMap attributeMap, int amplifier) {
-        super.addAttributeModifiers(entity, attributeMap, amplifier);
-        if (entity instanceof ServerPlayer player) {
-            bonus.onSkillLearned(player, true);
-        }
+    public void addAttributeModifiers(@NotNull AttributeMap attributeMap, int amplifier) {
+        super.addAttributeModifiers(attributeMap, amplifier);
     }
 
     @Override
-    public boolean isDurationEffectTick(int duration, int amplifier) {
+    public boolean shouldApplyEffectTickThisTick(int duration, int amplifier) {
         return bonus instanceof TickingSkillBonus;
     }
 
     @Override
-    public void applyEffectTick(@NotNull LivingEntity entity, int amplifier) {
+    public boolean applyEffectTick(@NotNull LivingEntity entity, int amplifier) {
         if (entity instanceof ServerPlayer player && bonus instanceof TickingSkillBonus ticking) {
             ticking.tick(player);
         }
+        return true;
     }
 
     public SkillBonus<?> getBonus() {
diff --git a/src/main/java/daripher/skilltree/enchantment/EnchantmentCategory.java b/src/main/java/daripher/skilltree/enchantment/EnchantmentCategory.java
new file mode 100644
index 000000000..2e77336ee
--- /dev/null
+++ b/src/main/java/daripher/skilltree/enchantment/EnchantmentCategory.java
@@ -0,0 +1,81 @@
+package daripher.skilltree.enchantment;
+
+import java.util.Objects;
+import java.util.function.Predicate;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.item.ArmorItem;
+import net.minecraft.world.item.AxeItem;
+import net.minecraft.world.item.BowItem;
+import net.minecraft.world.item.CrossbowItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.PotionItem;
+import net.minecraft.world.item.ShieldItem;
+import net.minecraft.world.item.SwordItem;
+import net.minecraft.world.item.TridentItem;
+
+public final class EnchantmentCategory {
+  public static final EnchantmentCategory ARMOR =
+      new EnchantmentCategory("armor", item -> item instanceof ArmorItem);
+  public static final EnchantmentCategory ARMOR_CHEST =
+      new EnchantmentCategory(
+          "armor_chest",
+          item -> item instanceof ArmorItem armor && armor.getEquipmentSlot() == EquipmentSlot.CHEST);
+  public static final EnchantmentCategory ARMOR_FEET =
+      new EnchantmentCategory(
+          "armor_feet",
+          item -> item instanceof ArmorItem armor && armor.getEquipmentSlot() == EquipmentSlot.FEET);
+  public static final EnchantmentCategory ARMOR_HEAD =
+      new EnchantmentCategory(
+          "armor_head",
+          item -> item instanceof ArmorItem armor && armor.getEquipmentSlot() == EquipmentSlot.HEAD);
+  public static final EnchantmentCategory ARMOR_LEGS =
+      new EnchantmentCategory(
+          "armor_legs",
+          item -> item instanceof ArmorItem armor && armor.getEquipmentSlot() == EquipmentSlot.LEGS);
+  public static final EnchantmentCategory WEAPON =
+      new EnchantmentCategory(
+          "weapon", item -> item instanceof SwordItem || item instanceof AxeItem || item instanceof TridentItem);
+  public static final EnchantmentCategory BOW =
+      new EnchantmentCategory("bow", item -> item instanceof BowItem);
+  public static final EnchantmentCategory CROSSBOW =
+      new EnchantmentCategory("crossbow", item -> item instanceof CrossbowItem);
+  public static final EnchantmentCategory TRIDENT =
+      new EnchantmentCategory("trident", item -> item instanceof TridentItem);
+
+  private final String name;
+  private final Predicate<Item> predicate;
+
+  private EnchantmentCategory(String name, Predicate<Item> predicate) {
+    this.name = name;
+    this.predicate = predicate;
+  }
+
+  public static EnchantmentCategory create(String name, Predicate<Item> predicate) {
+    return new EnchantmentCategory(name, predicate);
+  }
+
+  public boolean canEnchant(Item item) {
+    return predicate.test(item);
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public String toString() {
+    return name;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (!(o instanceof EnchantmentCategory that)) return false;
+    return Objects.equals(name, that.name);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(name);
+  }
+}
diff --git a/src/main/java/daripher/skilltree/entity/player/PlayerHelper.java b/src/main/java/daripher/skilltree/entity/player/PlayerHelper.java
index 77d12e9a2..96d19684c 100644
--- a/src/main/java/daripher/skilltree/entity/player/PlayerHelper.java
+++ b/src/main/java/daripher/skilltree/entity/player/PlayerHelper.java
@@ -6,7 +6,7 @@
 import net.minecraft.world.entity.EquipmentSlot;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.fml.ModList;
+import net.neoforged.fml.ModList;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Arrays;
diff --git a/src/main/java/daripher/skilltree/event/ModEvents.java b/src/main/java/daripher/skilltree/event/ModEvents.java
index 42b8b8591..0b30b6a97 100644
--- a/src/main/java/daripher/skilltree/event/ModEvents.java
+++ b/src/main/java/daripher/skilltree/event/ModEvents.java
@@ -7,9 +7,9 @@
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.item.ItemEntity;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.event.entity.living.LivingDropsEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
+import net.neoforged.neoforge.event.entity.living.LivingDropsEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 @EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class ModEvents {
diff --git a/src/main/java/daripher/skilltree/event/PSTEvents.java b/src/main/java/daripher/skilltree/event/PSTEvents.java
index 75124d090..19f37118a 100644
--- a/src/main/java/daripher/skilltree/event/PSTEvents.java
+++ b/src/main/java/daripher/skilltree/event/PSTEvents.java
@@ -2,9 +2,9 @@
 
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.config.ServerConfig;
-import net.minecraftforge.event.GrindstoneEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
+import net.neoforged.neoforge.event.GrindstoneEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 @EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class PSTEvents {
diff --git a/src/main/java/daripher/skilltree/event/PoisonedWeaponEvents.java b/src/main/java/daripher/skilltree/event/PoisonedWeaponEvents.java
index f5b39ec2d..d1748a700 100644
--- a/src/main/java/daripher/skilltree/event/PoisonedWeaponEvents.java
+++ b/src/main/java/daripher/skilltree/event/PoisonedWeaponEvents.java
@@ -2,27 +2,29 @@
 
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.skill.bonus.predicate.item.EquipmentPredicate;
+import net.minecraft.core.component.DataComponents;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
 import net.minecraft.nbt.Tag;
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.alchemy.PotionUtils;
-import net.minecraftforge.event.entity.living.LivingAttackEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.minecraft.world.item.alchemy.PotionContents;
+import net.minecraft.world.item.component.CustomData;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.ArrayList;
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class PoisonedWeaponEvents {
     public static final String WEAPON_EFFECTS_TAG_NAME = "poisoned_weapon_effects";
     public static final String POISON_USES_LEFT_TAG_NAME = "poisoned_weapon_uses_left";
 
     @SubscribeEvent
-    public static void applyPoisonedWeaponEffect(LivingAttackEvent event) {
+    public static void applyPoisonedWeaponEffect(LivingIncomingDamageEvent event) {
         if (!(event.getSource().getEntity() instanceof Player player)) {
             return;
         }
@@ -40,19 +42,17 @@ public static void applyPoisonedWeaponEffect(LivingAttackEvent event) {
     }
 
     public static void setPoisonedWeaponEffects(ItemStack itemStack, ItemStack potionStack, int maxUses) {
-        List<MobEffectInstance> potionEffects = PotionUtils.getMobEffects(potionStack);
-        CompoundTag itemTag = itemStack.getOrCreateTag();
+        PotionContents potionContents = potionStack.getOrDefault(DataComponents.POTION_CONTENTS, PotionContents.EMPTY);
         ListTag effectsTagList = new ListTag();
-        potionEffects.stream().map(effectInstance -> effectInstance.save(new CompoundTag())).forEach(effectsTagList::add);
-        itemTag.put(WEAPON_EFFECTS_TAG_NAME, effectsTagList);
-        itemTag.putInt(POISON_USES_LEFT_TAG_NAME, maxUses);
+        potionContents.getAllEffects().forEach(effect -> effectsTagList.add(effect.save()));
+        CustomData.update(DataComponents.CUSTOM_DATA, itemStack, itemTag -> {
+            itemTag.put(WEAPON_EFFECTS_TAG_NAME, effectsTagList);
+            itemTag.putInt(POISON_USES_LEFT_TAG_NAME, maxUses);
+        });
     }
 
     public static boolean hasPoison(ItemStack itemStack) {
-        if (!itemStack.hasTag()) {
-            return false;
-        }
-        CompoundTag itemTag = itemStack.getOrCreateTag();
+        CompoundTag itemTag = getCustomData(itemStack);
         if (!itemTag.contains(WEAPON_EFFECTS_TAG_NAME, Tag.TAG_LIST)) {
             return false;
         }
@@ -68,7 +68,7 @@ public static boolean hasInfinitePoisonUses(ItemStack itemStack) {
     }
 
     public static int getPoisonUses(ItemStack itemStack) {
-        CompoundTag itemTag = itemStack.getOrCreateTag();
+        CompoundTag itemTag = getCustomData(itemStack);
         return itemTag.getInt(POISON_USES_LEFT_TAG_NAME);
     }
 
@@ -76,7 +76,7 @@ public static List<MobEffectInstance> getPoisonedWeaponEffects(ItemStack itemSta
         if (!hasPoison(itemStack)) {
             return List.of();
         }
-        CompoundTag itemTag = itemStack.getOrCreateTag();
+        CompoundTag itemTag = getCustomData(itemStack);
         List<MobEffectInstance> effects = new ArrayList<>();
         ListTag effectsListTag = itemTag.getList(WEAPON_EFFECTS_TAG_NAME, Tag.TAG_COMPOUND);
         effectsListTag.stream().map(CompoundTag.class::cast).map(MobEffectInstance::load).forEach(effects::add);
@@ -87,18 +87,22 @@ private static void consumePoisonStack(ItemStack itemStack) {
         if (!hasPoison(itemStack)) {
             return;
         }
-        CompoundTag itemTag = itemStack.getOrCreateTag();
         int usesLeft = getPoisonUses(itemStack) - 1;
         if (usesLeft == 0) {
             clearWeaponEffects(itemStack);
             return;
         }
-        itemTag.putInt(POISON_USES_LEFT_TAG_NAME, usesLeft);
+        CustomData.update(DataComponents.CUSTOM_DATA, itemStack, itemTag -> itemTag.putInt(POISON_USES_LEFT_TAG_NAME, usesLeft));
     }
 
     private static void clearWeaponEffects(ItemStack itemStack) {
-        CompoundTag itemTag = itemStack.getOrCreateTag();
-        itemTag.remove(WEAPON_EFFECTS_TAG_NAME);
-        itemTag.remove(POISON_USES_LEFT_TAG_NAME);
+        CustomData.update(DataComponents.CUSTOM_DATA, itemStack, itemTag -> {
+            itemTag.remove(WEAPON_EFFECTS_TAG_NAME);
+            itemTag.remove(POISON_USES_LEFT_TAG_NAME);
+        });
+    }
+
+    private static CompoundTag getCustomData(ItemStack itemStack) {
+        return itemStack.getOrDefault(DataComponents.CUSTOM_DATA, CustomData.EMPTY).copyTag();
     }
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTAttachments.java b/src/main/java/daripher/skilltree/init/PSTAttachments.java
new file mode 100644
index 000000000..92b5fc9c1
--- /dev/null
+++ b/src/main/java/daripher/skilltree/init/PSTAttachments.java
@@ -0,0 +1,17 @@
+package daripher.skilltree.init;
+
+import daripher.skilltree.SkillTreeMod;
+import daripher.skilltree.capability.skill.PlayerSkills;
+import java.util.function.Supplier;
+import net.neoforged.neoforge.attachment.AttachmentType;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.NeoForgeRegistries;
+
+public class PSTAttachments {
+  public static final DeferredRegister<AttachmentType<?>> REGISTRY =
+      DeferredRegister.create(NeoForgeRegistries.ATTACHMENT_TYPES, SkillTreeMod.MOD_ID);
+
+  public static final Supplier<AttachmentType<PlayerSkills>> PLAYER_SKILLS =
+      REGISTRY.register(
+          "player_skills", () -> AttachmentType.serializable(PlayerSkills::new).copyOnDeath().build());
+}
diff --git a/src/main/java/daripher/skilltree/init/PSTBlocks.java b/src/main/java/daripher/skilltree/init/PSTBlocks.java
index 947bd92f2..8376bf202 100644
--- a/src/main/java/daripher/skilltree/init/PSTBlocks.java
+++ b/src/main/java/daripher/skilltree/init/PSTBlocks.java
@@ -3,13 +3,13 @@
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.block.WorkbenchBlock;
 import net.minecraft.world.level.block.Block;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.ForgeRegistries;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import daripher.skilltree.util.ForgeRegistries;
 
 public class PSTBlocks {
     public static final DeferredRegister<Block> REGISTRY = DeferredRegister.create(ForgeRegistries.BLOCKS, SkillTreeMod.MOD_ID);
 
     // crafting stations
-    public static final RegistryObject<Block> WORKBENCH = REGISTRY.register("workbench", WorkbenchBlock::new);
+    public static final DeferredHolder<Block, ? extends Block> WORKBENCH = REGISTRY.register("workbench", WorkbenchBlock::new);
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTBrewingRecipes.java b/src/main/java/daripher/skilltree/init/PSTBrewingRecipes.java
index 0edf9eac6..f8e7bfd9a 100644
--- a/src/main/java/daripher/skilltree/init/PSTBrewingRecipes.java
+++ b/src/main/java/daripher/skilltree/init/PSTBrewingRecipes.java
@@ -1,57 +1,56 @@
 package daripher.skilltree.init;
 
 import daripher.skilltree.SkillTreeMod;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
 import net.minecraft.world.item.alchemy.Potion;
-import net.minecraft.world.item.alchemy.PotionUtils;
+import net.minecraft.world.item.alchemy.PotionContents;
 import net.minecraft.world.item.alchemy.Potions;
 import net.minecraft.world.item.crafting.Ingredient;
-import net.minecraftforge.common.brewing.BrewingRecipeRegistry;
-import net.minecraftforge.common.crafting.StrictNBTIngredient;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
+import net.neoforged.neoforge.common.crafting.DataComponentIngredient;
+import net.neoforged.neoforge.event.brewing.RegisterBrewingRecipesEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.fml.common.EventBusSubscriber.Bus;
 import org.jetbrains.annotations.NotNull;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Bus.GAME)
 public class PSTBrewingRecipes {
     @SubscribeEvent
-    public static void addRecipes(FMLCommonSetupEvent event) {
-        addRecipe(Potions.FIRE_RESISTANCE, Items.FERMENTED_SPIDER_EYE, PSTPotions.LIQUID_FIRE_1.get());
-        addSplashRecipe(PSTPotions.LIQUID_FIRE_1.get());
-        addLingeringRecipe(PSTPotions.LIQUID_FIRE_1.get());
-        addRecipe(PSTPotions.LIQUID_FIRE_1.get(), Items.GLOWSTONE_DUST, PSTPotions.LIQUID_FIRE_2.get());
-        addSplashRecipe(PSTPotions.LIQUID_FIRE_2.get());
-        addLingeringRecipe(PSTPotions.LIQUID_FIRE_2.get());
+    public static void addRecipes(RegisterBrewingRecipesEvent event) {
+        addRecipe(event, Potions.FIRE_RESISTANCE.value(), Items.FERMENTED_SPIDER_EYE, PSTPotions.LIQUID_FIRE_1.get());
+        addSplashRecipe(event, PSTPotions.LIQUID_FIRE_1.get());
+        addLingeringRecipe(event, PSTPotions.LIQUID_FIRE_1.get());
+        addRecipe(event, PSTPotions.LIQUID_FIRE_1.get(), Items.GLOWSTONE_DUST, PSTPotions.LIQUID_FIRE_2.get());
+        addSplashRecipe(event, PSTPotions.LIQUID_FIRE_2.get());
+        addLingeringRecipe(event, PSTPotions.LIQUID_FIRE_2.get());
     }
 
-    private static void addRecipe(Potion inputPotion, Item ingredient, @NotNull Potion outputPotion) {
+    private static void addRecipe(RegisterBrewingRecipesEvent event, Potion inputPotion, Item ingredient, @NotNull Potion outputPotion) {
         Item[] potionItems = new Item[]{Items.POTION, Items.SPLASH_POTION, Items.LINGERING_POTION};
         for (Item potionItem : potionItems) {
-            addRecipe(inputPotion, potionItem, ingredient, outputPotion, potionItem);
+            addRecipe(event, inputPotion, potionItem, ingredient, outputPotion, potionItem);
         }
     }
 
-    private static void addLingeringRecipe(@NotNull Potion potion) {
-        addRecipe(potion, Items.SPLASH_POTION, Items.DRAGON_BREATH, potion, Items.LINGERING_POTION);
+    private static void addLingeringRecipe(RegisterBrewingRecipesEvent event, @NotNull Potion potion) {
+        addRecipe(event, potion, Items.SPLASH_POTION, Items.DRAGON_BREATH, potion, Items.LINGERING_POTION);
     }
 
-    private static void addSplashRecipe(@NotNull Potion potion) {
-        addRecipe(potion, Items.POTION, Items.GUNPOWDER, potion, Items.SPLASH_POTION);
+    private static void addSplashRecipe(RegisterBrewingRecipesEvent event, @NotNull Potion potion) {
+        addRecipe(event, potion, Items.POTION, Items.GUNPOWDER, potion, Items.SPLASH_POTION);
     }
 
-    private static void addRecipe(Potion inputPotion, Item inputItem, Item ingredient, @NotNull Potion outputPotion, Item outputItem) {
+    private static void addRecipe(RegisterBrewingRecipesEvent event, Potion inputPotion, Item inputItem, Item ingredient, @NotNull Potion outputPotion, Item outputItem) {
         ItemStack input = getPotionStack(inputItem, inputPotion);
         ItemStack output = getPotionStack(outputItem, outputPotion);
-        BrewingRecipeRegistry.addRecipe(StrictNBTIngredient.of(input), Ingredient.of(ingredient), output);
+        event.getBuilder().addRecipe(DataComponentIngredient.of(true, input), Ingredient.of(ingredient), output);
     }
 
     @NotNull
     private static ItemStack getPotionStack(Item potionItem, @NotNull Potion outputPotion) {
-        ItemStack output = new ItemStack(potionItem);
-        PotionUtils.setPotion(output, outputPotion);
-        return output;
+        return PotionContents.createItemStack(potionItem, BuiltInRegistries.POTION.wrapAsHolder(outputPotion));
     }
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTCreativeTabs.java b/src/main/java/daripher/skilltree/init/PSTCreativeTabs.java
index 6356c2f0a..55cca6908 100644
--- a/src/main/java/daripher/skilltree/init/PSTCreativeTabs.java
+++ b/src/main/java/daripher/skilltree/init/PSTCreativeTabs.java
@@ -6,8 +6,8 @@
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.world.item.CreativeModeTab;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.function.Supplier;
 
@@ -22,6 +22,6 @@ public class PSTCreativeTabs {
     }
 
     private static void collectModItems(CreativeModeTab.Output output) {
-        PSTItems.REGISTRY.getEntries().stream().map(RegistryObject::get).forEach(output::accept);
+        PSTItems.REGISTRY.getEntries().stream().map(DeferredHolder::get).forEach(output::accept);
     }
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTEnchantmentCategories.java b/src/main/java/daripher/skilltree/init/PSTEnchantmentCategories.java
index 09727f53f..811f62cb7 100644
--- a/src/main/java/daripher/skilltree/init/PSTEnchantmentCategories.java
+++ b/src/main/java/daripher/skilltree/init/PSTEnchantmentCategories.java
@@ -3,7 +3,7 @@
 import daripher.skilltree.skill.bonus.predicate.item.EquipmentPredicate;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.PotionItem;
-import net.minecraft.world.item.enchantment.EnchantmentCategory;
+import daripher.skilltree.enchantment.EnchantmentCategory;
 
 public class PSTEnchantmentCategories {
     public static EnchantmentCategory SHIELD = EnchantmentCategory.create("shield", item -> EquipmentPredicate.isShield(new ItemStack(item)));
diff --git a/src/main/java/daripher/skilltree/init/PSTEventListeners.java b/src/main/java/daripher/skilltree/init/PSTEventListeners.java
index 02180faf8..db8fe65c7 100644
--- a/src/main/java/daripher/skilltree/init/PSTEventListeners.java
+++ b/src/main/java/daripher/skilltree/init/PSTEventListeners.java
@@ -4,8 +4,8 @@
 import daripher.skilltree.client.tooltip.TooltipHelper;
 import daripher.skilltree.skill.bonus.event.*;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -14,16 +14,16 @@ public class PSTEventListeners {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "event_listeners");
     public static final DeferredRegister<SkillEventListener.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<SkillEventListener.Serializer> ATTACK = REGISTRY.register("attack", OutgoingDamageEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> BLOCK = REGISTRY.register("block", ShieldBlockEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> EVASION = REGISTRY.register("evasion", EvasionEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> ITEM_USED = REGISTRY.register("item_used", ItemUseEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> DAMAGE_TAKEN = REGISTRY.register("damage_taken", IncomingDamageEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> ON_KILL = REGISTRY.register("on_kill", KillEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> SKILL_LEARNED = REGISTRY.register("skill_learned", SkillLearnedEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> SKILL_REMOVED = REGISTRY.register("skill_removed", SkillRemovedEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> TICKING = REGISTRY.register("ticking", TickingEventListener.Serializer::new);
-    public static final RegistryObject<SkillEventListener.Serializer> CRITICAL_HIT = REGISTRY.register("critical_hit", CriticalHitEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> ATTACK = REGISTRY.register("attack", OutgoingDamageEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> BLOCK = REGISTRY.register("block", ShieldBlockEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> EVASION = REGISTRY.register("evasion", EvasionEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> ITEM_USED = REGISTRY.register("item_used", ItemUseEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> DAMAGE_TAKEN = REGISTRY.register("damage_taken", IncomingDamageEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> ON_KILL = REGISTRY.register("on_kill", KillEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> SKILL_LEARNED = REGISTRY.register("skill_learned", SkillLearnedEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> SKILL_REMOVED = REGISTRY.register("skill_removed", SkillRemovedEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> TICKING = REGISTRY.register("ticking", TickingEventListener.Serializer::new);
+    public static final DeferredHolder<SkillEventListener.Serializer, ? extends SkillEventListener.Serializer> CRITICAL_HIT = REGISTRY.register("critical_hit", CriticalHitEventListener.Serializer::new);
 
     public static List<SkillEventListener> eventsList() {
         return PSTRegistries.EVENT_LISTENERS.get().getValues().stream().map(SkillEventListener.Serializer::createDefaultInstance).toList();
diff --git a/src/main/java/daripher/skilltree/init/PSTFloatFunctions.java b/src/main/java/daripher/skilltree/init/PSTFloatFunctions.java
index ffd279cc8..74a1450d7 100644
--- a/src/main/java/daripher/skilltree/init/PSTFloatFunctions.java
+++ b/src/main/java/daripher/skilltree/init/PSTFloatFunctions.java
@@ -4,8 +4,8 @@
 import daripher.skilltree.client.tooltip.TooltipHelper;
 import daripher.skilltree.skill.bonus.function.*;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -14,15 +14,15 @@ public class PSTFloatFunctions {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "numeric_value_providers");
     public static final DeferredRegister<FloatFunction.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<FloatFunction.Serializer> ATTRIBUTE_VALUE = REGISTRY.register("attribute_value", AttributeValueFunction.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> EFFECT_AMOUNT = REGISTRY.register("effect_amount", EffectAmountFunction.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> FOOD_LEVEL = REGISTRY.register("food_level", FoodLevelFunction.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> HEALTH_LEVEL = REGISTRY.register("health_level", HealthLevelFunction.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> EQUIPMENT_DURABILITY = REGISTRY.register("equipment_durability", EquipmentDurabilityFunction.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> ENCHANTMENT_AMOUNT = REGISTRY.register("enchantment_amount", EnchantmentAmountFunction.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> ENCHANTMENT_LEVELS = REGISTRY.register("enchantment_levels", EnchantmentLevelsFunction.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> DISTANCE_TO_TARGET = REGISTRY.register("distance_to_target", DistanceToTargetFunction.Serializer::new);
-    public static final RegistryObject<FloatFunction.Serializer> LEARNED_SKILLS_AMOUNT = REGISTRY.register("learned_skills_amount", LearnedSkillsNumberFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> ATTRIBUTE_VALUE = REGISTRY.register("attribute_value", AttributeValueFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> EFFECT_AMOUNT = REGISTRY.register("effect_amount", EffectAmountFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> FOOD_LEVEL = REGISTRY.register("food_level", FoodLevelFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> HEALTH_LEVEL = REGISTRY.register("health_level", HealthLevelFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> EQUIPMENT_DURABILITY = REGISTRY.register("equipment_durability", EquipmentDurabilityFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> ENCHANTMENT_AMOUNT = REGISTRY.register("enchantment_amount", EnchantmentAmountFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> ENCHANTMENT_LEVELS = REGISTRY.register("enchantment_levels", EnchantmentLevelsFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> DISTANCE_TO_TARGET = REGISTRY.register("distance_to_target", DistanceToTargetFunction.Serializer::new);
+    public static final DeferredHolder<FloatFunction.Serializer, ? extends FloatFunction.Serializer> LEARNED_SKILLS_AMOUNT = REGISTRY.register("learned_skills_amount", LearnedSkillsNumberFunction.Serializer::new);
 
     @SuppressWarnings("rawtypes")
     public static List<FloatFunction> providerList() {
diff --git a/src/main/java/daripher/skilltree/init/PSTItemBonuses.java b/src/main/java/daripher/skilltree/init/PSTItemBonuses.java
index 60294a974..f1e1d8c87 100644
--- a/src/main/java/daripher/skilltree/init/PSTItemBonuses.java
+++ b/src/main/java/daripher/skilltree/init/PSTItemBonuses.java
@@ -6,8 +6,8 @@
 import daripher.skilltree.skill.bonus.item.GroupedItemBonus;
 import daripher.skilltree.skill.bonus.item.ItemBonus;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -16,8 +16,8 @@ public class PSTItemBonuses {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "item_bonuses");
     public static final DeferredRegister<ItemBonus.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<ItemBonus.Serializer> SKILL_BONUS = REGISTRY.register("skill_bonus", EquipmentBonus.Serializer::new);
-    public static final RegistryObject<ItemBonus.Serializer> ITEM_BONUS_LIST = REGISTRY.register("item_bonus_list", GroupedItemBonus.Serializer::new);
+    public static final DeferredHolder<ItemBonus.Serializer, ? extends ItemBonus.Serializer> SKILL_BONUS = REGISTRY.register("skill_bonus", EquipmentBonus.Serializer::new);
+    public static final DeferredHolder<ItemBonus.Serializer, ? extends ItemBonus.Serializer> ITEM_BONUS_LIST = REGISTRY.register("item_bonus_list", GroupedItemBonus.Serializer::new);
 
 
     @SuppressWarnings("rawtypes")
diff --git a/src/main/java/daripher/skilltree/init/PSTItems.java b/src/main/java/daripher/skilltree/init/PSTItems.java
index 9294068c0..8d3a7f439 100644
--- a/src/main/java/daripher/skilltree/init/PSTItems.java
+++ b/src/main/java/daripher/skilltree/init/PSTItems.java
@@ -5,17 +5,17 @@
 import daripher.skilltree.item.ModBlockItem;
 import daripher.skilltree.item.WisdomScrollItem;
 import net.minecraft.world.item.Item;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.ForgeRegistries;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import daripher.skilltree.util.ForgeRegistries;
 
 public class PSTItems {
     public static final DeferredRegister<Item> REGISTRY = DeferredRegister.create(ForgeRegistries.ITEMS, SkillTreeMod.MOD_ID);
 
     // scrolls
-    public static final RegistryObject<Item> WISDOM_SCROLL = REGISTRY.register("wisdom_scroll", WisdomScrollItem::new);
-    public static final RegistryObject<Item> AMNESIA_SCROLL = REGISTRY.register("amnesia_scroll", AmnesiaScrollItem::new);
+    public static final DeferredHolder<Item, ? extends Item> WISDOM_SCROLL = REGISTRY.register("wisdom_scroll", WisdomScrollItem::new);
+    public static final DeferredHolder<Item, ? extends Item> AMNESIA_SCROLL = REGISTRY.register("amnesia_scroll", AmnesiaScrollItem::new);
 
     // blocks
-    public static final RegistryObject<Item> WORKBENCH = REGISTRY.register("workbench", () -> new ModBlockItem(PSTBlocks.WORKBENCH));
+    public static final DeferredHolder<Item, ? extends Item> WORKBENCH = REGISTRY.register("workbench", () -> new ModBlockItem(PSTBlocks.WORKBENCH));
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTLivingMultipliers.java b/src/main/java/daripher/skilltree/init/PSTLivingMultipliers.java
index 9137d994e..2bff8bc52 100644
--- a/src/main/java/daripher/skilltree/init/PSTLivingMultipliers.java
+++ b/src/main/java/daripher/skilltree/init/PSTLivingMultipliers.java
@@ -6,8 +6,8 @@
 import daripher.skilltree.skill.bonus.multiplier.LivingMultiplier;
 import daripher.skilltree.skill.bonus.multiplier.NoneLivingMultiplier;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -16,8 +16,8 @@ public class PSTLivingMultipliers {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "skill_bonus_multipliers");
     public static final DeferredRegister<LivingMultiplier.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<LivingMultiplier.Serializer> NONE = REGISTRY.register("none", NoneLivingMultiplier.Serializer::new);
-    public static final RegistryObject<LivingMultiplier.Serializer> NUMERIC_VALUE = REGISTRY.register("numeric_value", FloatFunctionMultiplier.Serializer::new);
+    public static final DeferredHolder<LivingMultiplier.Serializer, ? extends LivingMultiplier.Serializer> NONE = REGISTRY.register("none", NoneLivingMultiplier.Serializer::new);
+    public static final DeferredHolder<LivingMultiplier.Serializer, ? extends LivingMultiplier.Serializer> NUMERIC_VALUE = REGISTRY.register("numeric_value", FloatFunctionMultiplier.Serializer::new);
 
     public static List<LivingMultiplier> multiplierList() {
         return PSTRegistries.LIVING_MULTIPLIERS.get().getValues().stream().map(LivingMultiplier.Serializer::createDefaultInstance).toList();
diff --git a/src/main/java/daripher/skilltree/init/PSTLootModifiers.java b/src/main/java/daripher/skilltree/init/PSTLootModifiers.java
index fc46241c9..6c19e0301 100644
--- a/src/main/java/daripher/skilltree/init/PSTLootModifiers.java
+++ b/src/main/java/daripher/skilltree/init/PSTLootModifiers.java
@@ -1,16 +1,16 @@
 package daripher.skilltree.init;
 
-import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.loot.modifier.AddItemModifier;
 import daripher.skilltree.loot.modifier.SkillBonusesLootModifier;
-import net.minecraftforge.common.loot.IGlobalLootModifier;
-import net.minecraftforge.eventbus.api.IEventBus;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.ForgeRegistries;
+import net.neoforged.neoforge.common.loot.IGlobalLootModifier;
+import net.neoforged.bus.api.IEventBus;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.NeoForgeRegistries;
 
 public class PSTLootModifiers {
-    public static final DeferredRegister<Codec<? extends IGlobalLootModifier>> REGISTRY = DeferredRegister.create(ForgeRegistries.Keys.GLOBAL_LOOT_MODIFIER_SERIALIZERS, SkillTreeMod.MOD_ID);
+    public static final DeferredRegister<MapCodec<? extends IGlobalLootModifier>> REGISTRY = DeferredRegister.create(NeoForgeRegistries.Keys.GLOBAL_LOOT_MODIFIER_SERIALIZERS, SkillTreeMod.MOD_ID);
 
     static {
         REGISTRY.register("add_item", AddItemModifier.CODEC);
diff --git a/src/main/java/daripher/skilltree/init/PSTMenuTypes.java b/src/main/java/daripher/skilltree/init/PSTMenuTypes.java
index 2d4ed5839..0a6fdcf66 100644
--- a/src/main/java/daripher/skilltree/init/PSTMenuTypes.java
+++ b/src/main/java/daripher/skilltree/init/PSTMenuTypes.java
@@ -3,24 +3,23 @@
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.client.screen.menu.WorkbenchScreen;
 import daripher.skilltree.inventory.menu.WorkbenchMenu;
-import net.minecraft.client.gui.screens.MenuScreens;
 import net.minecraft.world.flag.FeatureFlags;
 import net.minecraft.world.inventory.MenuType;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.ForgeRegistries;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.neoforge.client.event.RegisterMenuScreensEvent;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import daripher.skilltree.util.ForgeRegistries;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = EventBusSubscriber.Bus.MOD)
 public class PSTMenuTypes {
     public static final DeferredRegister<MenuType<?>> REGISTRY = DeferredRegister.create(ForgeRegistries.MENU_TYPES, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<MenuType<WorkbenchMenu>> ARTISAN_WORKBENCH = REGISTRY.register("artisan_workbench", () -> new MenuType<>(WorkbenchMenu::new, FeatureFlags.DEFAULT_FLAGS));
+    public static final DeferredHolder<MenuType<?>, ? extends MenuType<WorkbenchMenu>> ARTISAN_WORKBENCH = REGISTRY.register("artisan_workbench", () -> new MenuType<>(WorkbenchMenu::new, FeatureFlags.DEFAULT_FLAGS));
 
     @SubscribeEvent
-    public static void clientSetup(FMLClientSetupEvent event) {
-        event.enqueueWork(() -> MenuScreens.register(ARTISAN_WORKBENCH.get(), WorkbenchScreen::new));
+    public static void registerScreens(RegisterMenuScreensEvent event) {
+        event.register(ARTISAN_WORKBENCH.get(), WorkbenchScreen::new);
     }
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTMobEffects.java b/src/main/java/daripher/skilltree/init/PSTMobEffects.java
index a54772847..42177f86f 100644
--- a/src/main/java/daripher/skilltree/init/PSTMobEffects.java
+++ b/src/main/java/daripher/skilltree/init/PSTMobEffects.java
@@ -3,12 +3,12 @@
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.effect.LiquidFireEffect;
 import net.minecraft.world.effect.MobEffect;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.ForgeRegistries;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import daripher.skilltree.util.ForgeRegistries;
 
 public class PSTMobEffects {
     public static final DeferredRegister<MobEffect> REGISTRY = DeferredRegister.create(ForgeRegistries.MOB_EFFECTS, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<MobEffect> LIQUID_FIRE = REGISTRY.register("liquid_fire", LiquidFireEffect::new);
+    public static final DeferredHolder<MobEffect, ? extends MobEffect> LIQUID_FIRE = REGISTRY.register("liquid_fire", LiquidFireEffect::new);
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTPotions.java b/src/main/java/daripher/skilltree/init/PSTPotions.java
index 67d6c3741..0223aa5af 100644
--- a/src/main/java/daripher/skilltree/init/PSTPotions.java
+++ b/src/main/java/daripher/skilltree/init/PSTPotions.java
@@ -3,13 +3,13 @@
 import daripher.skilltree.SkillTreeMod;
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.item.alchemy.Potion;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.ForgeRegistries;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import daripher.skilltree.util.ForgeRegistries;
 
 public class PSTPotions {
     public static final DeferredRegister<Potion> REGISTRY = DeferredRegister.create(ForgeRegistries.POTIONS, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<Potion> LIQUID_FIRE_1 = REGISTRY.register("liquid_fire_1", () -> new Potion(new MobEffectInstance(PSTMobEffects.LIQUID_FIRE.get())));
-    public static final RegistryObject<Potion> LIQUID_FIRE_2 = REGISTRY.register("liquid_fire_2", () -> new Potion(new MobEffectInstance(PSTMobEffects.LIQUID_FIRE.get(), 0, 1)));
+    public static final DeferredHolder<Potion, ? extends Potion> LIQUID_FIRE_1 = REGISTRY.register("liquid_fire_1", () -> new Potion(new MobEffectInstance(PSTMobEffects.LIQUID_FIRE)));
+    public static final DeferredHolder<Potion, ? extends Potion> LIQUID_FIRE_2 = REGISTRY.register("liquid_fire_2", () -> new Potion(new MobEffectInstance(PSTMobEffects.LIQUID_FIRE, 0, 1)));
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTRecipeSerializers.java b/src/main/java/daripher/skilltree/init/PSTRecipeSerializers.java
index 3a4ffd024..2d2e0e44c 100644
--- a/src/main/java/daripher/skilltree/init/PSTRecipeSerializers.java
+++ b/src/main/java/daripher/skilltree/init/PSTRecipeSerializers.java
@@ -6,15 +6,15 @@
 import daripher.skilltree.recipe.workbench.WorkbenchUpgradeBonusRecipe;
 import daripher.skilltree.recipe.workbench.WorkbenchWeaponPoisoningRecipe;
 import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.ForgeRegistries;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import daripher.skilltree.util.ForgeRegistries;
 
 public class PSTRecipeSerializers {
     public static final DeferredRegister<RecipeSerializer<?>> REGISTRY = DeferredRegister.create(ForgeRegistries.RECIPE_SERIALIZERS, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<WorkbenchUpgradeBonusRecipe.Serializer> WORKBENCH_ITEM_BONUS = REGISTRY.register("workbench_item_bonus", WorkbenchUpgradeBonusRecipe.Serializer::new);
-    public static final RegistryObject<WorkbenchCraftingRecipe.Serializer> WORKBENCH_CRAFTING = REGISTRY.register("workbench_crafting", WorkbenchCraftingRecipe.Serializer::new);
-    public static final RegistryObject<WorkbenchPotionMixingRecipe.Serializer> WORKBENCH_POTION_MIXING = REGISTRY.register("workbench_potion_mixing", WorkbenchPotionMixingRecipe.Serializer::new);
-    public static final RegistryObject<WorkbenchWeaponPoisoningRecipe.Serializer> WORKBENCH_WEAPON_POISONING = REGISTRY.register("workbench_weapon_poisoning", WorkbenchWeaponPoisoningRecipe.Serializer::new);
+    public static final DeferredHolder<RecipeSerializer<?>, ? extends WorkbenchUpgradeBonusRecipe.Serializer> WORKBENCH_ITEM_BONUS = REGISTRY.register("workbench_item_bonus", WorkbenchUpgradeBonusRecipe.Serializer::new);
+    public static final DeferredHolder<RecipeSerializer<?>, ? extends WorkbenchCraftingRecipe.Serializer> WORKBENCH_CRAFTING = REGISTRY.register("workbench_crafting", WorkbenchCraftingRecipe.Serializer::new);
+    public static final DeferredHolder<RecipeSerializer<?>, ? extends WorkbenchPotionMixingRecipe.Serializer> WORKBENCH_POTION_MIXING = REGISTRY.register("workbench_potion_mixing", WorkbenchPotionMixingRecipe.Serializer::new);
+    public static final DeferredHolder<RecipeSerializer<?>, ? extends WorkbenchWeaponPoisoningRecipe.Serializer> WORKBENCH_WEAPON_POISONING = REGISTRY.register("workbench_weapon_poisoning", WorkbenchWeaponPoisoningRecipe.Serializer::new);
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTRecipeTypes.java b/src/main/java/daripher/skilltree/init/PSTRecipeTypes.java
index 71b3f2138..7817b3cea 100644
--- a/src/main/java/daripher/skilltree/init/PSTRecipeTypes.java
+++ b/src/main/java/daripher/skilltree/init/PSTRecipeTypes.java
@@ -2,23 +2,18 @@
 
 import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.recipe.workbench.AbstractWorkbenchRecipe;
-import net.minecraft.world.item.crafting.Recipe;
 import net.minecraft.world.item.crafting.RecipeType;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.ForgeRegistries;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import daripher.skilltree.util.ForgeRegistries;
 
 public class PSTRecipeTypes {
     public static final DeferredRegister<RecipeType<?>> REGISTRY = DeferredRegister.create(ForgeRegistries.RECIPE_TYPES, SkillTreeMod.MOD_ID);
 
-    public static final RecipeType<AbstractWorkbenchRecipe> WORKBENCH = register("workbench");
-
-    private static <T extends Recipe<?>> RecipeType<T> register(final String identifier) {
-        RecipeType<T> recipeType = new RecipeType<>() {
-            public String toString() {
-                return identifier;
-            }
-        };
-        ForgeRegistries.RECIPE_TYPES.register(identifier, recipeType);
-        return recipeType;
-    }
+    public static final DeferredHolder<RecipeType<?>, RecipeType<AbstractWorkbenchRecipe>> WORKBENCH =
+            REGISTRY.register("workbench", () -> new RecipeType<>() {
+                public String toString() {
+                    return SkillTreeMod.MOD_ID + ":workbench";
+                }
+            });
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTRegistries.java b/src/main/java/daripher/skilltree/init/PSTRegistries.java
index c8b0ce71b..3e86ac2ff 100644
--- a/src/main/java/daripher/skilltree/init/PSTRegistries.java
+++ b/src/main/java/daripher/skilltree/init/PSTRegistries.java
@@ -1,7 +1,10 @@
 package daripher.skilltree.init;
 
-import daripher.skilltree.SkillTreeMod;
-import daripher.skilltree.init.predicate.*;
+import daripher.skilltree.init.predicate.PSTDamagePredicates;
+import daripher.skilltree.init.predicate.PSTEnchantmentPredicates;
+import daripher.skilltree.init.predicate.PSTItemPredicates;
+import daripher.skilltree.init.predicate.PSTLivingEntityPredicates;
+import daripher.skilltree.init.predicate.PSTMobEffectPredicates;
 import daripher.skilltree.skill.bonus.SkillBonus;
 import daripher.skilltree.skill.bonus.event.SkillEventListener;
 import daripher.skilltree.skill.bonus.function.FloatFunction;
@@ -13,45 +16,42 @@
 import daripher.skilltree.skill.bonus.predicate.item.ItemStackPredicate;
 import daripher.skilltree.skill.bonus.predicate.living.LivingEntityPredicate;
 import daripher.skilltree.skill.requirement.SkillRequirement;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.registries.IForgeRegistry;
-import net.minecraftforge.registries.NewRegistryEvent;
-import net.minecraftforge.registries.RegistryBuilder;
-
+import daripher.skilltree.util.ForgeRegistries.ForgeRegistry;
 import java.util.function.Supplier;
+import net.minecraft.core.Registry;
+import net.neoforged.neoforge.registries.DeferredRegister;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
 public class PSTRegistries {
-    public static final Supplier<IForgeRegistry<SkillBonus.Serializer>> SKILL_BONUSES = PSTSkillBonuses.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<LivingMultiplier.Serializer>> LIVING_MULTIPLIERS = PSTLivingMultipliers.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<LivingEntityPredicate.Serializer>> LIVING_CONDITIONS = PSTLivingEntityPredicates.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<DamageCondition.Serializer>> DAMAGE_CONDITIONS = PSTDamagePredicates.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<ItemStackPredicate.Serializer>> ITEM_CONDITIONS = PSTItemPredicates.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<EnchantmentCondition.Serializer>> ENCHANTMENT_CONDITIONS = PSTEnchantmentPredicates.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<SkillEventListener.Serializer>> EVENT_LISTENERS = PSTEventListeners.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<FloatFunction.Serializer>> FLOAT_FUNCTIONS = PSTFloatFunctions.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<SkillRequirement.Serializer>> SKILL_REQUIREMENTS = PSTSkillRequirements.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<ItemBonus.Serializer>> ITEM_BONUSES = PSTItemBonuses.REGISTRY.makeRegistry(RegistryBuilder::new);
-    public static final Supplier<IForgeRegistry<MobEffectPredicate.Serializer>> MOB_EFFECT_PREDICATES = PSTMobEffectPredicates.REGISTRY.makeRegistry(RegistryBuilder::new);
+    public static final Supplier<ForgeRegistry<SkillBonus.Serializer>> SKILL_BONUSES =
+            createRegistry(PSTSkillBonuses.REGISTRY);
+    public static final Supplier<ForgeRegistry<LivingMultiplier.Serializer>> LIVING_MULTIPLIERS =
+            createRegistry(PSTLivingMultipliers.REGISTRY);
+    public static final Supplier<ForgeRegistry<LivingEntityPredicate.Serializer>> LIVING_CONDITIONS =
+            createRegistry(PSTLivingEntityPredicates.REGISTRY);
+    public static final Supplier<ForgeRegistry<DamageCondition.Serializer>> DAMAGE_CONDITIONS =
+            createRegistry(PSTDamagePredicates.REGISTRY);
+    public static final Supplier<ForgeRegistry<ItemStackPredicate.Serializer>> ITEM_CONDITIONS =
+            createRegistry(PSTItemPredicates.REGISTRY);
+    public static final Supplier<ForgeRegistry<EnchantmentCondition.Serializer>>
+            ENCHANTMENT_CONDITIONS = createRegistry(PSTEnchantmentPredicates.REGISTRY);
+    public static final Supplier<ForgeRegistry<SkillEventListener.Serializer>> EVENT_LISTENERS =
+            createRegistry(PSTEventListeners.REGISTRY);
+    public static final Supplier<ForgeRegistry<FloatFunction.Serializer>> FLOAT_FUNCTIONS =
+            createRegistry(PSTFloatFunctions.REGISTRY);
+    public static final Supplier<ForgeRegistry<SkillRequirement.Serializer>> SKILL_REQUIREMENTS =
+            createRegistry(PSTSkillRequirements.REGISTRY);
+    public static final Supplier<ForgeRegistry<ItemBonus.Serializer>> ITEM_BONUSES =
+            createRegistry(PSTItemBonuses.REGISTRY);
+    public static final Supplier<ForgeRegistry<MobEffectPredicate.Serializer>> MOB_EFFECT_PREDICATES =
+            createRegistry(PSTMobEffectPredicates.REGISTRY);
 
-    @SubscribeEvent
-    public static void registerRegistries(NewRegistryEvent event) {
-        createRegistry(event, PSTSkillBonuses.REGISTRY_ID);
-        createRegistry(event, PSTLivingMultipliers.REGISTRY_ID);
-        createRegistry(event, PSTLivingEntityPredicates.REGISTRY_ID);
-        createRegistry(event, PSTDamagePredicates.REGISTRY_ID);
-        createRegistry(event, PSTItemPredicates.REGISTRY_ID);
-        createRegistry(event, PSTEnchantmentPredicates.REGISTRY_ID);
-        createRegistry(event, PSTEventListeners.REGISTRY_ID);
-        createRegistry(event, PSTFloatFunctions.REGISTRY_ID);
-        createRegistry(event, PSTSkillRequirements.REGISTRY_ID);
-        createRegistry(event, PSTItemBonuses.REGISTRY_ID);
-        createRegistry(event, PSTMobEffectPredicates.REGISTRY_ID);
+    public static void bootstrap() {
     }
 
-    private static <T> void createRegistry(NewRegistryEvent event, ResourceLocation id) {
-        event.create(new RegistryBuilder<T>().setName(id));
+    private static <T> Supplier<ForgeRegistry<T>> createRegistry(
+            DeferredRegister<T> deferredRegister) {
+        Registry<T> registry = deferredRegister.makeRegistry(builder -> {
+        });
+        return () -> new ForgeRegistry<>(registry);
     }
 }
diff --git a/src/main/java/daripher/skilltree/init/PSTSkillBonuses.java b/src/main/java/daripher/skilltree/init/PSTSkillBonuses.java
index 00a1f40fa..4aae0eaca 100644
--- a/src/main/java/daripher/skilltree/init/PSTSkillBonuses.java
+++ b/src/main/java/daripher/skilltree/init/PSTSkillBonuses.java
@@ -5,8 +5,8 @@
 import daripher.skilltree.skill.bonus.SkillBonus;
 import daripher.skilltree.skill.bonus.player.*;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -15,48 +15,48 @@ public class PSTSkillBonuses {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "skill_bonuses");
     public static final DeferredRegister<SkillBonus.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<SkillBonus.Serializer> ATTRIBUTE = REGISTRY.register("attribute", AttributeBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> COMMAND = REGISTRY.register("command", ExecuteCommandBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> DAMAGE = REGISTRY.register("damage", OutgoingDamageBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> CRIT_DAMAGE = REGISTRY.register("crit_damage", CritDamageBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> CRIT_CHANCE = REGISTRY.register("crit_chance", CritChanceBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> REPAIR_EFFICIENCY = REGISTRY.register("repair_efficiency", RepairEfficiencyBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> BLOCK_BREAK_SPEED = REGISTRY.register("block_break_speed", BlockBreakSpeedBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> FREE_ENCHANTMENT = REGISTRY.register("free_enchantment", EnchantingExperienceRefundBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> JUMP_HEIGHT = REGISTRY.register("jump_height", JumpHeightBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> INCOMING_HEALING = REGISTRY.register("incoming_healing", IncomingHealingBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> LOOT_DUPLICATION = REGISTRY.register("loot_duplication", LootAmountModifierBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> GAINED_EXPERIENCE = REGISTRY.register("gained_experience", ExperienceGainMultiplierBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> INFLICT_IGNITE = REGISTRY.register("inflict_ignite", InflictIgniteBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> ARROW_RETRIEVAL = REGISTRY.register("arrow_retrieval", ArrowRetrievalBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> HEALTH_RESERVATION = REGISTRY.register("health_reservation", HealthReservationBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> ALL_ATTRIBUTES = REGISTRY.register("all_attributes", AllAttributesBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> INFLICT_EFFECT = REGISTRY.register("inflict_effect", InflictMobEffectBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> CANT_USE_ITEM = REGISTRY.register("cant_use_item", PreventItemUsageBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> HEALING = REGISTRY.register("healing", RestoreHealthBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> INFLICT_DAMAGE = REGISTRY.register("inflict_damage", InflictDamageBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> IGNORE_EFFECT_IMMUNITY = REGISTRY.register("ignore_effect_immunity", EffectImmunityBypassBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> LETHAL_POISON = REGISTRY.register("lethal_poison", LethalPoisonBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> DAMAGE_TAKEN = REGISTRY.register("damage_taken", IncomingDamageBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> DAMAGE_AVOIDANCE = REGISTRY.register("damage_avoidance", DamageAvoidanceChanceBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> DAMAGE_CONVERSION = REGISTRY.register("damage_conversion", DamageConversionBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> GRANT_ITEM = REGISTRY.register("grant_item", GrantItemBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> EFFECT_DURATION = REGISTRY.register("effect_duration", EffectDurationBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> PROJECTILE_DUPLICATION = REGISTRY.register("projectile_duplication", ProjectileDuplicationBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> SELF_SPLASH_IMMUNE = REGISTRY.register("self_splash_immune", SelfSplashImmuneBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> PROJECTILE_SPEED = REGISTRY.register("projectile_speed", ProjectileSpeedBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> ITEM_DURABILITY_LOSS_AVOIDANCE = REGISTRY.register("item_durability_loss_avoidance", ItemDurabilityLossPreventionBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> ITEM_USAGE_SPEED = REGISTRY.register("item_usage_speed", ItemUsageSpeedBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> ITEM_USE_MOVEMENT_SPEED = REGISTRY.register("item_use_movement_speed", ItemUseMovementSpeedBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> RECIPE_UNLOCK = REGISTRY.register("recipe_unlock", RecipeUnlockBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> MORE_ITEM_BONUSES = REGISTRY.register("more_item_bonuses", ItemUpgradeLimitBonusesBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> GAIN_EXPERIENCE = REGISTRY.register("gain_experience", GrantExperienceBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> VANILLA_RECIPE_UNLOCK = REGISTRY.register("vanilla_recipe_unlock", VanillaRecipeUnlockBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> CRAFTED_ITEM_BONUS = REGISTRY.register("crafted_item_bonus", CraftedItemBonusBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> STEALTH = REGISTRY.register("stealth", StealthBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> EFFECT_IMMUNITY = REGISTRY.register("effect_immunity", EffectImmunityBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> BROKEN = REGISTRY.register("broken", BrokenSkillBonus.Serializer::new);
-    public static final RegistryObject<SkillBonus.Serializer> REMOVE_EFFECT = REGISTRY.register("remove_effect", RemoveMobEffectBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> ATTRIBUTE = REGISTRY.register("attribute", AttributeBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> COMMAND = REGISTRY.register("command", ExecuteCommandBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> DAMAGE = REGISTRY.register("damage", OutgoingDamageBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> CRIT_DAMAGE = REGISTRY.register("crit_damage", CritDamageBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> CRIT_CHANCE = REGISTRY.register("crit_chance", CritChanceBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> REPAIR_EFFICIENCY = REGISTRY.register("repair_efficiency", RepairEfficiencyBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> BLOCK_BREAK_SPEED = REGISTRY.register("block_break_speed", BlockBreakSpeedBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> FREE_ENCHANTMENT = REGISTRY.register("free_enchantment", EnchantingExperienceRefundBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> JUMP_HEIGHT = REGISTRY.register("jump_height", JumpHeightBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> INCOMING_HEALING = REGISTRY.register("incoming_healing", IncomingHealingBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> LOOT_DUPLICATION = REGISTRY.register("loot_duplication", LootAmountModifierBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> GAINED_EXPERIENCE = REGISTRY.register("gained_experience", ExperienceGainMultiplierBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> INFLICT_IGNITE = REGISTRY.register("inflict_ignite", InflictIgniteBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> ARROW_RETRIEVAL = REGISTRY.register("arrow_retrieval", ArrowRetrievalBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> HEALTH_RESERVATION = REGISTRY.register("health_reservation", HealthReservationBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> ALL_ATTRIBUTES = REGISTRY.register("all_attributes", AllAttributesBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> INFLICT_EFFECT = REGISTRY.register("inflict_effect", InflictMobEffectBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> CANT_USE_ITEM = REGISTRY.register("cant_use_item", PreventItemUsageBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> HEALING = REGISTRY.register("healing", RestoreHealthBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> INFLICT_DAMAGE = REGISTRY.register("inflict_damage", InflictDamageBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> IGNORE_EFFECT_IMMUNITY = REGISTRY.register("ignore_effect_immunity", EffectImmunityBypassBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> LETHAL_POISON = REGISTRY.register("lethal_poison", LethalPoisonBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> DAMAGE_TAKEN = REGISTRY.register("damage_taken", IncomingDamageBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> DAMAGE_AVOIDANCE = REGISTRY.register("damage_avoidance", DamageAvoidanceChanceBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> DAMAGE_CONVERSION = REGISTRY.register("damage_conversion", DamageConversionBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> GRANT_ITEM = REGISTRY.register("grant_item", GrantItemBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> EFFECT_DURATION = REGISTRY.register("effect_duration", EffectDurationBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> PROJECTILE_DUPLICATION = REGISTRY.register("projectile_duplication", ProjectileDuplicationBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> SELF_SPLASH_IMMUNE = REGISTRY.register("self_splash_immune", SelfSplashImmuneBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> PROJECTILE_SPEED = REGISTRY.register("projectile_speed", ProjectileSpeedBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> ITEM_DURABILITY_LOSS_AVOIDANCE = REGISTRY.register("item_durability_loss_avoidance", ItemDurabilityLossPreventionBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> ITEM_USAGE_SPEED = REGISTRY.register("item_usage_speed", ItemUsageSpeedBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> ITEM_USE_MOVEMENT_SPEED = REGISTRY.register("item_use_movement_speed", ItemUseMovementSpeedBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> RECIPE_UNLOCK = REGISTRY.register("recipe_unlock", RecipeUnlockBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> MORE_ITEM_BONUSES = REGISTRY.register("more_item_bonuses", ItemUpgradeLimitBonusesBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> GAIN_EXPERIENCE = REGISTRY.register("gain_experience", GrantExperienceBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> VANILLA_RECIPE_UNLOCK = REGISTRY.register("vanilla_recipe_unlock", VanillaRecipeUnlockBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> CRAFTED_ITEM_BONUS = REGISTRY.register("crafted_item_bonus", CraftedItemBonusBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> STEALTH = REGISTRY.register("stealth", StealthBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> EFFECT_IMMUNITY = REGISTRY.register("effect_immunity", EffectImmunityBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> BROKEN = REGISTRY.register("broken", BrokenSkillBonus.Serializer::new);
+    public static final DeferredHolder<SkillBonus.Serializer, ? extends SkillBonus.Serializer> REMOVE_EFFECT = REGISTRY.register("remove_effect", RemoveMobEffectBonus.Serializer::new);
 
     @SuppressWarnings("rawtypes")
     public static List<SkillBonus> defaultInstances() {
diff --git a/src/main/java/daripher/skilltree/init/PSTSkillRequirements.java b/src/main/java/daripher/skilltree/init/PSTSkillRequirements.java
index 9e587a0d2..c344650c6 100644
--- a/src/main/java/daripher/skilltree/init/PSTSkillRequirements.java
+++ b/src/main/java/daripher/skilltree/init/PSTSkillRequirements.java
@@ -4,8 +4,8 @@
 import daripher.skilltree.client.tooltip.TooltipHelper;
 import daripher.skilltree.skill.requirement.*;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -14,10 +14,10 @@ public class PSTSkillRequirements {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "skill_requirements");
     public static final DeferredRegister<SkillRequirement.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<SkillRequirement.Serializer> STAT_VALUE = REGISTRY.register("stat_value", StatRequirement.Serializer::new);
-    public static final RegistryObject<SkillRequirement.Serializer> NUMERIC_VALUE = REGISTRY.register("numeric_value", NumericValueRequirement.Serializer::new);
-    public static final RegistryObject<SkillRequirement.Serializer> ADVANCEMENT = REGISTRY.register("advancement", AdvancementRequirement.Serializer::new);
-    public static final RegistryObject<SkillRequirement.Serializer> LEARNED_SKILL = REGISTRY.register("learned_skill", LearnedSkillRequirement.Serializer::new);
+    public static final DeferredHolder<SkillRequirement.Serializer, ? extends SkillRequirement.Serializer> STAT_VALUE = REGISTRY.register("stat_value", StatRequirement.Serializer::new);
+    public static final DeferredHolder<SkillRequirement.Serializer, ? extends SkillRequirement.Serializer> NUMERIC_VALUE = REGISTRY.register("numeric_value", NumericValueRequirement.Serializer::new);
+    public static final DeferredHolder<SkillRequirement.Serializer, ? extends SkillRequirement.Serializer> ADVANCEMENT = REGISTRY.register("advancement", AdvancementRequirement.Serializer::new);
+    public static final DeferredHolder<SkillRequirement.Serializer, ? extends SkillRequirement.Serializer> LEARNED_SKILL = REGISTRY.register("learned_skill", LearnedSkillRequirement.Serializer::new);
 
     @SuppressWarnings("rawtypes")
     public static List<SkillRequirement> requirementList() {
diff --git a/src/main/java/daripher/skilltree/init/PSTTags.java b/src/main/java/daripher/skilltree/init/PSTTags.java
index 489be9ce7..8fb5a51f0 100644
--- a/src/main/java/daripher/skilltree/init/PSTTags.java
+++ b/src/main/java/daripher/skilltree/init/PSTTags.java
@@ -1,21 +1,21 @@
 package daripher.skilltree.init;
 
-import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.tags.ItemTags;
 import net.minecraft.tags.TagKey;
 import net.minecraft.world.damagesource.DamageType;
 import net.minecraft.world.item.Item;
+import net.neoforged.neoforge.common.Tags;
 
 public class PSTTags {
     public static class DamageTypes {
-        public static final TagKey<DamageType> IS_MAGIC = TagKey.create(Registries.DAMAGE_TYPE, ResourceLocation.fromNamespaceAndPath("forge", "is_magic"));
+        public static final TagKey<DamageType> IS_MAGIC = Tags.DamageTypes.IS_MAGIC;
     }
 
     public static class Items {
         public static final TagKey<Item> RINGS = ItemTags.create(ResourceLocation.fromNamespaceAndPath("curios", "ring"));
         public static final TagKey<Item> NECKLACES = ItemTags.create(ResourceLocation.fromNamespaceAndPath("curios", "necklace"));
-        public static final TagKey<Item> JEWELRY = ItemTags.create(ResourceLocation.fromNamespaceAndPath("forge", "curios/jewelry"));
+        public static final TagKey<Item> JEWELRY = ItemTags.create(ResourceLocation.fromNamespaceAndPath("curios", "jewelry"));
         public static final TagKey<Item> MELEE_WEAPON = ItemTags.create(ResourceLocation.fromNamespaceAndPath("skilltree", "melee_weapon"));
         public static final TagKey<Item> RANGED_WEAPON = ItemTags.create(ResourceLocation.fromNamespaceAndPath("skilltree", "ranged_weapon"));
         public static final TagKey<Item> LEATHER_ARMOR = ItemTags.create(ResourceLocation.fromNamespaceAndPath("skilltree", "armors/leather"));
diff --git a/src/main/java/daripher/skilltree/init/client/PSTKeybinds.java b/src/main/java/daripher/skilltree/init/client/PSTKeybinds.java
index dc24b5ede..6e6386154 100644
--- a/src/main/java/daripher/skilltree/init/client/PSTKeybinds.java
+++ b/src/main/java/daripher/skilltree/init/client/PSTKeybinds.java
@@ -11,12 +11,12 @@
 import net.minecraft.client.KeyMapping;
 import net.minecraft.client.Minecraft;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.InputEvent;
-import net.minecraftforge.client.event.RegisterKeyMappingsEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber.Bus;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.neoforge.client.event.InputEvent;
+import net.neoforged.neoforge.client.event.RegisterKeyMappingsEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.fml.common.EventBusSubscriber.Bus;
 import org.lwjgl.glfw.GLFW;
 
 @EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Bus.MOD, value = Dist.CLIENT)
diff --git a/src/main/java/daripher/skilltree/init/predicate/PSTDamagePredicates.java b/src/main/java/daripher/skilltree/init/predicate/PSTDamagePredicates.java
index 364273cf6..4c2a2efa2 100644
--- a/src/main/java/daripher/skilltree/init/predicate/PSTDamagePredicates.java
+++ b/src/main/java/daripher/skilltree/init/predicate/PSTDamagePredicates.java
@@ -5,8 +5,8 @@
 import daripher.skilltree.init.PSTRegistries;
 import daripher.skilltree.skill.bonus.predicate.damage.*;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -15,14 +15,14 @@ public class PSTDamagePredicates {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "damage_conditions");
     public static final DeferredRegister<DamageCondition.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<DamageCondition.Serializer> NONE = REGISTRY.register("none", NoneDamageCondition.Serializer::new);
-    public static final RegistryObject<DamageCondition.Serializer> PROJECTILE = REGISTRY.register("projectile", ProjectileDamageCondition.Serializer::new);
-    public static final RegistryObject<DamageCondition.Serializer> MELEE = REGISTRY.register("melee", MeleeDamageCondition.Serializer::new);
-    public static final RegistryObject<DamageCondition.Serializer> MAGIC = REGISTRY.register("magic", MagicDamageCondition.Serializer::new);
-    public static final RegistryObject<DamageCondition.Serializer> FALL = REGISTRY.register("fall", FallDamageCondition.Serializer::new);
-    public static final RegistryObject<DamageCondition.Serializer> FIRE = REGISTRY.register("fire", FireDamageCondition.Serializer::new);
-    public static final RegistryObject<DamageCondition.Serializer> POISON = REGISTRY.register("poison", PoisonDamageCondition.Serializer::new);
-    public static final RegistryObject<DamageCondition.Serializer> THORNS = REGISTRY.register("thorns", ThornsDamageCondition.Serializer::new);
+    public static final DeferredHolder<DamageCondition.Serializer, ? extends DamageCondition.Serializer> NONE = REGISTRY.register("none", NoneDamageCondition.Serializer::new);
+    public static final DeferredHolder<DamageCondition.Serializer, ? extends DamageCondition.Serializer> PROJECTILE = REGISTRY.register("projectile", ProjectileDamageCondition.Serializer::new);
+    public static final DeferredHolder<DamageCondition.Serializer, ? extends DamageCondition.Serializer> MELEE = REGISTRY.register("melee", MeleeDamageCondition.Serializer::new);
+    public static final DeferredHolder<DamageCondition.Serializer, ? extends DamageCondition.Serializer> MAGIC = REGISTRY.register("magic", MagicDamageCondition.Serializer::new);
+    public static final DeferredHolder<DamageCondition.Serializer, ? extends DamageCondition.Serializer> FALL = REGISTRY.register("fall", FallDamageCondition.Serializer::new);
+    public static final DeferredHolder<DamageCondition.Serializer, ? extends DamageCondition.Serializer> FIRE = REGISTRY.register("fire", FireDamageCondition.Serializer::new);
+    public static final DeferredHolder<DamageCondition.Serializer, ? extends DamageCondition.Serializer> POISON = REGISTRY.register("poison", PoisonDamageCondition.Serializer::new);
+    public static final DeferredHolder<DamageCondition.Serializer, ? extends DamageCondition.Serializer> THORNS = REGISTRY.register("thorns", ThornsDamageCondition.Serializer::new);
 
     public static List<DamageCondition> conditionsList() {
         return PSTRegistries.DAMAGE_CONDITIONS.get().getValues().stream().map(DamageCondition.Serializer::createDefaultInstance).toList();
diff --git a/src/main/java/daripher/skilltree/init/predicate/PSTEnchantmentPredicates.java b/src/main/java/daripher/skilltree/init/predicate/PSTEnchantmentPredicates.java
index f2d63c7c5..af2d05f0a 100644
--- a/src/main/java/daripher/skilltree/init/predicate/PSTEnchantmentPredicates.java
+++ b/src/main/java/daripher/skilltree/init/predicate/PSTEnchantmentPredicates.java
@@ -8,8 +8,8 @@
 import daripher.skilltree.skill.bonus.predicate.enchantment.NoneEnchantmentCondition;
 import daripher.skilltree.skill.bonus.predicate.enchantment.WeaponEnchantmentCondition;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -18,9 +18,9 @@ public class PSTEnchantmentPredicates {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "enchantment_conditions");
     public static final DeferredRegister<EnchantmentCondition.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<EnchantmentCondition.Serializer> NONE = REGISTRY.register("none", NoneEnchantmentCondition.Serializer::new);
-    public static final RegistryObject<EnchantmentCondition.Serializer> ARMOR = REGISTRY.register("armor", ArmorEnchantmentCondition.Serializer::new);
-    public static final RegistryObject<EnchantmentCondition.Serializer> WEAPON = REGISTRY.register("weapon", WeaponEnchantmentCondition.Serializer::new);
+    public static final DeferredHolder<EnchantmentCondition.Serializer, ? extends EnchantmentCondition.Serializer> NONE = REGISTRY.register("none", NoneEnchantmentCondition.Serializer::new);
+    public static final DeferredHolder<EnchantmentCondition.Serializer, ? extends EnchantmentCondition.Serializer> ARMOR = REGISTRY.register("armor", ArmorEnchantmentCondition.Serializer::new);
+    public static final DeferredHolder<EnchantmentCondition.Serializer, ? extends EnchantmentCondition.Serializer> WEAPON = REGISTRY.register("weapon", WeaponEnchantmentCondition.Serializer::new);
 
     public static List<EnchantmentCondition> conditionsList() {
         return PSTRegistries.ENCHANTMENT_CONDITIONS.get().getValues().stream().map(EnchantmentCondition.Serializer::createDefaultInstance)
diff --git a/src/main/java/daripher/skilltree/init/predicate/PSTItemPredicates.java b/src/main/java/daripher/skilltree/init/predicate/PSTItemPredicates.java
index e053085ab..c05f52748 100644
--- a/src/main/java/daripher/skilltree/init/predicate/PSTItemPredicates.java
+++ b/src/main/java/daripher/skilltree/init/predicate/PSTItemPredicates.java
@@ -5,8 +5,8 @@
 import daripher.skilltree.init.PSTRegistries;
 import daripher.skilltree.skill.bonus.predicate.item.*;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -15,13 +15,13 @@ public class PSTItemPredicates {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "item_conditions");
     public static final DeferredRegister<ItemStackPredicate.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<ItemStackPredicate.Serializer> NONE = REGISTRY.register("none", NoneItemStackPredicate.Serializer::new);
-    public static final RegistryObject<ItemStackPredicate.Serializer> POTIONS = REGISTRY.register("potion", PotionStackPredicate.Serializer::new);
-    public static final RegistryObject<ItemStackPredicate.Serializer> FOOD = REGISTRY.register("food", FoodStackPredicate.Serializer::new);
-    public static final RegistryObject<ItemStackPredicate.Serializer> ITEM_ID = REGISTRY.register("item_id", ItemIdPredicate.Serializer::new);
-    public static final RegistryObject<ItemStackPredicate.Serializer> ENCHANTED = REGISTRY.register("enchanted", EnchantedStackPredicate.Serializer::new);
-    public static final RegistryObject<ItemStackPredicate.Serializer> TAG = REGISTRY.register("tag", ItemTagPredicate.Serializer::new);
-    public static final RegistryObject<ItemStackPredicate.Serializer> EQUIPMENT_TYPE = REGISTRY.register("equipment_type", EquipmentPredicate.Serializer::new);
+    public static final DeferredHolder<ItemStackPredicate.Serializer, ? extends ItemStackPredicate.Serializer> NONE = REGISTRY.register("none", NoneItemStackPredicate.Serializer::new);
+    public static final DeferredHolder<ItemStackPredicate.Serializer, ? extends ItemStackPredicate.Serializer> POTIONS = REGISTRY.register("potion", PotionStackPredicate.Serializer::new);
+    public static final DeferredHolder<ItemStackPredicate.Serializer, ? extends ItemStackPredicate.Serializer> FOOD = REGISTRY.register("food", FoodStackPredicate.Serializer::new);
+    public static final DeferredHolder<ItemStackPredicate.Serializer, ? extends ItemStackPredicate.Serializer> ITEM_ID = REGISTRY.register("item_id", ItemIdPredicate.Serializer::new);
+    public static final DeferredHolder<ItemStackPredicate.Serializer, ? extends ItemStackPredicate.Serializer> ENCHANTED = REGISTRY.register("enchanted", EnchantedStackPredicate.Serializer::new);
+    public static final DeferredHolder<ItemStackPredicate.Serializer, ? extends ItemStackPredicate.Serializer> TAG = REGISTRY.register("tag", ItemTagPredicate.Serializer::new);
+    public static final DeferredHolder<ItemStackPredicate.Serializer, ? extends ItemStackPredicate.Serializer> EQUIPMENT_TYPE = REGISTRY.register("equipment_type", EquipmentPredicate.Serializer::new);
 
     public static List<ItemStackPredicate> conditionsList() {
         return PSTRegistries.ITEM_CONDITIONS.get().getValues().stream().map(ItemStackPredicate.Serializer::createDefaultInstance).toList();
diff --git a/src/main/java/daripher/skilltree/init/predicate/PSTLivingEntityPredicates.java b/src/main/java/daripher/skilltree/init/predicate/PSTLivingEntityPredicates.java
index b6edf286f..aff0066e1 100644
--- a/src/main/java/daripher/skilltree/init/predicate/PSTLivingEntityPredicates.java
+++ b/src/main/java/daripher/skilltree/init/predicate/PSTLivingEntityPredicates.java
@@ -5,8 +5,8 @@
 import daripher.skilltree.init.PSTRegistries;
 import daripher.skilltree.skill.bonus.predicate.living.*;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -15,18 +15,18 @@ public class PSTLivingEntityPredicates {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "living_conditions");
     public static final DeferredRegister<LivingEntityPredicate.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<LivingEntityPredicate.Serializer> NONE = REGISTRY.register("none", NoneLivingEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> HAS_ITEM_EQUIPPED = REGISTRY.register("has_item_equipped", HasItemEquippedEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> HAS_EFFECT = REGISTRY.register("has_effect", HasEffectEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> BURNING = REGISTRY.register("burning", BurningEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> FISHING = REGISTRY.register("fishing", FishingEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> UNDERWATER = REGISTRY.register("underwater", UnderwaterEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> DUAL_WIELDING = REGISTRY.register("dual_wielding", DualWieldingEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> HAS_ITEM_IN_HAND = REGISTRY.register("has_item_in_hand", HasItemInHandEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> CROUCHING = REGISTRY.register("crouching", CrouchingEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> UNARMED = REGISTRY.register("unarmed", UnarmedEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> NUMERIC_VALUE = REGISTRY.register("numeric_value", FloatFunctionEntityPredicate.Serializer::new);
-    public static final RegistryObject<LivingEntityPredicate.Serializer> ALL_ARMOR = REGISTRY.register("all_armor", AllArmorEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> NONE = REGISTRY.register("none", NoneLivingEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> HAS_ITEM_EQUIPPED = REGISTRY.register("has_item_equipped", HasItemEquippedEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> HAS_EFFECT = REGISTRY.register("has_effect", HasEffectEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> BURNING = REGISTRY.register("burning", BurningEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> FISHING = REGISTRY.register("fishing", FishingEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> UNDERWATER = REGISTRY.register("underwater", UnderwaterEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> DUAL_WIELDING = REGISTRY.register("dual_wielding", DualWieldingEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> HAS_ITEM_IN_HAND = REGISTRY.register("has_item_in_hand", HasItemInHandEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> CROUCHING = REGISTRY.register("crouching", CrouchingEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> UNARMED = REGISTRY.register("unarmed", UnarmedEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> NUMERIC_VALUE = REGISTRY.register("numeric_value", FloatFunctionEntityPredicate.Serializer::new);
+    public static final DeferredHolder<LivingEntityPredicate.Serializer, ? extends LivingEntityPredicate.Serializer> ALL_ARMOR = REGISTRY.register("all_armor", AllArmorEntityPredicate.Serializer::new);
 
     public static List<LivingEntityPredicate> conditionsList() {
         return PSTRegistries.LIVING_CONDITIONS.get().getValues().stream().map(LivingEntityPredicate.Serializer::createDefaultInstance)
diff --git a/src/main/java/daripher/skilltree/init/predicate/PSTMobEffectPredicates.java b/src/main/java/daripher/skilltree/init/predicate/PSTMobEffectPredicates.java
index 726c9490f..0ecd9bef7 100644
--- a/src/main/java/daripher/skilltree/init/predicate/PSTMobEffectPredicates.java
+++ b/src/main/java/daripher/skilltree/init/predicate/PSTMobEffectPredicates.java
@@ -8,8 +8,8 @@
 import daripher.skilltree.skill.bonus.predicate.effect.MobEffectTypePredicate;
 import daripher.skilltree.skill.bonus.predicate.effect.NoneMobEffectPredicate;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.DeferredRegister;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 import java.util.List;
 import java.util.Objects;
@@ -18,9 +18,9 @@ public class PSTMobEffectPredicates {
     public static final ResourceLocation REGISTRY_ID = ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "mob_effect_conditions");
     public static final DeferredRegister<MobEffectPredicate.Serializer> REGISTRY = DeferredRegister.create(REGISTRY_ID, SkillTreeMod.MOD_ID);
 
-    public static final RegistryObject<MobEffectPredicate.Serializer> NONE = REGISTRY.register("none", NoneMobEffectPredicate.Serializer::new);
-    public static final RegistryObject<MobEffectPredicate.Serializer> EFFECT_CATEGORY = REGISTRY.register("effect_category", MobEffectTypePredicate.Serializer::new);
-    public static final RegistryObject<MobEffectPredicate.Serializer> EFFECT_ID = REGISTRY.register("effect_id", MobEffectIdPredicate.Serializer::new);
+    public static final DeferredHolder<MobEffectPredicate.Serializer, ? extends MobEffectPredicate.Serializer> NONE = REGISTRY.register("none", NoneMobEffectPredicate.Serializer::new);
+    public static final DeferredHolder<MobEffectPredicate.Serializer, ? extends MobEffectPredicate.Serializer> EFFECT_CATEGORY = REGISTRY.register("effect_category", MobEffectTypePredicate.Serializer::new);
+    public static final DeferredHolder<MobEffectPredicate.Serializer, ? extends MobEffectPredicate.Serializer> EFFECT_ID = REGISTRY.register("effect_id", MobEffectIdPredicate.Serializer::new);
 
     public static List<MobEffectPredicate> defaultInstances() {
         return PSTRegistries.MOB_EFFECT_PREDICATES.get().getValues().stream().map(MobEffectPredicate.Serializer::createDefaultInstance)
diff --git a/src/main/java/daripher/skilltree/inventory/menu/WorkbenchContainer.java b/src/main/java/daripher/skilltree/inventory/menu/WorkbenchContainer.java
index 25c348057..b10505c9c 100644
--- a/src/main/java/daripher/skilltree/inventory/menu/WorkbenchContainer.java
+++ b/src/main/java/daripher/skilltree/inventory/menu/WorkbenchContainer.java
@@ -4,11 +4,12 @@
 import net.minecraft.world.inventory.TransientCraftingContainer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.crafting.RecipeInput;
 
 import java.util.HashMap;
 import java.util.Map;
 
-public class WorkbenchContainer extends TransientCraftingContainer {
+public class WorkbenchContainer extends TransientCraftingContainer implements RecipeInput {
     public final WorkbenchMenu menu;
 
     public WorkbenchContainer(WorkbenchMenu menu) {
@@ -24,6 +25,11 @@ public ItemStack getBaseItem() {
         return getItem(0);
     }
 
+    @Override
+    public int size() {
+        return getContainerSize();
+    }
+
     public boolean hasIngredients(Map<Ingredient, Integer> ingredients) {
         Map<Ingredient, Integer> remaining = new HashMap<>(ingredients);
         for (int i = 1; i < getContainerSize(); i++) {
diff --git a/src/main/java/daripher/skilltree/inventory/menu/WorkbenchMenu.java b/src/main/java/daripher/skilltree/inventory/menu/WorkbenchMenu.java
index 5ea718825..687e7c496 100644
--- a/src/main/java/daripher/skilltree/inventory/menu/WorkbenchMenu.java
+++ b/src/main/java/daripher/skilltree/inventory/menu/WorkbenchMenu.java
@@ -16,6 +16,7 @@
 import net.minecraft.world.inventory.*;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.CraftingRecipe;
+import net.minecraft.world.item.crafting.RecipeHolder;
 import net.minecraft.world.item.crafting.RecipeType;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.NotNull;
@@ -164,7 +165,7 @@ private void updateSelectedRecipe() {
             updateCraftingResult(selectedRecipe);
             return;
         }
-        if (!ItemStack.isSameItemSameTags(input, prevInput)) {
+        if (!ItemStack.isSameItemSameComponents(input, prevInput)) {
             setupRecipeList();
             prevInput = input.copy();
         }
@@ -185,7 +186,7 @@ private void updateCraftingResult(AbstractWorkbenchRecipe selectedRecipe) {
             if (!level.isClientSide) {
                 ItemStack craftResult = selectedRecipe.assemble(workbenchContainer, level.registryAccess());
                 addCraftingBonuses(craftResult);
-                resultSlots.setRecipeUsed(selectedRecipe);
+                resultSlots.setRecipeUsed(new RecipeHolder<>(selectedRecipe.getId(), selectedRecipe));
                 resultSlots.setItem(0, craftResult);
             }
         }
@@ -206,14 +207,18 @@ private List<AbstractWorkbenchRecipe> getAllWorkbenchRecipes() {
         if (!WORKBENCH_RECIPE_CACHE.isEmpty()) {
             return WORKBENCH_RECIPE_CACHE;
         }
-        List<CraftingRecipe> vanillaCraftingRecipes = level.getRecipeManager().getAllRecipesFor(RecipeType.CRAFTING).stream()
-                .filter(recipe -> !recipe.getResultItem(level.registryAccess()).isEmpty()).toList();
-        WORKBENCH_RECIPE_CACHE.addAll(level.getRecipeManager().getAllRecipesFor(PSTRecipeTypes.WORKBENCH));
+        List<RecipeHolder<CraftingRecipe>> vanillaCraftingRecipes = level.getRecipeManager()
+                .getAllRecipesFor(RecipeType.CRAFTING).stream()
+                .filter(recipe -> !recipe.value().getResultItem(level.registryAccess()).isEmpty()).toList();
+        WORKBENCH_RECIPE_CACHE.addAll(level.getRecipeManager()
+                .getAllRecipesFor(PSTRecipeTypes.WORKBENCH.get()).stream()
+                .map(RecipeHolder::value)
+                .toList());
         WORKBENCH_RECIPE_CACHE.addAll(vanillaCraftingRecipes.stream().map(this::convertVanillaRecipe).toList());
         return WORKBENCH_RECIPE_CACHE;
     }
 
-    private AbstractWorkbenchRecipe convertVanillaRecipe(CraftingRecipe craftingRecipe) {
+    private AbstractWorkbenchRecipe convertVanillaRecipe(RecipeHolder<CraftingRecipe> craftingRecipe) {
         return new WorkbenchVanillaCraftingRecipe(craftingRecipe, level.registryAccess());
     }
 
diff --git a/src/main/java/daripher/skilltree/inventory/slot/WorkbenchResultSlot.java b/src/main/java/daripher/skilltree/inventory/slot/WorkbenchResultSlot.java
index bbd6a2df9..9d3115375 100644
--- a/src/main/java/daripher/skilltree/inventory/slot/WorkbenchResultSlot.java
+++ b/src/main/java/daripher/skilltree/inventory/slot/WorkbenchResultSlot.java
@@ -7,7 +7,7 @@
 import net.minecraft.world.inventory.Slot;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.Ingredient;
-import net.minecraftforge.event.ForgeEventFactory;
+import net.neoforged.neoforge.event.EventHooks;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
@@ -80,7 +80,7 @@ protected void onSwapCraft(int numItemsCrafted) {
     protected void checkTakeAchievements(@NotNull ItemStack itemStack) {
         if (removeCount > 0) {
             itemStack.onCraftedBy(player.level(), player, removeCount);
-            ForgeEventFactory.firePlayerCraftingEvent(player, itemStack, workbenchContainer);
+            EventHooks.firePlayerCraftingEvent(player, itemStack, workbenchContainer);
             consumeMaterials();
         }
         removeCount = 0;
diff --git a/src/main/java/daripher/skilltree/item/AmnesiaScrollItem.java b/src/main/java/daripher/skilltree/item/AmnesiaScrollItem.java
index 2a2242d65..fd0f11d76 100644
--- a/src/main/java/daripher/skilltree/item/AmnesiaScrollItem.java
+++ b/src/main/java/daripher/skilltree/item/AmnesiaScrollItem.java
@@ -3,8 +3,6 @@
 import daripher.skilltree.capability.skill.IPlayerSkills;
 import daripher.skilltree.capability.skill.PlayerSkillsProvider;
 import daripher.skilltree.config.ServerConfig;
-import daripher.skilltree.network.NetworkDispatcher;
-import daripher.skilltree.network.message.SyncPlayerSkillsMessage;
 import net.minecraft.ChatFormatting;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
@@ -16,7 +14,6 @@
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.TooltipFlag;
 import net.minecraft.world.level.Level;
-import net.minecraftforge.network.PacketDistributor;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
@@ -41,13 +38,17 @@ public AmnesiaScrollItem() {
             skills.resetTree((ServerPlayer) player);
             skills.setSkillPoints((int) (skills.getSkillPoints() * (1 - ServerConfig.amnesia_scroll_penalty)));
             player.sendSystemMessage(Component.translatable("skilltree.message.reset_command").withStyle(ChatFormatting.YELLOW));
-            NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), new SyncPlayerSkillsMessage(player));
+            PlayerSkillsProvider.sendPlayerSkills((ServerPlayer) player);
         }
         return InteractionResultHolder.sidedSuccess(scroll, level.isClientSide);
     }
 
     @Override
-    public void appendHoverText(@NotNull ItemStack itemStack, Level level, List<Component> components, @NotNull TooltipFlag tooltipFlag) {
+    public void appendHoverText(
+            @NotNull ItemStack itemStack,
+            Item.TooltipContext context,
+            List<Component> components,
+            @NotNull TooltipFlag tooltipFlag) {
         components.add(Component.translatable(getDescriptionId() + ".tooltip").withStyle(ChatFormatting.GOLD));
         double penalty = ServerConfig.amnesia_scroll_penalty;
         if (penalty > 0) {
diff --git a/src/main/java/daripher/skilltree/item/ModBlockItem.java b/src/main/java/daripher/skilltree/item/ModBlockItem.java
index 1c7f87461..bb5c54755 100644
--- a/src/main/java/daripher/skilltree/item/ModBlockItem.java
+++ b/src/main/java/daripher/skilltree/item/ModBlockItem.java
@@ -2,10 +2,10 @@
 
 import net.minecraft.world.item.BlockItem;
 import net.minecraft.world.level.block.Block;
-import net.minecraftforge.registries.RegistryObject;
+import net.neoforged.neoforge.registries.DeferredHolder;
 
 public class ModBlockItem extends BlockItem {
-    public ModBlockItem(RegistryObject<Block> blockRegistryObject) {
+    public ModBlockItem(DeferredHolder<Block, ? extends Block> blockRegistryObject) {
         super(blockRegistryObject.get(), new Properties());
     }
 }
diff --git a/src/main/java/daripher/skilltree/item/WisdomScrollItem.java b/src/main/java/daripher/skilltree/item/WisdomScrollItem.java
index 3f50b5493..4cebfe06a 100644
--- a/src/main/java/daripher/skilltree/item/WisdomScrollItem.java
+++ b/src/main/java/daripher/skilltree/item/WisdomScrollItem.java
@@ -3,8 +3,6 @@
 import daripher.skilltree.capability.skill.IPlayerSkills;
 import daripher.skilltree.capability.skill.PlayerSkillsProvider;
 import daripher.skilltree.config.ServerConfig;
-import daripher.skilltree.network.NetworkDispatcher;
-import daripher.skilltree.network.message.SyncPlayerSkillsMessage;
 import net.minecraft.ChatFormatting;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
@@ -16,7 +14,6 @@
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.TooltipFlag;
 import net.minecraft.world.level.Level;
-import net.minecraftforge.network.PacketDistributor;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
@@ -43,7 +40,7 @@ public WisdomScrollItem() {
             level.playSound(null, player, SoundEvents.PLAYER_LEVELUP, player.getSoundSource(), 0.4F, 0.2F + player.getRandom()
                     .nextFloat() * 0.3F);
             skillsCapability.grantSkillPoints(1);
-            NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), new SyncPlayerSkillsMessage(player));
+            PlayerSkillsProvider.sendPlayerSkills((ServerPlayer) player);
             if (ServerConfig.show_chat_messages) {
                 player.sendSystemMessage(Component.translatable("skilltree.message.point_command").withStyle(ChatFormatting.YELLOW));
             }
@@ -52,7 +49,11 @@ public WisdomScrollItem() {
     }
 
     @Override
-    public void appendHoverText(@NotNull ItemStack itemStack, Level level, List<Component> components, @NotNull TooltipFlag tooltipFlag) {
+    public void appendHoverText(
+            @NotNull ItemStack itemStack,
+            Item.TooltipContext context,
+            List<Component> components,
+            @NotNull TooltipFlag tooltipFlag) {
         components.add(Component.translatable(getDescriptionId() + ".tooltip").withStyle(ChatFormatting.GOLD));
     }
 }
diff --git a/src/main/java/daripher/skilltree/loot/modifier/AddItemModifier.java b/src/main/java/daripher/skilltree/loot/modifier/AddItemModifier.java
index cfa2c8dd0..cf6371d53 100644
--- a/src/main/java/daripher/skilltree/loot/modifier/AddItemModifier.java
+++ b/src/main/java/daripher/skilltree/loot/modifier/AddItemModifier.java
@@ -1,14 +1,13 @@
 package daripher.skilltree.loot.modifier;
 
 import com.google.common.base.Suppliers;
-import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.storage.loot.LootContext;
 import net.minecraft.world.level.storage.loot.predicates.LootItemCondition;
-import net.minecraftforge.common.loot.IGlobalLootModifier;
-import net.minecraftforge.common.loot.LootModifier;
+import net.neoforged.neoforge.common.loot.LootModifier;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.Supplier;
@@ -21,7 +20,7 @@ public AddItemModifier(ItemStack item, LootItemCondition... conditionsIn) {
         this.itemStack = item;
     }
 
-    public static final Supplier<Codec<AddItemModifier>> CODEC = Suppliers.memoize(() -> RecordCodecBuilder.create(inst -> codecStart(inst).and(ItemStack.CODEC.fieldOf("item")
+    public static final Supplier<MapCodec<AddItemModifier>> CODEC = Suppliers.memoize(() -> RecordCodecBuilder.mapCodec(inst -> codecStart(inst).and(ItemStack.CODEC.fieldOf("item")
             .forGetter(m -> m.itemStack)).apply(inst, (conditionsIn, item) -> new AddItemModifier(item, conditionsIn))));
 
     @Override
@@ -36,7 +35,7 @@ public AddItemModifier(ItemStack item, LootItemCondition... conditionsIn) {
     }
 
     @Override
-    public Codec<? extends IGlobalLootModifier> codec() {
+    public MapCodec<AddItemModifier> codec() {
         return CODEC.get();
     }
 }
diff --git a/src/main/java/daripher/skilltree/loot/modifier/SkillBonusesLootModifier.java b/src/main/java/daripher/skilltree/loot/modifier/SkillBonusesLootModifier.java
index 33cff73d3..fbc134212 100644
--- a/src/main/java/daripher/skilltree/loot/modifier/SkillBonusesLootModifier.java
+++ b/src/main/java/daripher/skilltree/loot/modifier/SkillBonusesLootModifier.java
@@ -1,15 +1,14 @@
 package daripher.skilltree.loot.modifier;
 
 import com.google.common.base.Suppliers;
-import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import daripher.skilltree.skill.bonus.handler.LootAmountModifierBonusHandler;
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.storage.loot.LootContext;
 import net.minecraft.world.level.storage.loot.predicates.LootItemCondition;
-import net.minecraftforge.common.loot.IGlobalLootModifier;
-import net.minecraftforge.common.loot.LootModifier;
+import net.neoforged.neoforge.common.loot.LootModifier;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.Supplier;
@@ -19,7 +18,7 @@ public SkillBonusesLootModifier(LootItemCondition... conditionsIn) {
         super(conditionsIn);
     }
 
-    public static final Supplier<Codec<SkillBonusesLootModifier>> CODEC = Suppliers.memoize(() -> RecordCodecBuilder.create(inst -> codecStart(inst).apply(inst, SkillBonusesLootModifier::new)));
+    public static final Supplier<MapCodec<SkillBonusesLootModifier>> CODEC = Suppliers.memoize(() -> RecordCodecBuilder.mapCodec(inst -> codecStart(inst).apply(inst, SkillBonusesLootModifier::new)));
 
     @Override
     protected @NotNull ObjectArrayList<ItemStack> doApply(ObjectArrayList<ItemStack> defaultLoot, LootContext lootContext) {
@@ -32,7 +31,7 @@ public SkillBonusesLootModifier(LootItemCondition... conditionsIn) {
     }
 
     @Override
-    public Codec<? extends IGlobalLootModifier> codec() {
+    public MapCodec<SkillBonusesLootModifier> codec() {
         return CODEC.get();
     }
 }
diff --git a/src/main/java/daripher/skilltree/mixin/ClientAdvancementsAccessor.java b/src/main/java/daripher/skilltree/mixin/ClientAdvancementsAccessor.java
index 8bb508090..e10332fec 100644
--- a/src/main/java/daripher/skilltree/mixin/ClientAdvancementsAccessor.java
+++ b/src/main/java/daripher/skilltree/mixin/ClientAdvancementsAccessor.java
@@ -1,6 +1,6 @@
 package daripher.skilltree.mixin;
 
-import net.minecraft.advancements.Advancement;
+import net.minecraft.advancements.AdvancementHolder;
 import net.minecraft.advancements.AdvancementProgress;
 import net.minecraft.client.multiplayer.ClientAdvancements;
 import org.spongepowered.asm.mixin.Mixin;
@@ -11,5 +11,5 @@
 @Mixin(ClientAdvancements.class)
 public interface ClientAdvancementsAccessor {
     @Accessor
-    Map<Advancement, AdvancementProgress> getProgress();
+    Map<AdvancementHolder, AdvancementProgress> getProgress();
 }
diff --git a/src/main/java/daripher/skilltree/mixin/EditBoxAccessor.java b/src/main/java/daripher/skilltree/mixin/EditBoxAccessor.java
index ce8e8b217..c5397eec7 100644
--- a/src/main/java/daripher/skilltree/mixin/EditBoxAccessor.java
+++ b/src/main/java/daripher/skilltree/mixin/EditBoxAccessor.java
@@ -22,9 +22,6 @@ public interface EditBoxAccessor {
     @Accessor
     int getHighlightPos();
 
-    @Accessor
-    int getFrame();
-
     @Accessor
     int getMaxLength();
 
diff --git a/src/main/java/daripher/skilltree/mixin/minecraft/ClientPacketListenerMixin.java b/src/main/java/daripher/skilltree/mixin/minecraft/ClientPacketListenerMixin.java
new file mode 100644
index 000000000..6bc878757
--- /dev/null
+++ b/src/main/java/daripher/skilltree/mixin/minecraft/ClientPacketListenerMixin.java
@@ -0,0 +1,25 @@
+package daripher.skilltree.mixin.minecraft;
+
+import net.minecraft.client.Minecraft;
+import daripher.skilltree.client.screen.StatsUpdateListener;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.network.protocol.game.ClientboundAwardStatsPacket;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ClientPacketListener.class)
+public abstract class ClientPacketListenerMixin {
+  @Inject(
+      method = "handleAwardStats(Lnet/minecraft/network/protocol/game/ClientboundAwardStatsPacket;)V",
+      at = @At("TAIL"),
+      remap = false)
+  private void notifyStatsScreen(ClientboundAwardStatsPacket packet, CallbackInfo ci) {
+    Screen screen = Minecraft.getInstance().screen;
+    if (screen instanceof StatsUpdateListener statsUpdateListener) {
+      statsUpdateListener.onStatsUpdated();
+    }
+  }
+}
diff --git a/src/main/java/daripher/skilltree/mixin/minecraft/ItemStackMixin.java b/src/main/java/daripher/skilltree/mixin/minecraft/ItemStackMixin.java
index 563cf2207..af4770a0e 100644
--- a/src/main/java/daripher/skilltree/mixin/minecraft/ItemStackMixin.java
+++ b/src/main/java/daripher/skilltree/mixin/minecraft/ItemStackMixin.java
@@ -1,25 +1,37 @@
 package daripher.skilltree.mixin.minecraft;
 
 import daripher.skilltree.skill.bonus.handler.ItemDurabilityLossPreventionBonusHandler;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.util.RandomSource;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.function.Consumer;
 
 @Mixin(ItemStack.class)
 public class ItemStackMixin {
-    @Inject(method = "hurt", at = @At("HEAD"), cancellable = true)
-    public void preventDurabilityLoss(int amount, RandomSource random, @Nullable ServerPlayer playerUsingItem, CallbackInfoReturnable<Boolean> callbackInfo) {
-        if (playerUsingItem == null) {
+    @Inject(
+            method = "hurtAndBreak(ILnet/minecraft/server/level/ServerLevel;Lnet/minecraft/world/entity/LivingEntity;Ljava/util/function/Consumer;)V",
+            at = @At("HEAD"),
+            cancellable = true,
+            remap = false)
+    public void preventDurabilityLoss(
+            int amount,
+            ServerLevel level,
+            @Nullable LivingEntity user,
+            Consumer<Item> onBreak,
+            CallbackInfo callbackInfo) {
+        if (!(user instanceof net.minecraft.server.level.ServerPlayer player)) {
             return;
         }
         @SuppressWarnings("DataFlowIssue") ItemStack itemStack = (ItemStack) (Object) this;
-        if (ItemDurabilityLossPreventionBonusHandler.shouldPreventItemDurabilityLoss(playerUsingItem, itemStack, random)) {
-            callbackInfo.setReturnValue(false);
+        if (ItemDurabilityLossPreventionBonusHandler.shouldPreventItemDurabilityLoss(player, itemStack, level.getRandom())) {
+            callbackInfo.cancel();
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/mixin/minecraft/LivingEntityMixin.java b/src/main/java/daripher/skilltree/mixin/minecraft/LivingEntityMixin.java
index bd2f0f1c1..badd07e50 100644
--- a/src/main/java/daripher/skilltree/mixin/minecraft/LivingEntityMixin.java
+++ b/src/main/java/daripher/skilltree/mixin/minecraft/LivingEntityMixin.java
@@ -4,6 +4,7 @@
 import daripher.skilltree.entity.EquipmentContainer;
 import daripher.skilltree.skill.bonus.handler.JumpHeightBonusHandler;
 import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.entity.EquipmentSlot;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
@@ -22,7 +23,7 @@ public abstract class LivingEntityMixin implements EquipmentContainer {
     private final List<ItemStack> equipment = new ArrayList<>();
 
     @SuppressWarnings({"ConstantValue", "unused"})
-    @ModifyReturnValue(method = "getJumpPower", at = @At("RETURN"))
+    @ModifyReturnValue(method = "getJumpPower()F", at = @At("RETURN"), remap = false)
     private float applyJumpHeightBonus(float original) {
         if ((Object) this instanceof Player player) {
             return original * JumpHeightBonusHandler.getJumpHeightMultiplier(player);
@@ -31,8 +32,12 @@ private float applyJumpHeightBonus(float original) {
     }
 
     @SuppressWarnings("unused")
-    @Inject(method = "dropAllDeathLoot", at = @At("HEAD"))
-    private void storeEquipmentBeforeDeath(DamageSource damageSource, CallbackInfo callbackInfo) {
+    @Inject(
+            method = "dropAllDeathLoot(Lnet/minecraft/server/level/ServerLevel;Lnet/minecraft/world/damagesource/DamageSource;)V",
+            at = @At("HEAD"),
+            remap = false)
+    private void storeEquipmentBeforeDeath(
+            ServerLevel level, DamageSource damageSource, CallbackInfo callbackInfo) {
         for (EquipmentSlot slot : EquipmentSlot.values()) {
             ItemStack itemInSlot = getItemBySlot(slot);
             if (itemInSlot.isEmpty()) {
diff --git a/src/main/java/daripher/skilltree/mixin/minecraft/MobEffectMixin.java b/src/main/java/daripher/skilltree/mixin/minecraft/MobEffectMixin.java
index 25ad99322..f15087a5f 100644
--- a/src/main/java/daripher/skilltree/mixin/minecraft/MobEffectMixin.java
+++ b/src/main/java/daripher/skilltree/mixin/minecraft/MobEffectMixin.java
@@ -13,17 +13,23 @@
 import net.minecraft.world.effect.MobEffects;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.common.extensions.IForgeMobEffect;
 import org.jetbrains.annotations.NotNull;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(MobEffect.class)
-public abstract class MobEffectMixin implements IForgeMobEffect {
-    @Inject(method = "applyEffectTick", at = @At("HEAD"), cancellable = true)
-    public void inflictPoisonDamage(LivingEntity livingEntity, int amplifier, CallbackInfo callbackInfo) {
+public abstract class MobEffectMixin {
+    @Inject(
+            method = "applyEffectTick(Lnet/minecraft/world/entity/LivingEntity;I)Z",
+            at = @At("HEAD"),
+            cancellable = true,
+            remap = false)
+    public void inflictPoisonDamage(
+            LivingEntity livingEntity,
+            int amplifier,
+            CallbackInfoReturnable<Boolean> callbackInfo) {
         //noinspection ConstantValue
         if (((Object) this) != MobEffects.POISON) {
             return;
@@ -44,7 +50,7 @@ public void inflictPoisonDamage(LivingEntity livingEntity, int amplifier, Callba
             livingEntity.setLastHurtByPlayer(player);
         }
         SkillBonusHandlerUtils.hurtIgnoringInvulnerabilityTime(livingEntity, damageSource, damage);
-        callbackInfo.cancel();
+        callbackInfo.setReturnValue(true);
     }
 
     private static @NotNull Holder.Reference<DamageType> getPoisonDamageType(Player player) {
diff --git a/src/main/java/daripher/skilltree/mixin/minecraft/PlayerMixin.java b/src/main/java/daripher/skilltree/mixin/minecraft/PlayerMixin.java
index 4c9588712..217c05af3 100644
--- a/src/main/java/daripher/skilltree/mixin/minecraft/PlayerMixin.java
+++ b/src/main/java/daripher/skilltree/mixin/minecraft/PlayerMixin.java
@@ -18,7 +18,10 @@ protected PlayerMixin() {
     }
 
     @SuppressWarnings("DataFlowIssue")
-    @Inject(method = "onEnchantmentPerformed", at = @At("TAIL"))
+    @Inject(
+            method = "onEnchantmentPerformed(Lnet/minecraft/world/item/ItemStack;I)V",
+            at = @At("TAIL"),
+            remap = false)
     private void restoreEnchantmentExperience(ItemStack itemStack, int enchantmentCost, CallbackInfo callbackInfo) {
         Player player = (Player) (Object) this;
         if (EnchantingExperienceRefundBonusHandler.shouldRefundEnchantingExperience(player, itemStack)) {
diff --git a/src/main/java/daripher/skilltree/mixin/minecraft/ThrownPotionMixin.java b/src/main/java/daripher/skilltree/mixin/minecraft/ThrownPotionMixin.java
index 8aaea6045..a4fb78281 100644
--- a/src/main/java/daripher/skilltree/mixin/minecraft/ThrownPotionMixin.java
+++ b/src/main/java/daripher/skilltree/mixin/minecraft/ThrownPotionMixin.java
@@ -23,7 +23,10 @@ private ThrownPotionMixin() {
         super(null, null);
     }
 
-    @Redirect(method = "applySplash", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/LivingEntity;" + "addEffect(" + "Lnet/minecraft/world/effect/MobEffectInstance;" + "Lnet/minecraft/world/entity/Entity;" + ")Z"))
+    @Redirect(
+            method = "applySplash(Ljava/lang/Iterable;Lnet/minecraft/world/entity/Entity;)V",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/LivingEntity;" + "addEffect(" + "Lnet/minecraft/world/effect/MobEffectInstance;" + "Lnet/minecraft/world/entity/Entity;" + ")Z"),
+            remap = false)
     private boolean setAttackerOnHit(LivingEntity entity, MobEffectInstance effectInstance, Entity effectSource) {
         if (getOwner() instanceof Player player) {
             entity.setLastHurtByPlayer(player);
@@ -31,7 +34,10 @@ private boolean setAttackerOnHit(LivingEntity entity, MobEffectInstance effectIn
         return entity.addEffect(effectInstance, effectSource);
     }
 
-    @Redirect(method = "applySplash", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/Level;" + "getEntitiesOfClass(" + "Ljava/lang/Class;" + "Lnet/minecraft/world/phys/AABB;" + ")Ljava/util/List;"))
+    @Redirect(
+            method = "applySplash(Ljava/lang/Iterable;Lnet/minecraft/world/entity/Entity;)V",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/Level;" + "getEntitiesOfClass(" + "Ljava/lang/Class;" + "Lnet/minecraft/world/phys/AABB;" + ")Ljava/util/List;"),
+            remap = false)
     private <T extends Entity> List<T> removePlayerTarget(Level level, Class<T> entityClass, AABB area) {
         List<T> baseTargets = level.getEntitiesOfClass(entityClass, area);
         Entity owner = getOwner();
@@ -49,4 +55,3 @@ private <T extends Entity> List<T> removePlayerTarget(Level level, Class<T> enti
         return baseTargets;
     }
 }
-
diff --git a/src/main/java/daripher/skilltree/network/NetworkDispatcher.java b/src/main/java/daripher/skilltree/network/NetworkDispatcher.java
index e40887008..40031ab54 100644
--- a/src/main/java/daripher/skilltree/network/NetworkDispatcher.java
+++ b/src/main/java/daripher/skilltree/network/NetworkDispatcher.java
@@ -5,28 +5,30 @@
 import daripher.skilltree.network.message.LearnSkillMessage;
 import daripher.skilltree.network.message.SyncPlayerSkillsMessage;
 import daripher.skilltree.network.message.SyncServerDataMessage;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber.Bus;
-import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
-import net.minecraftforge.network.NetworkDirection;
-import net.minecraftforge.network.NetworkRegistry;
-import net.minecraftforge.network.simple.SimpleChannel;
-
-import java.util.Optional;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.fml.common.EventBusSubscriber.Bus;
+import net.neoforged.neoforge.network.event.RegisterPayloadHandlersEvent;
+import net.neoforged.neoforge.network.registration.PayloadRegistrar;
 
 @EventBusSubscriber(bus = Bus.MOD, modid = SkillTreeMod.MOD_ID)
 public class NetworkDispatcher {
-    public static SimpleChannel network_channel;
-
     @SubscribeEvent
-    public static void registerNetworkChannel(FMLCommonSetupEvent event) {
-        network_channel = NetworkRegistry.newSimpleChannel(ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "channel"), () -> "1.0", s -> true, s -> true);
-        network_channel.registerMessage(1, SyncServerDataMessage.class, SyncServerDataMessage::encode, SyncServerDataMessage::decode, SyncServerDataMessage::receive, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
-        network_channel.registerMessage(2, SyncPlayerSkillsMessage.class, SyncPlayerSkillsMessage::encode, SyncPlayerSkillsMessage::decode, SyncPlayerSkillsMessage::receive, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
-        network_channel.registerMessage(3, LearnSkillMessage.class, LearnSkillMessage::encode, LearnSkillMessage::decode, LearnSkillMessage::receive, Optional.of(NetworkDirection.PLAY_TO_SERVER));
-        network_channel.registerMessage(4, GainSkillPointMessage.class, (msg, buf) -> {
-        }, (buf) -> new GainSkillPointMessage(), (msg, ctx) -> GainSkillPointMessage.receive(ctx), Optional.of(NetworkDirection.PLAY_TO_SERVER));
+    public static void registerPayloadHandlers(RegisterPayloadHandlersEvent event) {
+        PayloadRegistrar registrar = event.registrar("1");
+        registrar.playToClient(
+                SyncServerDataMessage.TYPE,
+                SyncServerDataMessage.STREAM_CODEC,
+                SyncServerDataMessage::handle);
+        registrar.playToClient(
+                SyncPlayerSkillsMessage.TYPE,
+                SyncPlayerSkillsMessage.STREAM_CODEC,
+                SyncPlayerSkillsMessage::handle);
+        registrar.playToServer(
+                LearnSkillMessage.TYPE, LearnSkillMessage.STREAM_CODEC, LearnSkillMessage::handle);
+        registrar.playToServer(
+                GainSkillPointMessage.TYPE,
+                GainSkillPointMessage.STREAM_CODEC,
+                GainSkillPointMessage::handle);
     }
 }
diff --git a/src/main/java/daripher/skilltree/network/NetworkHelper.java b/src/main/java/daripher/skilltree/network/NetworkHelper.java
index 393ac31a4..e9be594ca 100644
--- a/src/main/java/daripher/skilltree/network/NetworkHelper.java
+++ b/src/main/java/daripher/skilltree/network/NetworkHelper.java
@@ -15,6 +15,7 @@
 import daripher.skilltree.skill.bonus.predicate.living.LivingEntityPredicate;
 import daripher.skilltree.skill.requirement.SkillRequirement;
 import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.network.chat.Style;
@@ -24,7 +25,7 @@
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.entity.ai.attributes.Attribute;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
-import net.minecraftforge.registries.ForgeRegistries;
+import daripher.skilltree.util.ForgeRegistries;
 import org.jetbrains.annotations.NotNull;
 
 import javax.annotation.Nonnull;
@@ -91,20 +92,17 @@ public static void writeAttribute(FriendlyByteBuf buf, Attribute attribute) {
     }
 
     public static void writeAttributeModifier(FriendlyByteBuf buf, AttributeModifier modifier) {
-        buf.writeLong(modifier.getId().getMostSignificantBits());
-        buf.writeLong(modifier.getId().getLeastSignificantBits());
-        buf.writeUtf(modifier.getName());
-        buf.writeDouble(modifier.getAmount());
-        writeOperation(buf, modifier.getOperation());
+        buf.writeResourceLocation(modifier.id());
+        buf.writeDouble(modifier.amount());
+        writeOperation(buf, modifier.operation());
     }
 
     @Nonnull
     public static AttributeModifier readAttributeModifier(FriendlyByteBuf buf) {
-        UUID id = new UUID(buf.readLong(), buf.readLong());
-        String name = buf.readUtf();
+        ResourceLocation id = buf.readResourceLocation();
         double amount = buf.readDouble();
         AttributeModifier.Operation operation = readOperation(buf);
-        return new AttributeModifier(id, name, amount, operation);
+        return new AttributeModifier(id, amount, operation);
     }
 
     public static void writeResourceLocations(FriendlyByteBuf buf, List<ResourceLocation> locations) {
@@ -398,16 +396,16 @@ public static <T extends Enum<T>> void writeEnum(FriendlyByteBuf buf, T anEnum)
     }
 
     public static void writeOperation(FriendlyByteBuf buf, AttributeModifier.Operation operation) {
-        buf.writeInt(operation.toValue());
+        buf.writeInt(operation.id());
     }
 
     @NotNull
     public static AttributeModifier.Operation readOperation(FriendlyByteBuf buf) {
-        return AttributeModifier.Operation.fromValue(buf.readInt());
+        return AttributeModifier.Operation.BY_ID.apply(buf.readInt());
     }
 
     public static void writeEffectInstance(FriendlyByteBuf buf, MobEffectInstance effect) {
-        writeMobEffect(buf, effect.getEffect());
+        writeMobEffect(buf, effect.getEffect().value());
         buf.writeInt(effect.getDuration());
         buf.writeInt(effect.getAmplifier());
     }
@@ -416,7 +414,10 @@ public static void writeEffectInstance(FriendlyByteBuf buf, MobEffectInstance ef
     public static MobEffectInstance readEffectInstance(FriendlyByteBuf buf) {
         MobEffect effect = readMobEffect(buf);
         Objects.requireNonNull(effect);
-        return new MobEffectInstance(effect, buf.readInt(), buf.readInt());
+        return new MobEffectInstance(
+                BuiltInRegistries.MOB_EFFECT.wrapAsHolder(effect),
+                buf.readInt(),
+                buf.readInt());
     }
 
     public static void writeValueProvider(FriendlyByteBuf buf, FloatFunction<?> provider) {
diff --git a/src/main/java/daripher/skilltree/network/message/GainSkillPointMessage.java b/src/main/java/daripher/skilltree/network/message/GainSkillPointMessage.java
index 7e5f5d23e..416735740 100644
--- a/src/main/java/daripher/skilltree/network/message/GainSkillPointMessage.java
+++ b/src/main/java/daripher/skilltree/network/message/GainSkillPointMessage.java
@@ -4,33 +4,39 @@
 import daripher.skilltree.capability.skill.PlayerSkillsProvider;
 import daripher.skilltree.config.ServerConfig;
 import daripher.skilltree.exp.ExpHelper;
-import daripher.skilltree.network.NetworkDispatcher;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraftforge.network.NetworkEvent;
-import net.minecraftforge.network.NetworkEvent.Context;
-import net.minecraftforge.network.PacketDistributor;
+import net.neoforged.neoforge.network.handling.IPayloadContext;
 
-import java.util.Objects;
-import java.util.function.Supplier;
+public record GainSkillPointMessage() implements CustomPacketPayload {
+    public static final Type<GainSkillPointMessage> TYPE =
+            new Type<>(ResourceLocation.fromNamespaceAndPath("skilltree", "gain_skill_point"));
+    public static final StreamCodec<ByteBuf, GainSkillPointMessage> STREAM_CODEC =
+            StreamCodec.unit(new GainSkillPointMessage());
 
-public class GainSkillPointMessage {
-    public static void receive(Supplier<NetworkEvent.Context> ctxSupplier) {
-        Context ctx = ctxSupplier.get();
-        ctx.setPacketHandled(true);
-        ServerPlayer player = Objects.requireNonNull(ctx.getSender());
-        IPlayerSkills capability = PlayerSkillsProvider.get(player);
-        int skills = capability.getPlayerSkills().size();
-        int points = capability.getSkillPoints();
-        int level = skills + points;
-        if (level >= ServerConfig.max_skill_points) {
-            return;
-        }
-        int cost = ServerConfig.getSkillPointCost(level);
-        if (ExpHelper.getPlayerExp(player) < cost) {
-            return;
-        }
-        player.giveExperiencePoints(-cost);
-        capability.grantSkillPoints(1);
-        NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> player), new SyncPlayerSkillsMessage(player));
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
+    }
+
+    public static void handle(GainSkillPointMessage message, IPayloadContext context) {
+        context.enqueueWork(() -> {
+            ServerPlayer player = (ServerPlayer) context.player();
+            IPlayerSkills capability = PlayerSkillsProvider.get(player);
+            int level = capability.getPlayerSkills().size() + capability.getSkillPoints();
+            if (level >= ServerConfig.max_skill_points) {
+                return;
+            }
+            int cost = ServerConfig.getSkillPointCost(level);
+            if (ExpHelper.getPlayerExp(player) < cost) {
+                return;
+            }
+            player.giveExperiencePoints(-cost);
+            capability.grantSkillPoints(1);
+            PlayerSkillsProvider.sendPlayerSkills(player);
+        });
     }
 }
diff --git a/src/main/java/daripher/skilltree/network/message/LearnSkillMessage.java b/src/main/java/daripher/skilltree/network/message/LearnSkillMessage.java
index 1c0fa995b..02f35dc02 100644
--- a/src/main/java/daripher/skilltree/network/message/LearnSkillMessage.java
+++ b/src/main/java/daripher/skilltree/network/message/LearnSkillMessage.java
@@ -3,49 +3,39 @@
 import daripher.skilltree.capability.skill.IPlayerSkills;
 import daripher.skilltree.capability.skill.PlayerSkillsProvider;
 import daripher.skilltree.data.reloader.SkillsReloader;
-import daripher.skilltree.network.NetworkDispatcher;
 import daripher.skilltree.skill.PassiveSkill;
-import net.minecraft.network.FriendlyByteBuf;
+import io.netty.buffer.ByteBuf;
+import java.util.Objects;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraftforge.network.NetworkEvent;
-import net.minecraftforge.network.NetworkEvent.Context;
-import net.minecraftforge.network.PacketDistributor;
-
-import java.util.Objects;
-import java.util.function.Supplier;
+import net.neoforged.neoforge.network.handling.IPayloadContext;
 
-public class LearnSkillMessage {
-    private ResourceLocation skillId;
+public record LearnSkillMessage(ResourceLocation skillId) implements CustomPacketPayload {
+    public static final Type<LearnSkillMessage> TYPE =
+            new Type<>(ResourceLocation.fromNamespaceAndPath("skilltree", "learn_skill"));
+    public static final StreamCodec<ByteBuf, LearnSkillMessage> STREAM_CODEC =
+            ResourceLocation.STREAM_CODEC.map(LearnSkillMessage::new, LearnSkillMessage::skillId);
 
     public LearnSkillMessage(PassiveSkill passiveSkill) {
-        skillId = passiveSkill.getId();
-    }
-
-    private LearnSkillMessage() {
-    }
-
-    public static LearnSkillMessage decode(FriendlyByteBuf buf) {
-        LearnSkillMessage message = new LearnSkillMessage();
-        message.skillId = ResourceLocation.parse(buf.readUtf());
-        return message;
+        this(passiveSkill.getId());
     }
 
-    public static void receive(LearnSkillMessage message, Supplier<NetworkEvent.Context> ctxSupplier) {
-        Context ctx = ctxSupplier.get();
-        ctx.setPacketHandled(true);
-        ServerPlayer player = ctx.getSender();
-        Objects.requireNonNull(player);
-        IPlayerSkills capability = PlayerSkillsProvider.get(player);
-        PassiveSkill skill = SkillsReloader.getSkillById(message.skillId);
-        Objects.requireNonNull(skill);
-        if (capability.learnSkill(skill)) {
-            skill.learn(player, true);
-        }
-        NetworkDispatcher.network_channel.send(PacketDistributor.PLAYER.with(() -> player), new SyncPlayerSkillsMessage(player));
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
     }
 
-    public void encode(FriendlyByteBuf buf) {
-        buf.writeUtf(skillId.toString());
+    public static void handle(LearnSkillMessage message, IPayloadContext context) {
+        context.enqueueWork(() -> {
+            ServerPlayer player = (ServerPlayer) context.player();
+            IPlayerSkills capability = PlayerSkillsProvider.get(player);
+            PassiveSkill skill = Objects.requireNonNull(SkillsReloader.getSkillById(message.skillId()));
+            if (capability.learnSkill(skill)) {
+                skill.learn(player, true);
+            }
+            PlayerSkillsProvider.sendPlayerSkills(player);
+        });
     }
 }
diff --git a/src/main/java/daripher/skilltree/network/message/SyncPlayerSkillsMessage.java b/src/main/java/daripher/skilltree/network/message/SyncPlayerSkillsMessage.java
index 9d91b3b67..38f822a7e 100644
--- a/src/main/java/daripher/skilltree/network/message/SyncPlayerSkillsMessage.java
+++ b/src/main/java/daripher/skilltree/network/message/SyncPlayerSkillsMessage.java
@@ -2,71 +2,75 @@
 
 import daripher.skilltree.capability.skill.IPlayerSkills;
 import daripher.skilltree.capability.skill.PlayerSkillsProvider;
-import daripher.skilltree.client.screen.SkillTreeScreen;
 import daripher.skilltree.data.reloader.SkillsReloader;
 import daripher.skilltree.skill.PassiveSkill;
-import net.minecraft.client.Minecraft;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.fml.DistExecutor;
-import net.minecraftforge.network.NetworkEvent;
-
-import java.util.ArrayList;
+import io.netty.buffer.ByteBuf;
 import java.util.List;
 import java.util.Objects;
-import java.util.function.Supplier;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.player.Player;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.fml.loading.FMLEnvironment;
+import net.neoforged.neoforge.network.handling.IPayloadContext;
 
-public class SyncPlayerSkillsMessage {
-    private List<ResourceLocation> learnedSkills = new ArrayList<>();
-    private int skillPoints;
+public record SyncPlayerSkillsMessage(List<ResourceLocation> learnedSkills, int skillPoints)
+        implements CustomPacketPayload {
+    private static final String CLIENT_HANDLERS_CLASS =
+            "daripher.skilltree.client.network.ClientNetworkPayloadHandlers";
 
-    private SyncPlayerSkillsMessage() {
-    }
+    public static final Type<SyncPlayerSkillsMessage> TYPE =
+            new Type<>(ResourceLocation.fromNamespaceAndPath("skilltree", "sync_player_skills"));
+    public static final StreamCodec<ByteBuf, SyncPlayerSkillsMessage> STREAM_CODEC =
+            StreamCodec.composite(
+                    ResourceLocation.STREAM_CODEC.apply(ByteBufCodecs.list()),
+                    SyncPlayerSkillsMessage::learnedSkills,
+                    ByteBufCodecs.VAR_INT,
+                    SyncPlayerSkillsMessage::skillPoints,
+                    SyncPlayerSkillsMessage::new);
 
     public SyncPlayerSkillsMessage(Player player) {
-        IPlayerSkills skillsCapability = PlayerSkillsProvider.get(player);
-        learnedSkills = skillsCapability.getPlayerSkills().stream().map(PassiveSkill::getId).toList();
-        skillPoints = skillsCapability.getSkillPoints();
+        this(
+                PlayerSkillsProvider.get(player).getPlayerSkills().stream()
+                        .map(PassiveSkill::getId)
+                        .toList(),
+                PlayerSkillsProvider.get(player).getSkillPoints());
     }
 
-    public static SyncPlayerSkillsMessage decode(FriendlyByteBuf buf) {
-        SyncPlayerSkillsMessage result = new SyncPlayerSkillsMessage();
-        int learnedSkillsCount = buf.readInt();
-        for (int i = 0; i < learnedSkillsCount; i++) {
-            result.learnedSkills.add(ResourceLocation.parse(buf.readUtf()));
-        }
-        result.skillPoints = buf.readInt();
-        return result;
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
     }
 
-    public static void receive(SyncPlayerSkillsMessage message, Supplier<NetworkEvent.Context> ctxSupplier) {
-        NetworkEvent.Context ctx = ctxSupplier.get();
-        ctx.setPacketHandled(true);
-        ctx.enqueueWork(() -> DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> handlePacket(message, ctx)));
+    public static void handle(SyncPlayerSkillsMessage message, IPayloadContext context) {
+        context.enqueueWork(() -> {
+            Player player = context.player();
+            if (player == null) {
+                return;
+            }
+            IPlayerSkills capability = PlayerSkillsProvider.get(player);
+            capability.getPlayerSkills().clear();
+            message.learnedSkills().stream()
+                    .map(SkillsReloader::getSkillById)
+                    .filter(Objects::nonNull)
+                    .forEach(capability.getPlayerSkills()::add);
+            capability.setSkillPoints(message.skillPoints());
+            refreshSkillTreeScreen(capability.getSkillPoints());
+        });
     }
 
-    @OnlyIn(value = Dist.CLIENT)
-    private static void handlePacket(SyncPlayerSkillsMessage message, NetworkEvent.Context ctx) {
-        ctx.setPacketHandled(true);
-        Minecraft minecraft = Minecraft.getInstance();
-        assert minecraft.player != null;
-        IPlayerSkills capability = PlayerSkillsProvider.get(minecraft.player);
-        capability.getPlayerSkills().clear();
-        message.learnedSkills.stream().map(SkillsReloader::getSkillById).filter(Objects::nonNull)
-                .forEach(capability.getPlayerSkills()::add);
-        capability.setSkillPoints(message.skillPoints);
-        if (minecraft.screen instanceof SkillTreeScreen screen) {
-            screen.updateSkillPoints(capability.getSkillPoints());
-            screen.init();
+    private static void refreshSkillTreeScreen(int skillPoints) {
+        if (FMLEnvironment.dist != Dist.CLIENT) {
+            return;
+        }
+        try {
+            Class.forName(CLIENT_HANDLERS_CLASS)
+                    .getMethod("refreshSkillTreeScreen", int.class)
+                    .invoke(null, skillPoints);
+        } catch (ReflectiveOperationException exception) {
+            throw new IllegalStateException("Failed to refresh skill tree screen", exception);
         }
-    }
-
-    public void encode(FriendlyByteBuf buf) {
-        buf.writeInt(learnedSkills.size());
-        learnedSkills.stream().map(ResourceLocation::toString).forEach(buf::writeUtf);
-        buf.writeInt(skillPoints);
     }
 }
diff --git a/src/main/java/daripher/skilltree/network/message/SyncServerDataMessage.java b/src/main/java/daripher/skilltree/network/message/SyncServerDataMessage.java
index d81f00a71..3883815fd 100644
--- a/src/main/java/daripher/skilltree/network/message/SyncServerDataMessage.java
+++ b/src/main/java/daripher/skilltree/network/message/SyncServerDataMessage.java
@@ -3,24 +3,54 @@
 import daripher.skilltree.data.reloader.SkillTreesReloader;
 import daripher.skilltree.data.reloader.SkillsReloader;
 import daripher.skilltree.network.NetworkHelper;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.network.handling.IPayloadContext;
 
-import java.util.function.Supplier;
+public class SyncServerDataMessage implements CustomPacketPayload {
+    public static final Type<SyncServerDataMessage> TYPE =
+            new Type<>(ResourceLocation.fromNamespaceAndPath("skilltree", "sync_server_data"));
+    public static final StreamCodec<ByteBuf, SyncServerDataMessage> STREAM_CODEC =
+            ByteBufCodecs.BYTE_ARRAY.map(SyncServerDataMessage::new, SyncServerDataMessage::payload);
 
-public class SyncServerDataMessage {
-    public static SyncServerDataMessage decode(FriendlyByteBuf buf) {
-        SkillsReloader.loadFromByteBuf(buf);
-        SkillTreesReloader.loadFromByteBuf(buf);
-        return new SyncServerDataMessage();
+    private final byte[] payload;
+
+    public SyncServerDataMessage() {
+        this(encodeServerData());
+    }
+
+    public SyncServerDataMessage(byte[] payload) {
+        this.payload = payload;
+    }
+
+    public byte[] payload() {
+        return payload;
+    }
+
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
     }
 
-    public static void receive(SyncServerDataMessage message, Supplier<NetworkEvent.Context> ctxSupplier) {
-        ctxSupplier.get().setPacketHandled(true);
+    public static void handle(SyncServerDataMessage message, IPayloadContext context) {
+        context.enqueueWork(() -> {
+            FriendlyByteBuf buffer = new FriendlyByteBuf(Unpooled.wrappedBuffer(message.payload));
+            SkillsReloader.loadFromByteBuf(buffer);
+            SkillTreesReloader.loadFromByteBuf(buffer);
+        });
     }
 
-    public void encode(FriendlyByteBuf buf) {
-        NetworkHelper.writePassiveSkills(buf, SkillsReloader.getSkills().values());
-        NetworkHelper.writePassiveSkillTrees(buf, SkillTreesReloader.getSkillTrees().values());
+    private static byte[] encodeServerData() {
+        FriendlyByteBuf buffer = new FriendlyByteBuf(Unpooled.buffer());
+        NetworkHelper.writePassiveSkills(buffer, SkillsReloader.getSkills().values());
+        NetworkHelper.writePassiveSkillTrees(buffer, SkillTreesReloader.getSkillTrees().values());
+        byte[] payload = new byte[buffer.readableBytes()];
+        buffer.readBytes(payload);
+        return payload;
     }
 }
diff --git a/src/main/java/daripher/skilltree/recipe/builder/WorkbenchCraftingRecipeBuilder.java b/src/main/java/daripher/skilltree/recipe/builder/WorkbenchCraftingRecipeBuilder.java
index 52a816493..4535fabdb 100644
--- a/src/main/java/daripher/skilltree/recipe/builder/WorkbenchCraftingRecipeBuilder.java
+++ b/src/main/java/daripher/skilltree/recipe/builder/WorkbenchCraftingRecipeBuilder.java
@@ -1,24 +1,16 @@
 package daripher.skilltree.recipe.builder;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
-import daripher.skilltree.init.PSTRecipeSerializers;
-import net.minecraft.data.recipes.FinishedRecipe;
+import daripher.skilltree.recipe.workbench.WorkbenchCraftingRecipe;
+import java.util.HashMap;
+import java.util.Map;
+import net.minecraft.data.recipes.RecipeOutput;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.Ingredient;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraftforge.registries.ForgeRegistries;
 import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.function.Consumer;
-
 public class WorkbenchCraftingRecipeBuilder {
     private final ResourceLocation id;
     private final Map<Ingredient, Integer> ingredients = new HashMap<>();
@@ -34,12 +26,14 @@ public static WorkbenchCraftingRecipeBuilder create(ResourceLocation id) {
         return new WorkbenchCraftingRecipeBuilder(id);
     }
 
-    public WorkbenchCraftingRecipeBuilder setBaseIngredient(Ingredient ingredient, int requiredAmount) {
+    public WorkbenchCraftingRecipeBuilder setBaseIngredient(
+            Ingredient ingredient, int requiredAmount) {
         this.baseIngredient = Pair.of(ingredient, requiredAmount);
         return this;
     }
 
-    public WorkbenchCraftingRecipeBuilder addIngredients(Ingredient ingredient, int requiredAmount) {
+    public WorkbenchCraftingRecipeBuilder addIngredients(
+            Ingredient ingredient, int requiredAmount) {
         this.ingredients.put(ingredient, requiredAmount);
         return this;
     }
@@ -54,9 +48,17 @@ public WorkbenchCraftingRecipeBuilder setResult(@NotNull ItemStack result) {
         return this;
     }
 
-    public void save(Consumer<FinishedRecipe> finishedRecipeConsumer) {
+    public void save(RecipeOutput recipeOutput) {
         validate();
-        finishedRecipeConsumer.accept(new Result(id, baseIngredient, ingredients, requiresPassiveSkill, result));
+        recipeOutput.accept(
+                id,
+                new WorkbenchCraftingRecipe(
+                        id,
+                        baseIngredient,
+                        Map.copyOf(ingredients),
+                        requiresPassiveSkill,
+                        result.copy()),
+                null);
     }
 
     private void validate() {
@@ -70,59 +72,4 @@ private void validate() {
             throw new IllegalStateException("No result item set for recipe " + id);
         }
     }
-
-    private record Result(ResourceLocation id, @Nullable Pair<Ingredient, Integer> baseIngredient, Map<Ingredient, Integer> ingredients,
-                          boolean requiresPassiveSkill, ItemStack result) implements FinishedRecipe {
-        @Override
-        public void serializeRecipeData(@NotNull JsonObject jsonObject) {
-            JsonArray ingredientsJson = new JsonArray();
-            ingredients.forEach(((ingredient, requiredAmount) -> {
-                JsonObject ingredientJson = new JsonObject();
-                ingredientJson.add("ingredient", ingredient.toJson());
-                ingredientJson.addProperty("required_amount", requiredAmount);
-                ingredientsJson.add(ingredientJson);
-            }));
-            jsonObject.addProperty("requires_passive_skill", requiresPassiveSkill);
-            jsonObject.add("ingredients", ingredientsJson);
-            if (baseIngredient != null) {
-                JsonObject baseIngredientJson = new JsonObject();
-                baseIngredientJson.add("ingredient", baseIngredient.getLeft().toJson());
-                baseIngredientJson.addProperty("required_amount", baseIngredient.getRight());
-                jsonObject.add("base_ingredient", baseIngredientJson);
-            }
-            JsonObject resultJson = new JsonObject();
-            Item resultItem = this.result.getItem();
-            ResourceLocation itemId = Objects.requireNonNull(ForgeRegistries.ITEMS.getKey(resultItem));
-            resultJson.addProperty("item", itemId.toString());
-            if (result.getCount() > 1) {
-                resultJson.addProperty("count", result.getCount());
-            }
-            if (result.getTag() != null) {
-                resultJson.addProperty("nbt", result.getTag().toString());
-            }
-            jsonObject.add("result", resultJson);
-        }
-
-        @Override
-        public @NotNull ResourceLocation getId() {
-            return id;
-        }
-
-        @Override
-        public @NotNull RecipeSerializer<?> getType() {
-            return PSTRecipeSerializers.WORKBENCH_CRAFTING.get();
-        }
-
-        @Nullable
-        @Override
-        public JsonObject serializeAdvancement() {
-            return null;
-        }
-
-        @Nullable
-        @Override
-        public ResourceLocation getAdvancementId() {
-            return null;
-        }
-    }
 }
diff --git a/src/main/java/daripher/skilltree/recipe/builder/WorkbenchItemBonusRecipeBuilder.java b/src/main/java/daripher/skilltree/recipe/builder/WorkbenchItemBonusRecipeBuilder.java
index 5f8d891b1..40cde6e75 100644
--- a/src/main/java/daripher/skilltree/recipe/builder/WorkbenchItemBonusRecipeBuilder.java
+++ b/src/main/java/daripher/skilltree/recipe/builder/WorkbenchItemBonusRecipeBuilder.java
@@ -1,28 +1,20 @@
 package daripher.skilltree.recipe.builder;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
-import daripher.skilltree.data.serializers.SerializationHelper;
-import daripher.skilltree.init.PSTRecipeSerializers;
+import daripher.skilltree.recipe.workbench.WorkbenchUpgradeBonusRecipe;
 import daripher.skilltree.skill.bonus.SkillBonus;
-import daripher.skilltree.skill.bonus.item.ItemBonus;
 import daripher.skilltree.skill.bonus.item.EquipmentBonus;
+import daripher.skilltree.skill.bonus.item.ItemBonus;
 import daripher.skilltree.skill.bonus.predicate.item.ItemStackPredicate;
-import net.minecraft.data.recipes.FinishedRecipe;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.crafting.Ingredient;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
 import java.util.HashMap;
 import java.util.Map;
-import java.util.function.Consumer;
+import net.minecraft.data.recipes.RecipeOutput;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.crafting.Ingredient;
 
 public class WorkbenchItemBonusRecipeBuilder {
     private final ResourceLocation id;
-    private ItemStackPredicate baseItemStackPredicate;
     private final Map<Ingredient, Integer> ingredients = new HashMap<>();
+    private ItemStackPredicate baseItemStackPredicate;
     private boolean requiresPassiveSkill;
     private ItemBonus<?> itemBonus;
 
@@ -34,12 +26,14 @@ public static WorkbenchItemBonusRecipeBuilder create(ResourceLocation id) {
         return new WorkbenchItemBonusRecipeBuilder(id);
     }
 
-    public WorkbenchItemBonusRecipeBuilder setBaseItemCondition(ItemStackPredicate baseItemStackPredicate) {
+    public WorkbenchItemBonusRecipeBuilder setBaseItemCondition(
+            ItemStackPredicate baseItemStackPredicate) {
         this.baseItemStackPredicate = baseItemStackPredicate;
         return this;
     }
 
-    public WorkbenchItemBonusRecipeBuilder addIngredients(Ingredient ingredient, int requiredAmount) {
+    public WorkbenchItemBonusRecipeBuilder addIngredients(
+            Ingredient ingredient, int requiredAmount) {
         this.ingredients.put(ingredient, requiredAmount);
         return this;
     }
@@ -59,9 +53,17 @@ public WorkbenchItemBonusRecipeBuilder setItemBonus(SkillBonus<?> skillBonus) {
         return this;
     }
 
-    public void save(Consumer<FinishedRecipe> finishedRecipeConsumer) {
+    public void save(RecipeOutput recipeOutput) {
         validate();
-        finishedRecipeConsumer.accept(new Result(id, baseItemStackPredicate, ingredients, requiresPassiveSkill, itemBonus));
+        recipeOutput.accept(
+                id,
+                new WorkbenchUpgradeBonusRecipe(
+                        id,
+                        baseItemStackPredicate,
+                        Map.copyOf(ingredients),
+                        requiresPassiveSkill,
+                        itemBonus),
+                null);
     }
 
     private void validate() {
@@ -78,44 +80,4 @@ private void validate() {
             throw new IllegalStateException("No item bonus set for recipe " + id);
         }
     }
-
-    private record Result(ResourceLocation id, ItemStackPredicate baseItemStackPredicate, Map<Ingredient, Integer> ingredients,
-                          boolean requiresPassiveSkill, ItemBonus<?> itemBonus) implements FinishedRecipe {
-        @Override
-        public void serializeRecipeData(@NotNull JsonObject jsonObject) {
-            JsonArray ingredientsJson = new JsonArray();
-            ingredients.forEach(((ingredient, requiredAmount) -> {
-                JsonObject ingredientJson = new JsonObject();
-                ingredientJson.add("ingredient", ingredient.toJson());
-                ingredientJson.addProperty("required_amount", requiredAmount);
-                ingredientsJson.add(ingredientJson);
-            }));
-            SerializationHelper.serializeItemPredicate(jsonObject, baseItemStackPredicate, "base_item_condition");
-            SerializationHelper.serializeItemBonus(jsonObject, itemBonus);
-            jsonObject.addProperty("requires_passive_skill", requiresPassiveSkill);
-            jsonObject.add("ingredients", ingredientsJson);
-        }
-
-        @Override
-        public @NotNull ResourceLocation getId() {
-            return id;
-        }
-
-        @Override
-        public @NotNull RecipeSerializer<?> getType() {
-            return PSTRecipeSerializers.WORKBENCH_ITEM_BONUS.get();
-        }
-
-        @Nullable
-        @Override
-        public JsonObject serializeAdvancement() {
-            return null;
-        }
-
-        @Nullable
-        @Override
-        public ResourceLocation getAdvancementId() {
-            return null;
-        }
-    }
 }
diff --git a/src/main/java/daripher/skilltree/recipe/workbench/AbstractWorkbenchRecipe.java b/src/main/java/daripher/skilltree/recipe/workbench/AbstractWorkbenchRecipe.java
index 8f28b7005..67ddc4d07 100644
--- a/src/main/java/daripher/skilltree/recipe/workbench/AbstractWorkbenchRecipe.java
+++ b/src/main/java/daripher/skilltree/recipe/workbench/AbstractWorkbenchRecipe.java
@@ -5,7 +5,7 @@
 import daripher.skilltree.recipe.SkillRequiringRecipe;
 import daripher.skilltree.skill.SkillBonusProvider;
 import daripher.skilltree.skill.bonus.player.RecipeUnlockBonus;
-import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.player.Player;
@@ -14,7 +14,7 @@
 import net.minecraft.world.item.crafting.Recipe;
 import net.minecraft.world.item.crafting.RecipeType;
 import net.minecraft.world.level.Level;
-import net.minecraftforge.registries.ForgeRegistries;
+import daripher.skilltree.util.ForgeRegistries;
 import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -88,20 +88,19 @@ public boolean canCraftInDimensions(int width, int height) {
         return width == 5 && height == 2;
     }
 
-    @Override
     public @NotNull ResourceLocation getId() {
         return id;
     }
 
     @Deprecated
     @Override
-    public @NotNull ItemStack getResultItem(@NotNull RegistryAccess registryAccess) {
+    public @NotNull ItemStack getResultItem(@NotNull HolderLookup.Provider registryAccess) {
         return ItemStack.EMPTY;
     }
 
     @Override
     public @NotNull RecipeType<?> getType() {
-        return PSTRecipeTypes.WORKBENCH;
+        return PSTRecipeTypes.WORKBENCH.get();
     }
 
     @Override
diff --git a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchCraftingRecipe.java b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchCraftingRecipe.java
index a02691c6a..e113094aa 100644
--- a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchCraftingRecipe.java
+++ b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchCraftingRecipe.java
@@ -1,31 +1,36 @@
 package daripher.skilltree.recipe.workbench;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.init.PSTRecipeSerializers;
 import daripher.skilltree.inventory.menu.WorkbenchContainer;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.network.FriendlyByteBuf;
+import java.util.Map;
+import java.util.Optional;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraftforge.common.crafting.CraftingHelper;
 import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.HashMap;
-import java.util.Map;
-
 public class WorkbenchCraftingRecipe extends AbstractWorkbenchRecipe {
     private final @Nullable Pair<Ingredient, Integer> baseIngredient;
     private final Map<Ingredient, Integer> additionalIngredients;
     private final ItemStack result;
 
-    public WorkbenchCraftingRecipe(ResourceLocation id, @Nullable Pair<Ingredient, Integer> baseIngredient, Map<Ingredient, Integer> additionalIngredients, boolean requiresPassiveSkill, ItemStack result) {
+    public WorkbenchCraftingRecipe(
+            ResourceLocation id,
+            @Nullable Pair<Ingredient, Integer> baseIngredient,
+            Map<Ingredient, Integer> additionalIngredients,
+            boolean requiresPassiveSkill,
+            ItemStack result) {
         super(id, requiresPassiveSkill);
         this.result = result;
         this.baseIngredient = baseIngredient;
@@ -33,7 +38,9 @@ public WorkbenchCraftingRecipe(ResourceLocation id, @Nullable Pair<Ingredient, I
     }
 
     @Override
-    public @NotNull ItemStack assemble(@NotNull WorkbenchContainer container, @NotNull RegistryAccess registryAccess) {
+    public @NotNull ItemStack assemble(
+            @NotNull WorkbenchContainer container,
+            @NotNull HolderLookup.Provider registryAccess) {
         return getResult(container);
     }
 
@@ -42,12 +49,13 @@ public boolean isValidBaseItem(ItemStack itemStack) {
         if (baseIngredient == null) {
             return itemStack.isEmpty();
         }
-        return baseIngredient.getLeft().test(itemStack) && itemStack.getCount() >= baseIngredient.getRight();
+        return baseIngredient.getLeft().test(itemStack)
+                && itemStack.getCount() >= baseIngredient.getRight();
     }
 
     @Override
     public Map<Ingredient, Integer> getAdditionalIngredients(ItemStack baseIngredient) {
-        return getAdditionalIngredients();
+        return additionalIngredients;
     }
 
     public Map<Ingredient, Integer> getAdditionalIngredients() {
@@ -80,61 +88,77 @@ public int requiredBaseItemAmount() {
     }
 
     public static class Serializer implements RecipeSerializer<WorkbenchCraftingRecipe> {
+        private static final ResourceLocation UNKNOWN_ID =
+                ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "unknown");
+
+        private static final MapCodec<WorkbenchCraftingRecipe> CODEC =
+                RecordCodecBuilder.mapCodec(instance -> instance.group(
+                                ResourceLocation.CODEC.optionalFieldOf("id", UNKNOWN_ID)
+                                        .forGetter(AbstractWorkbenchRecipe::getId),
+                                WorkbenchRecipeCodecs.IngredientEntry.CODEC
+                                        .optionalFieldOf("base_ingredient")
+                                        .forGetter(recipe -> optionalBaseIngredient(recipe.baseIngredient)),
+                                WorkbenchRecipeCodecs.IngredientEntry.CODEC.listOf()
+                                        .fieldOf("ingredients")
+                                        .xmap(WorkbenchRecipeCodecs::toMap, WorkbenchRecipeCodecs::toEntries)
+                                        .forGetter(WorkbenchCraftingRecipe::getAdditionalIngredients),
+                                Codec.BOOL.optionalFieldOf("requires_passive_skill", false)
+                                        .forGetter(AbstractWorkbenchRecipe::hasPassiveSkillRequirement),
+                                ItemStack.CODEC.fieldOf("result").forGetter(recipe -> recipe.result))
+                        .apply(instance, (id, baseIngredient, ingredients, requiresPassiveSkill, result) ->
+                                new WorkbenchCraftingRecipe(
+                                        id,
+                                        baseIngredient.map(entry -> Pair.of(entry.ingredient(), entry.requiredAmount()))
+                                                .orElse(null),
+                                        ingredients,
+                                        requiresPassiveSkill,
+                                        result)));
+
+        private static final StreamCodec<RegistryFriendlyByteBuf, WorkbenchCraftingRecipe>
+                STREAM_CODEC = StreamCodec.of(Serializer::encode, Serializer::decode);
+
         @Override
-        public @NotNull WorkbenchCraftingRecipe fromJson(@NotNull ResourceLocation id, @NotNull JsonObject jsonObject) {
-            boolean requiresPassiveSkill = jsonObject.get("requires_passive_skill").getAsBoolean();
-            Map<Ingredient, Integer> additionalIngredients = new HashMap<>();
-            JsonArray ingredientsJson = jsonObject.getAsJsonArray("additionalIngredients");
-            for (JsonElement jsonElement : ingredientsJson) {
-                JsonObject ingredientJson = jsonElement.getAsJsonObject();
-                Ingredient ingredient = Ingredient.fromJson(ingredientJson.get("ingredient"));
-                int requiredAmount = ingredientJson.get("required_amount").getAsInt();
-                additionalIngredients.put(ingredient, requiredAmount);
-            }
-            Pair<Ingredient, Integer> baseIngredient = null;
-            if (jsonObject.has("base_ingredient")) {
-                JsonObject baseIngredientJson = jsonObject.get("base_ingredient").getAsJsonObject();
-                Ingredient ingredient = Ingredient.fromJson(baseIngredientJson.get("ingredient"));
-                int requiredAmount = baseIngredientJson.get("required_amount").getAsInt();
-                baseIngredient = Pair.of(ingredient, requiredAmount);
-            }
-            JsonObject resultJson = jsonObject.getAsJsonObject("result");
-            ItemStack result = CraftingHelper.getItemStack(resultJson, true, true);
-            return new WorkbenchCraftingRecipe(id, baseIngredient, additionalIngredients, requiresPassiveSkill, result);
+        public @NotNull MapCodec<WorkbenchCraftingRecipe> codec() {
+            return CODEC;
         }
 
         @Override
-        public @Nullable WorkbenchCraftingRecipe fromNetwork(@NotNull ResourceLocation id, @NotNull FriendlyByteBuf buf) {
+        public @NotNull StreamCodec<RegistryFriendlyByteBuf, WorkbenchCraftingRecipe> streamCodec() {
+            return STREAM_CODEC;
+        }
+
+        private static WorkbenchCraftingRecipe decode(RegistryFriendlyByteBuf buf) {
+            ResourceLocation id = buf.readResourceLocation();
             boolean requiresPassiveSkill = buf.readBoolean();
-            Map<Ingredient, Integer> additionalIngredients = new HashMap<>();
-            int ingredientsCount = buf.readInt();
-            for (int i = 0; i < ingredientsCount; i++) {
-                additionalIngredients.put(Ingredient.fromNetwork(buf), buf.readInt());
-            }
+            Map<Ingredient, Integer> ingredients = WorkbenchRecipeCodecs.readIngredientMap(buf);
             Pair<Ingredient, Integer> baseIngredient = null;
-            boolean hasBaseIngredient = buf.readBoolean();
-            if (hasBaseIngredient) {
-                baseIngredient = Pair.of(Ingredient.fromNetwork(buf), buf.readInt());
+            if (buf.readBoolean()) {
+                baseIngredient = Pair.of(Ingredient.CONTENTS_STREAM_CODEC.decode(buf), buf.readInt());
             }
-            ItemStack result = buf.readItem();
-            return new WorkbenchCraftingRecipe(id, baseIngredient, additionalIngredients, requiresPassiveSkill, result);
+            ItemStack result = ItemStack.OPTIONAL_STREAM_CODEC.decode(buf);
+            return new WorkbenchCraftingRecipe(
+                    id, baseIngredient, ingredients, requiresPassiveSkill, result);
         }
 
-        @Override
-        public void toNetwork(@NotNull FriendlyByteBuf buf, @NotNull WorkbenchCraftingRecipe recipe) {
+        private static void encode(RegistryFriendlyByteBuf buf, WorkbenchCraftingRecipe recipe) {
+            buf.writeResourceLocation(recipe.getId());
             buf.writeBoolean(recipe.hasPassiveSkillRequirement());
-            int ingredientsCount = recipe.getAdditionalIngredients().size();
-            buf.writeInt(ingredientsCount);
-            recipe.getAdditionalIngredients().forEach((ingredient, requiredAmount) -> {
-                ingredient.toNetwork(buf);
-                buf.writeInt(requiredAmount);
-            });
+            WorkbenchRecipeCodecs.writeIngredientMap(buf, recipe.additionalIngredients);
             buf.writeBoolean(recipe.baseIngredient != null);
             if (recipe.baseIngredient != null) {
-                recipe.baseIngredient.getLeft().toNetwork(buf);
+                Ingredient.CONTENTS_STREAM_CODEC.encode(buf, recipe.baseIngredient.getLeft());
                 buf.writeInt(recipe.baseIngredient.getRight());
             }
-            buf.writeItem(recipe.result);
+            ItemStack.OPTIONAL_STREAM_CODEC.encode(buf, recipe.result);
+        }
+
+        private static Optional<WorkbenchRecipeCodecs.IngredientEntry> optionalBaseIngredient(
+                @Nullable Pair<Ingredient, Integer> baseIngredient) {
+            if (baseIngredient == null) {
+                return Optional.empty();
+            }
+            return Optional.of(new WorkbenchRecipeCodecs.IngredientEntry(
+                    baseIngredient.getLeft(), baseIngredient.getRight()));
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchPotionMixingRecipe.java b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchPotionMixingRecipe.java
index 7ff4cdd4b..012487152 100644
--- a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchPotionMixingRecipe.java
+++ b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchPotionMixingRecipe.java
@@ -1,31 +1,35 @@
 package daripher.skilltree.recipe.workbench;
 
-import com.google.gson.JsonObject;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.init.PSTRecipeSerializers;
 import daripher.skilltree.inventory.menu.WorkbenchContainer;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.network.FriendlyByteBuf;
+import daripher.skilltree.util.ForgeRegistries;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Stream;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.PotionItem;
 import net.minecraft.world.item.alchemy.Potion;
-import net.minecraft.world.item.alchemy.PotionUtils;
+import net.minecraft.world.item.alchemy.PotionContents;
+import net.minecraft.world.item.component.CustomData;
 import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraftforge.registries.ForgeRegistries;
 import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Stream;
 
 public class WorkbenchPotionMixingRecipe extends AbstractWorkbenchRecipe {
     public static final String IS_MIXTURE_TAG_NAME = "isMixture";
@@ -35,7 +39,9 @@ public WorkbenchPotionMixingRecipe(ResourceLocation id, boolean requiresPassiveS
     }
 
     @Override
-    public @NotNull ItemStack assemble(@NotNull WorkbenchContainer container, @NotNull RegistryAccess registryAccess) {
+    public @NotNull ItemStack assemble(
+            @NotNull WorkbenchContainer container,
+            @NotNull HolderLookup.Provider registryAccess) {
         return getResult(container);
     }
 
@@ -59,52 +65,51 @@ public Pair<Ingredient, Integer> getBaseIngredient() {
     }
 
     private void setIsMixtureTag(ItemStack itemStack) {
-        itemStack.getOrCreateTag().putBoolean(IS_MIXTURE_TAG_NAME, true);
+        CustomData.update(
+                DataComponents.CUSTOM_DATA,
+                itemStack,
+                tag -> tag.putBoolean(IS_MIXTURE_TAG_NAME, true));
     }
 
     private boolean canMixPotion(ItemStack itemStack) {
-        if (!itemStack.hasTag()) {
-            return true;
-        }
-        return !itemStack.getOrCreateTag().getBoolean(IS_MIXTURE_TAG_NAME);
+        CustomData customData = itemStack.getOrDefault(DataComponents.CUSTOM_DATA, CustomData.EMPTY);
+        return !customData.copyTag().getBoolean(IS_MIXTURE_TAG_NAME);
     }
 
     private Ingredient getPotionItemIngredient(PotionItem baseItem) {
         Collection<Potion> availablePotions = ForgeRegistries.POTIONS.getValues();
-        Stream<Potion> potionsWithEffects = availablePotions.stream().filter(potion -> !potion.getEffects().isEmpty());
-        Stream<ItemStack> suitablePotionStacks = potionsWithEffects.map(potion -> getPotionStack(baseItem, potion));
-        return Ingredient.of(suitablePotionStacks.toList().toArray(new ItemStack[0]));
+        Stream<Potion> potionsWithEffects =
+                availablePotions.stream().filter(potion -> !potion.getEffects().isEmpty());
+        Stream<ItemStack> suitablePotionStacks =
+                potionsWithEffects.map(potion -> getPotionStack(baseItem, potion));
+        return Ingredient.of(suitablePotionStacks.toArray(ItemStack[]::new));
     }
 
     private Ingredient getAllPotionsIngredient() {
         Collection<Potion> availablePotions = ForgeRegistries.POTIONS.getValues();
-        Stream<Potion> potions = availablePotions.stream().filter(potion -> !potion.getEffects().isEmpty());
+        Stream<Potion> potions =
+                availablePotions.stream().filter(potion -> !potion.getEffects().isEmpty());
         List<ItemStack> suitablePotionStacks = new ArrayList<>();
-        potions.forEach(potion -> {
-            List<PotionItem> potionItems = ForgeRegistries.ITEMS.getValues().stream().filter(PotionItem.class::isInstance)
-                    .map(PotionItem.class::cast).toList();
-            potionItems.forEach(potionItem -> suitablePotionStacks.add(getPotionStack(potionItem, potion)));
-        });
-        return Ingredient.of(suitablePotionStacks.toArray(new ItemStack[0]));
+        List<PotionItem> potionItems = ForgeRegistries.ITEMS.getValues().stream()
+                .filter(PotionItem.class::isInstance)
+                .map(PotionItem.class::cast)
+                .toList();
+        potions.forEach(potion -> potionItems.forEach(
+                potionItem -> suitablePotionStacks.add(getPotionStack(potionItem, potion))));
+        return Ingredient.of(suitablePotionStacks.toArray(ItemStack[]::new));
     }
 
-    private static @NotNull ItemStack getPotionStack(PotionItem baseItem, Potion potion) {
-        ItemStack itemStack = new ItemStack(baseItem);
-        PotionUtils.setPotion(itemStack, potion);
-        return itemStack;
+    private static @NotNull ItemStack getPotionStack(Item baseItem, Potion potion) {
+        return PotionContents.createItemStack(baseItem, ForgeRegistries.POTIONS.wrapAsHolder(potion));
     }
 
     @Override
     public Map<Ingredient, Integer> getAdditionalIngredients(ItemStack baseItem) {
         Map<Ingredient, Integer> allPotionsIngredient = Map.of(getAllPotionsIngredient(), 1);
-        if (baseItem.isEmpty()) {
-            return allPotionsIngredient;
+        if (baseItem.getItem() instanceof PotionItem potionItem) {
+            return Map.of(getPotionItemIngredient(potionItem), 1);
         }
-        Item item = baseItem.getItem();
-        if (!(item instanceof PotionItem potionItem)) {
-            return allPotionsIngredient;
-        }
-        return Map.of(getPotionItemIngredient(potionItem), 1);
+        return allPotionsIngredient;
     }
 
     @Override
@@ -114,36 +119,31 @@ public Component getShortDescription() {
 
     @Override
     public @NotNull ItemStack getResult(WorkbenchContainer workbenchContainer) {
-        ItemStack potionStack1 = workbenchContainer.getBaseItem();
-        ItemStack potionStack2 = workbenchContainer.getItem(1);
-        ItemStack resultItemStack = new ItemStack(potionStack1.getItem());
-        setMixtureEffects(potionStack1, potionStack2, resultItemStack);
-        setMixtureColor(potionStack1, potionStack2, resultItemStack);
-        setMixtureName(potionStack1, resultItemStack);
-        setIsMixtureTag(resultItemStack);
-        return resultItemStack;
-    }
-
-    private void setMixtureEffects(ItemStack potionStack1, ItemStack potionStack2, ItemStack resultItemStack) {
-        List<MobEffectInstance> mobEffectInstances = new ArrayList<>();
-        mobEffectInstances.addAll(PotionUtils.getMobEffects(potionStack1));
-        mobEffectInstances.addAll(PotionUtils.getMobEffects(potionStack2));
-        PotionUtils.setCustomEffects(resultItemStack, mobEffectInstances);
-    }
-
-    private void setMixtureColor(ItemStack potionStack1, ItemStack potionStack2, ItemStack resultItemStack) {
-        int potionColor = mixHexColors(PotionUtils.getColor(potionStack1), PotionUtils.getColor(potionStack2));
-        resultItemStack.getOrCreateTag().putInt(PotionUtils.TAG_CUSTOM_POTION_COLOR, potionColor);
-    }
-
-    private void setMixtureName(ItemStack potionStack1, ItemStack resultItemStack) {
-        String descriptionId = potionStack1.getItem().getDescriptionId() + ".mixture";
-        MutableComponent itemStackName = Component.translatable(descriptionId);
-        resultItemStack.setHoverName(itemStackName);
+        ItemStack firstPotion = workbenchContainer.getBaseItem();
+        ItemStack secondPotion = workbenchContainer.getItem(1);
+        ItemStack result = new ItemStack(firstPotion.getItem());
+        List<MobEffectInstance> effects = new ArrayList<>();
+        getPotionContents(firstPotion).getAllEffects().forEach(effects::add);
+        getPotionContents(secondPotion).getAllEffects().forEach(effects::add);
+        int color = mixHexColors(
+                getPotionContents(firstPotion).getColor(),
+                getPotionContents(secondPotion).getColor());
+        result.set(
+                DataComponents.POTION_CONTENTS,
+                new PotionContents(Optional.empty(), Optional.of(color), effects));
+        result.set(
+                DataComponents.CUSTOM_NAME,
+                Component.translatable(firstPotion.getItem().getDescriptionId() + ".mixture"));
+        setIsMixtureTag(result);
+        return result;
+    }
+
+    private static PotionContents getPotionContents(ItemStack stack) {
+        return stack.getOrDefault(DataComponents.POTION_CONTENTS, PotionContents.EMPTY);
     }
 
     private int mixHexColors(int color1, int color2) {
-        return ((color1 ^ color2) & 0xFEFEFE) >> 1 + (color1 & color2);
+        return (((color1 ^ color2) & 0xFEFEFE) >> 1) + (color1 & color2);
     }
 
     @Override
@@ -157,20 +157,35 @@ public int requiredBaseItemAmount() {
     }
 
     public static class Serializer implements RecipeSerializer<WorkbenchPotionMixingRecipe> {
+        private static final ResourceLocation UNKNOWN_ID =
+                ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "unknown");
+        private static final MapCodec<WorkbenchPotionMixingRecipe> CODEC =
+                RecordCodecBuilder.mapCodec(instance -> instance.group(
+                                ResourceLocation.CODEC.optionalFieldOf("id", UNKNOWN_ID)
+                                        .forGetter(AbstractWorkbenchRecipe::getId),
+                                Codec.BOOL.optionalFieldOf("requires_passive_skill", false)
+                                        .forGetter(AbstractWorkbenchRecipe::hasPassiveSkillRequirement))
+                        .apply(instance, WorkbenchPotionMixingRecipe::new));
+        private static final StreamCodec<RegistryFriendlyByteBuf, WorkbenchPotionMixingRecipe>
+                STREAM_CODEC = StreamCodec.of(Serializer::encode, Serializer::decode);
+
         @Override
-        public @NotNull WorkbenchPotionMixingRecipe fromJson(@NotNull ResourceLocation id, @NotNull JsonObject jsonObject) {
-            boolean requiresPassiveSkill = jsonObject.get("requires_passive_skill").getAsBoolean();
-            return new WorkbenchPotionMixingRecipe(id, requiresPassiveSkill);
+        public @NotNull MapCodec<WorkbenchPotionMixingRecipe> codec() {
+            return CODEC;
         }
 
         @Override
-        public @Nullable WorkbenchPotionMixingRecipe fromNetwork(@NotNull ResourceLocation id, @NotNull FriendlyByteBuf buf) {
-            boolean requiresPassiveSkill = buf.readBoolean();
-            return new WorkbenchPotionMixingRecipe(id, requiresPassiveSkill);
+        public @NotNull StreamCodec<RegistryFriendlyByteBuf, WorkbenchPotionMixingRecipe> streamCodec() {
+            return STREAM_CODEC;
         }
 
-        @Override
-        public void toNetwork(@NotNull FriendlyByteBuf buf, @NotNull WorkbenchPotionMixingRecipe recipe) {
+        private static WorkbenchPotionMixingRecipe decode(RegistryFriendlyByteBuf buf) {
+            return new WorkbenchPotionMixingRecipe(
+                    buf.readResourceLocation(), buf.readBoolean());
+        }
+
+        private static void encode(RegistryFriendlyByteBuf buf, WorkbenchPotionMixingRecipe recipe) {
+            buf.writeResourceLocation(recipe.getId());
             buf.writeBoolean(recipe.hasPassiveSkillRequirement());
         }
     }
diff --git a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchRecipeCodecs.java b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchRecipeCodecs.java
new file mode 100644
index 000000000..8ed2e9d50
--- /dev/null
+++ b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchRecipeCodecs.java
@@ -0,0 +1,72 @@
+package daripher.skilltree.recipe.workbench;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.Dynamic;
+import com.mojang.serialization.JsonOps;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.world.item.crafting.Ingredient;
+
+final class WorkbenchRecipeCodecs {
+  static final Codec<JsonObject> JSON_OBJECT =
+      Codec.PASSTHROUGH.flatXmap(
+          dynamic -> {
+            JsonElement element = dynamic.convert(JsonOps.INSTANCE).getValue();
+            if (element.isJsonObject()) {
+              return DataResult.success(element.getAsJsonObject());
+            }
+            return DataResult.error(() -> "Expected JSON object");
+          },
+          jsonObject -> DataResult.success(new Dynamic<>(JsonOps.INSTANCE, jsonObject)));
+
+  private WorkbenchRecipeCodecs() {}
+
+  static List<IngredientEntry> toEntries(Map<Ingredient, Integer> ingredients) {
+    return ingredients.entrySet().stream().map(IngredientEntry::from).toList();
+  }
+
+  static Map<Ingredient, Integer> toMap(List<IngredientEntry> ingredients) {
+    Map<Ingredient, Integer> map = new HashMap<>();
+    ingredients.forEach(entry -> map.put(entry.ingredient(), entry.requiredAmount()));
+    return map;
+  }
+
+  static void writeIngredientMap(RegistryFriendlyByteBuf buf, Map<Ingredient, Integer> ingredients) {
+    buf.writeInt(ingredients.size());
+    ingredients.forEach(
+        (ingredient, amount) -> {
+          Ingredient.CONTENTS_STREAM_CODEC.encode(buf, ingredient);
+          buf.writeInt(amount);
+        });
+  }
+
+  static Map<Ingredient, Integer> readIngredientMap(RegistryFriendlyByteBuf buf) {
+    Map<Ingredient, Integer> ingredients = new HashMap<>();
+    int ingredientsCount = buf.readInt();
+    for (int i = 0; i < ingredientsCount; i++) {
+      ingredients.put(Ingredient.CONTENTS_STREAM_CODEC.decode(buf), buf.readInt());
+    }
+    return ingredients;
+  }
+
+  record IngredientEntry(Ingredient ingredient, int requiredAmount) {
+    static final Codec<IngredientEntry> CODEC =
+        RecordCodecBuilder.create(
+            instance ->
+                instance
+                    .group(
+                        Ingredient.CODEC_NONEMPTY.fieldOf("ingredient").forGetter(IngredientEntry::ingredient),
+                        Codec.INT.fieldOf("required_amount").forGetter(IngredientEntry::requiredAmount))
+                    .apply(instance, IngredientEntry::new));
+
+    static IngredientEntry from(Map.Entry<Ingredient, Integer> entry) {
+      return new IngredientEntry(entry.getKey(), entry.getValue());
+    }
+  }
+}
diff --git a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchUpgradeBonusRecipe.java b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchUpgradeBonusRecipe.java
index b4cba4f25..c542d8b3d 100644
--- a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchUpgradeBonusRecipe.java
+++ b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchUpgradeBonusRecipe.java
@@ -1,8 +1,10 @@
 package daripher.skilltree.recipe.workbench;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.client.tooltip.TooltipHelper;
 import daripher.skilltree.data.serializers.SerializationHelper;
 import daripher.skilltree.init.PSTRecipeSerializers;
@@ -11,8 +13,12 @@
 import daripher.skilltree.skill.bonus.item.ItemBonus;
 import daripher.skilltree.skill.bonus.item.ItemBonusHandler;
 import daripher.skilltree.skill.bonus.predicate.item.ItemStackPredicate;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.network.FriendlyByteBuf;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.network.chat.Style;
@@ -25,17 +31,17 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 public class WorkbenchUpgradeBonusRecipe extends AbstractWorkbenchRecipe {
     private final ItemStackPredicate baseItemStackPredicate;
     private final Map<Ingredient, Integer> additionalIngredients;
     private final ItemBonus<?> itemBonus;
 
-    public WorkbenchUpgradeBonusRecipe(ResourceLocation id, ItemStackPredicate baseItemStackPredicate, Map<Ingredient, Integer> additionalIngredients, boolean requiresPassiveSkill, ItemBonus<?> itemBonus) {
+    public WorkbenchUpgradeBonusRecipe(
+            ResourceLocation id,
+            ItemStackPredicate baseItemStackPredicate,
+            Map<Ingredient, Integer> additionalIngredients,
+            boolean requiresPassiveSkill,
+            ItemBonus<?> itemBonus) {
         super(id, requiresPassiveSkill);
         this.baseItemStackPredicate = baseItemStackPredicate;
         this.itemBonus = itemBonus;
@@ -43,7 +49,9 @@ public WorkbenchUpgradeBonusRecipe(ResourceLocation id, ItemStackPredicate baseI
     }
 
     @Override
-    public @NotNull ItemStack assemble(@NotNull WorkbenchContainer container, @NotNull RegistryAccess registryAccess) {
+    public @NotNull ItemStack assemble(
+            @NotNull WorkbenchContainer container,
+            @NotNull HolderLookup.Provider registryAccess) {
         return getResult(container);
     }
 
@@ -75,8 +83,7 @@ public List<Component> getFullDescription() {
             fullDescription.add(mutableComponent.withStyle(style));
         }
         Component itemTooltip = baseItemStackPredicate.getTooltip("plural");
-        itemTooltip = Component.literal("[").append(itemTooltip).append("]");
-        fullDescription.add(itemTooltip);
+        fullDescription.add(Component.literal("[").append(itemTooltip).append("]"));
         return fullDescription;
     }
 
@@ -88,7 +95,8 @@ public List<Component> getFullDescription() {
         if (craftedBonusLimit <= 0) {
             return baseItem;
         }
-        List<ItemBonus<?>> originalBonuses = new ArrayList<>(ItemBonusHandler.getItemBonuses(baseItem));
+        List<ItemBonus<?>> originalBonuses =
+                new ArrayList<>(ItemBonusHandler.getItemBonuses(baseItem));
         while (craftedBonusLimit <= originalBonuses.size()) {
             originalBonuses.remove(0);
         }
@@ -103,7 +111,7 @@ public int requiredBaseItemAmount() {
     }
 
     @Override
-    public Pair<Ingredient, Integer> getBaseIngredient() {
+    public @Nullable Pair<Ingredient, Integer> getBaseIngredient() {
         return null;
     }
 
@@ -113,45 +121,87 @@ public Pair<Ingredient, Integer> getBaseIngredient() {
     }
 
     public static class Serializer implements RecipeSerializer<WorkbenchUpgradeBonusRecipe> {
+        private static final ResourceLocation UNKNOWN_ID =
+                ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "unknown");
+
+        private static final Codec<ItemStackPredicate> ITEM_PREDICATE_CODEC =
+                WorkbenchRecipeCodecs.JSON_OBJECT.xmap(
+                        Serializer::deserializeItemPredicate, Serializer::serializeItemPredicate);
+        private static final Codec<ItemBonus<?>> ITEM_BONUS_CODEC =
+                WorkbenchRecipeCodecs.JSON_OBJECT.xmap(
+                        Serializer::deserializeItemBonus, Serializer::serializeItemBonus);
+
+        private static final MapCodec<WorkbenchUpgradeBonusRecipe> CODEC =
+                RecordCodecBuilder.mapCodec(instance -> instance.group(
+                                ResourceLocation.CODEC.optionalFieldOf("id", UNKNOWN_ID)
+                                        .forGetter(AbstractWorkbenchRecipe::getId),
+                                ITEM_PREDICATE_CODEC.fieldOf("base_item_condition")
+                                        .forGetter(recipe -> recipe.baseItemStackPredicate),
+                                ITEM_BONUS_CODEC.fieldOf("item_bonus")
+                                        .forGetter(recipe -> recipe.itemBonus),
+                                WorkbenchRecipeCodecs.IngredientEntry.CODEC.listOf()
+                                        .fieldOf("ingredients")
+                                        .xmap(WorkbenchRecipeCodecs::toMap, WorkbenchRecipeCodecs::toEntries)
+                                        .forGetter(WorkbenchUpgradeBonusRecipe::getAdditionalIngredients),
+                                Codec.BOOL.optionalFieldOf("requires_passive_skill", false)
+                                        .forGetter(AbstractWorkbenchRecipe::hasPassiveSkillRequirement))
+                        .apply(instance, (id, predicate, itemBonus, ingredients, requiresPassiveSkill) ->
+                                new WorkbenchUpgradeBonusRecipe(
+                                        id, predicate, ingredients, requiresPassiveSkill, itemBonus)));
+
+        private static final StreamCodec<RegistryFriendlyByteBuf, WorkbenchUpgradeBonusRecipe>
+                STREAM_CODEC = StreamCodec.of(Serializer::encode, Serializer::decode);
+
         @Override
-        public @NotNull WorkbenchUpgradeBonusRecipe fromJson(@NotNull ResourceLocation id, @NotNull JsonObject jsonObject) {
-            ItemStackPredicate baseItemStackPredicate = SerializationHelper.deserializeItemPredicate(jsonObject, "base_item_condition");
-            ItemBonus<?> itemBonus = SerializationHelper.deserializeItemBonus(jsonObject);
-            boolean requiresPassiveSkill = jsonObject.get("requires_passive_skill").getAsBoolean();
-            Map<Ingredient, Integer> additionalIngredients = new HashMap<>();
-            JsonArray ingredientsJson = jsonObject.getAsJsonArray("additionalIngredients");
-            for (JsonElement jsonElement : ingredientsJson) {
-                Ingredient ingredient = Ingredient.fromJson(jsonElement.getAsJsonObject().get("ingredient"));
-                int requiredAmount = jsonElement.getAsJsonObject().get("required_amount").getAsInt();
-                additionalIngredients.put(ingredient, requiredAmount);
-            }
-            return new WorkbenchUpgradeBonusRecipe(id, baseItemStackPredicate, additionalIngredients, requiresPassiveSkill, itemBonus);
+        public @NotNull MapCodec<WorkbenchUpgradeBonusRecipe> codec() {
+            return CODEC;
         }
 
         @Override
-        public @Nullable WorkbenchUpgradeBonusRecipe fromNetwork(@NotNull ResourceLocation id, @NotNull FriendlyByteBuf buf) {
+        public @NotNull StreamCodec<RegistryFriendlyByteBuf, WorkbenchUpgradeBonusRecipe> streamCodec() {
+            return STREAM_CODEC;
+        }
+
+        private static WorkbenchUpgradeBonusRecipe decode(RegistryFriendlyByteBuf buf) {
+            ResourceLocation id = buf.readResourceLocation();
             ItemStackPredicate baseItemStackPredicate = NetworkHelper.readItemPredicate(buf);
             ItemBonus<?> itemBonus = NetworkHelper.readItemBonus(buf);
             boolean requiresPassiveSkill = buf.readBoolean();
-            Map<Ingredient, Integer> additionalIngredients = new HashMap<>();
-            int ingredientsCount = buf.readInt();
-            for (int i = 0; i < ingredientsCount; i++) {
-                additionalIngredients.put(Ingredient.fromNetwork(buf), buf.readInt());
-            }
-            return new WorkbenchUpgradeBonusRecipe(id, baseItemStackPredicate, additionalIngredients, requiresPassiveSkill, itemBonus);
+            Map<Ingredient, Integer> ingredients = WorkbenchRecipeCodecs.readIngredientMap(buf);
+            return new WorkbenchUpgradeBonusRecipe(
+                    id, baseItemStackPredicate, ingredients, requiresPassiveSkill, itemBonus);
         }
 
-        @Override
-        public void toNetwork(@NotNull FriendlyByteBuf buf, @NotNull WorkbenchUpgradeBonusRecipe recipe) {
+        private static void encode(RegistryFriendlyByteBuf buf, WorkbenchUpgradeBonusRecipe recipe) {
+            buf.writeResourceLocation(recipe.getId());
             NetworkHelper.writeItemPredicate(buf, recipe.baseItemStackPredicate);
             NetworkHelper.writeItemBonus(buf, recipe.itemBonus);
             buf.writeBoolean(recipe.hasPassiveSkillRequirement());
-            int ingredientsCount = recipe.getAdditionalIngredients().size();
-            buf.writeInt(ingredientsCount);
-            recipe.getAdditionalIngredients().forEach((ingredient, requiredAmount) -> {
-                ingredient.toNetwork(buf);
-                buf.writeInt(requiredAmount);
-            });
+            WorkbenchRecipeCodecs.writeIngredientMap(buf, recipe.additionalIngredients);
+        }
+
+        private static ItemStackPredicate deserializeItemPredicate(JsonObject predicateJson) {
+            JsonObject wrapper = new JsonObject();
+            wrapper.add("base_item_condition", predicateJson);
+            return SerializationHelper.deserializeItemPredicate(wrapper, "base_item_condition");
+        }
+
+        private static JsonObject serializeItemPredicate(ItemStackPredicate predicate) {
+            JsonObject wrapper = new JsonObject();
+            SerializationHelper.serializeItemPredicate(wrapper, predicate, "base_item_condition");
+            return wrapper.getAsJsonObject("base_item_condition");
+        }
+
+        private static ItemBonus<?> deserializeItemBonus(JsonObject itemBonusJson) {
+            JsonObject wrapper = new JsonObject();
+            wrapper.add("item_bonus", itemBonusJson);
+            return SerializationHelper.deserializeItemBonus(wrapper);
+        }
+
+        private static JsonObject serializeItemBonus(ItemBonus<?> itemBonus) {
+            JsonObject wrapper = new JsonObject();
+            SerializationHelper.serializeItemBonus(wrapper, itemBonus);
+            return wrapper.getAsJsonObject("item_bonus");
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchVanillaCraftingRecipe.java b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchVanillaCraftingRecipe.java
index 775f7e776..49a019ac8 100644
--- a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchVanillaCraftingRecipe.java
+++ b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchVanillaCraftingRecipe.java
@@ -1,51 +1,54 @@
 package daripher.skilltree.recipe.workbench;
 
-import com.google.gson.JsonObject;
 import daripher.skilltree.inventory.menu.WorkbenchContainer;
 import daripher.skilltree.skill.SkillBonusProvider;
 import daripher.skilltree.skill.bonus.player.VanillaRecipeUnlockBonus;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.core.NonNullList;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.CraftingRecipe;
 import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.crafting.RecipeHolder;
 import net.minecraft.world.item.crafting.RecipeSerializer;
 import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.*;
-import java.util.stream.Collectors;
-
 public class WorkbenchVanillaCraftingRecipe extends AbstractWorkbenchRecipe {
     private @Nullable Pair<Ingredient, Integer> baseIngredient;
     private Map<Ingredient, Integer> additionalIngredients;
     private final ItemStack result;
-
-    public WorkbenchVanillaCraftingRecipe(CraftingRecipe vanillaRecipe, RegistryAccess registryAccess) {
-        super(vanillaRecipe.getId(), true);
-        this.result = vanillaRecipe.getResultItem(registryAccess);
-        additionalIngredients = getIngredientsFromCraftingRecipe(vanillaRecipe);
-        List<Pair<Ingredient, Integer>> ingredients = new ArrayList<>(additionalIngredients.entrySet().stream().map(Pair::of).toList());
+    private final RecipeSerializer<?> serializer;
+
+    public WorkbenchVanillaCraftingRecipe(
+            RecipeHolder<CraftingRecipe> vanillaRecipe,
+            HolderLookup.Provider registryAccess) {
+        super(vanillaRecipe.id(), true);
+        CraftingRecipe recipe = vanillaRecipe.value();
+        this.result = recipe.getResultItem(registryAccess);
+        this.serializer = recipe.getSerializer();
+        additionalIngredients = getIngredientsFromCraftingRecipe(recipe);
+        List<Pair<Ingredient, Integer>> ingredients =
+                new ArrayList<>(additionalIngredients.entrySet().stream().map(Pair::of).toList());
         if (!ingredients.isEmpty()) {
             this.baseIngredient = ingredients.remove(0);
-            additionalIngredients = ingredients.stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+            additionalIngredients = ingredients.stream()
+                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
         }
     }
 
-    private WorkbenchVanillaCraftingRecipe(@NotNull ResourceLocation id, @Nullable Pair<Ingredient, Integer> baseIngredient, Map<Ingredient, Integer> additionalIngredients, ItemStack result) {
-        super(id, true);
-        this.result = result;
-        this.baseIngredient = baseIngredient;
-        this.additionalIngredients = additionalIngredients;
-    }
-
-    private static Map<Ingredient, Integer> getIngredientsFromCraftingRecipe(CraftingRecipe vanillaRecipe) {
+    private static Map<Ingredient, Integer> getIngredientsFromCraftingRecipe(
+            CraftingRecipe vanillaRecipe) {
         record IngredientKey(Set<Item> items) {
         }
         Map<IngredientKey, Ingredient> uniqueIngredients = new HashMap<>();
@@ -65,28 +68,28 @@ record IngredientKey(Set<Item> items) {
             ingredientCounts.put(key, ingredientCounts.getOrDefault(key, 0) + 1);
         }
         Map<Ingredient, Integer> result = new HashMap<>(ingredientCounts.size());
-        for (Map.Entry<IngredientKey, Integer> entry : ingredientCounts.entrySet()) {
-            result.put(uniqueIngredients.get(entry.getKey()), entry.getValue());
-        }
+        ingredientCounts.forEach(
+                (key, count) -> result.put(uniqueIngredients.get(key), count));
         return result;
     }
 
     @Override
-    public @NotNull ItemStack assemble(@NotNull WorkbenchContainer container, @NotNull RegistryAccess registryAccess) {
+    public @NotNull ItemStack assemble(
+            @NotNull WorkbenchContainer container,
+            @NotNull HolderLookup.Provider registryAccess) {
         return getResult(container);
     }
 
     @Override
     public boolean isValidBaseItem(ItemStack itemStack) {
-        if (baseIngredient == null) {
-            return false;
-        }
-        return baseIngredient.getKey().test(itemStack) && itemStack.getCount() >= baseIngredient.getValue();
+        return baseIngredient != null
+                && baseIngredient.getLeft().test(itemStack)
+                && itemStack.getCount() >= baseIngredient.getRight();
     }
 
     @Override
     public Map<Ingredient, Integer> getAdditionalIngredients(ItemStack baseIngredient) {
-        return getAdditionalIngredients();
+        return additionalIngredients;
     }
 
     public Map<Ingredient, Integer> getAdditionalIngredients() {
@@ -95,13 +98,9 @@ public Map<Ingredient, Integer> getAdditionalIngredients() {
 
     @Override
     public boolean isLockedFor(@NotNull Player player) {
-        List<VanillaRecipeUnlockBonus> recipeUnlockBonuses = SkillBonusProvider.getSkillBonuses(player, VanillaRecipeUnlockBonus.class);
-        for (VanillaRecipeUnlockBonus skillBonus : recipeUnlockBonuses) {
-            if (skillBonus.canUnlockRecipe(this)) {
-                return false;
-            }
-        }
-        return true;
+        List<VanillaRecipeUnlockBonus> recipeUnlockBonuses =
+                SkillBonusProvider.getSkillBonuses(player, VanillaRecipeUnlockBonus.class);
+        return recipeUnlockBonuses.stream().noneMatch(bonus -> bonus.canUnlockRecipe(this));
     }
 
     @Override
@@ -120,10 +119,7 @@ public Component getShortDescription() {
 
     @Override
     public int requiredBaseItemAmount() {
-        if (baseIngredient == null) {
-            return 0;
-        }
-        return baseIngredient.getRight();
+        return baseIngredient == null ? 0 : baseIngredient.getRight();
     }
 
     @Override
@@ -133,46 +129,6 @@ public int requiredBaseItemAmount() {
 
     @Override
     public @NotNull RecipeSerializer<?> getSerializer() {
-        return new Serializer();
-    }
-
-    public static class Serializer implements RecipeSerializer<WorkbenchVanillaCraftingRecipe> {
-        @Override
-        public @NotNull WorkbenchVanillaCraftingRecipe fromJson(@NotNull ResourceLocation id, @NotNull JsonObject jsonObject) {
-            throw new UnsupportedOperationException("Attempted to load an invalid recipe type.");
-        }
-
-        @Override
-        public @Nullable WorkbenchVanillaCraftingRecipe fromNetwork(@NotNull ResourceLocation id, @NotNull FriendlyByteBuf buf) {
-            Map<Ingredient, Integer> ingredients = new HashMap<>();
-            int ingredientsCount = buf.readInt();
-            for (int i = 0; i < ingredientsCount; i++) {
-                ingredients.put(Ingredient.fromNetwork(buf), buf.readInt());
-            }
-            Pair<Ingredient, Integer> baseIngredient = null;
-            boolean hasBaseIngredient = buf.readBoolean();
-            if (hasBaseIngredient) {
-                baseIngredient = Pair.of(Ingredient.fromNetwork(buf), buf.readInt());
-            }
-            ItemStack result = buf.readItem();
-            return new WorkbenchVanillaCraftingRecipe(id, baseIngredient, ingredients, result);
-        }
-
-        @Override
-        public void toNetwork(@NotNull FriendlyByteBuf buf, @NotNull WorkbenchVanillaCraftingRecipe recipe) {
-            int ingredientsCount = recipe.getAdditionalIngredients().size();
-            buf.writeInt(ingredientsCount);
-            recipe.getAdditionalIngredients().forEach((ingredient, requiredAmount) -> {
-                ingredient.toNetwork(buf);
-                buf.writeInt(requiredAmount);
-            });
-            Pair<Ingredient, Integer> baseIngredient = recipe.baseIngredient;
-            buf.writeBoolean(baseIngredient != null);
-            if (baseIngredient != null) {
-                baseIngredient.getLeft().toNetwork(buf);
-                buf.writeInt(baseIngredient.getRight());
-            }
-            buf.writeItem(recipe.result);
-        }
+        return serializer;
     }
 }
diff --git a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchWeaponPoisoningRecipe.java b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchWeaponPoisoningRecipe.java
index 980c489f0..e6f87ff54 100644
--- a/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchWeaponPoisoningRecipe.java
+++ b/src/main/java/daripher/skilltree/recipe/workbench/WorkbenchWeaponPoisoningRecipe.java
@@ -1,12 +1,23 @@
 package daripher.skilltree.recipe.workbench;
 
-import com.google.gson.JsonObject;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.event.PoisonedWeaponEvents;
 import daripher.skilltree.init.PSTRecipeSerializers;
 import daripher.skilltree.inventory.menu.WorkbenchContainer;
 import daripher.skilltree.skill.bonus.predicate.item.EquipmentPredicate;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.network.FriendlyByteBuf;
+import daripher.skilltree.util.ForgeRegistries;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.StreamSupport;
+import java.util.stream.Stream;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.effect.MobEffectCategory;
@@ -15,29 +26,25 @@
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
 import net.minecraft.world.item.alchemy.Potion;
-import net.minecraft.world.item.alchemy.PotionUtils;
+import net.minecraft.world.item.alchemy.PotionContents;
 import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraftforge.registries.ForgeRegistries;
 import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Stream;
 
 public class WorkbenchWeaponPoisoningRecipe extends AbstractWorkbenchRecipe {
     private final int maxUses;
 
-    public WorkbenchWeaponPoisoningRecipe(ResourceLocation id, boolean requiresPassiveSkill, int maxUses) {
+    public WorkbenchWeaponPoisoningRecipe(
+            ResourceLocation id, boolean requiresPassiveSkill, int maxUses) {
         super(id, requiresPassiveSkill);
         this.maxUses = maxUses;
     }
 
     @Override
-    public @NotNull ItemStack assemble(@NotNull WorkbenchContainer container, @NotNull RegistryAccess registryAccess) {
+    public @NotNull ItemStack assemble(
+            @NotNull WorkbenchContainer container,
+            @NotNull HolderLookup.Provider registryAccess) {
         return getResult(container);
     }
 
@@ -52,8 +59,10 @@ public boolean isValidIngredient(ItemStack itemStack) {
     }
 
     private boolean isValidPoison(ItemStack itemStack) {
-        Stream<MobEffectInstance> effectsStream = PotionUtils.getMobEffects(itemStack).stream();
-        return effectsStream.anyMatch(mobEffectInstance -> mobEffectInstance.getEffect().getCategory() == MobEffectCategory.HARMFUL);
+        PotionContents contents =
+                itemStack.getOrDefault(DataComponents.POTION_CONTENTS, PotionContents.EMPTY);
+        return StreamSupport.stream(contents.getAllEffects().spliterator(), false)
+                .anyMatch(WorkbenchWeaponPoisoningRecipe::isHarmfulEffect);
     }
 
     @Override
@@ -63,8 +72,9 @@ public Pair<Ingredient, Integer> getBaseIngredient() {
 
     private Ingredient getMeleeWeaponIngredient() {
         Collection<Item> items = ForgeRegistries.ITEMS.getValues();
-        Stream<ItemStack> meleeWeapons = items.stream().map(ItemStack::new).filter(EquipmentPredicate::isMeleeWeapon);
-        return Ingredient.of(meleeWeapons.toList().toArray(new ItemStack[0]));
+        Stream<ItemStack> meleeWeapons =
+                items.stream().map(ItemStack::new).filter(EquipmentPredicate::isMeleeWeapon);
+        return Ingredient.of(meleeWeapons.toArray(ItemStack[]::new));
     }
 
     @Override
@@ -73,27 +83,20 @@ public Map<Ingredient, Integer> getAdditionalIngredients(ItemStack baseIngredien
     }
 
     private Ingredient getPoisonIngredient() {
-        Item baseItem = Items.POTION;
         Collection<Potion> availablePotions = ForgeRegistries.POTIONS.getValues();
-        Stream<Potion> harmfulPotions = availablePotions.stream().filter(WorkbenchWeaponPoisoningRecipe::isHarmfulPotion);
-        Stream<ItemStack> suitablePotionStacks = harmfulPotions.map(potion -> getPotionStack(baseItem, potion));
-        return Ingredient.of(suitablePotionStacks.toList().toArray(new ItemStack[0]));
+        Stream<ItemStack> suitablePotionStacks = availablePotions.stream()
+                .filter(WorkbenchWeaponPoisoningRecipe::isHarmfulPotion)
+                .map(potion -> PotionContents.createItemStack(
+                        Items.POTION, ForgeRegistries.POTIONS.wrapAsHolder(potion)));
+        return Ingredient.of(suitablePotionStacks.toArray(ItemStack[]::new));
     }
 
     private static boolean isHarmfulPotion(Potion potion) {
-        List<MobEffectInstance> effects = potion.getEffects();
-        for (MobEffectInstance mobEffectInstance : effects) {
-            if (mobEffectInstance.getEffect().getCategory() == MobEffectCategory.HARMFUL) {
-                return true;
-            }
-        }
-        return false;
+        return potion.getEffects().stream().anyMatch(WorkbenchWeaponPoisoningRecipe::isHarmfulEffect);
     }
 
-    private static @NotNull ItemStack getPotionStack(Item baseItem, Potion potion) {
-        ItemStack itemStack = new ItemStack(baseItem);
-        PotionUtils.setPotion(itemStack, potion);
-        return itemStack;
+    private static boolean isHarmfulEffect(MobEffectInstance effect) {
+        return effect.getEffect().value().getCategory() == MobEffectCategory.HARMFUL;
     }
 
     @Override
@@ -105,9 +108,9 @@ public Component getShortDescription() {
     public @NotNull ItemStack getResult(WorkbenchContainer workbenchContainer) {
         ItemStack weaponStack = workbenchContainer.getBaseItem();
         ItemStack potionStack = workbenchContainer.getItem(1);
-        ItemStack resultItemStack = new ItemStack(weaponStack.getItem());
-        PoisonedWeaponEvents.setPoisonedWeaponEffects(resultItemStack, potionStack, maxUses);
-        return resultItemStack;
+        ItemStack result = weaponStack.copyWithCount(1);
+        PoisonedWeaponEvents.setPoisonedWeaponEffects(result, potionStack, maxUses);
+        return result;
     }
 
     @Override
@@ -121,24 +124,40 @@ public int requiredBaseItemAmount() {
     }
 
     public static class Serializer implements RecipeSerializer<WorkbenchWeaponPoisoningRecipe> {
+        private static final ResourceLocation UNKNOWN_ID =
+                ResourceLocation.fromNamespaceAndPath(SkillTreeMod.MOD_ID, "unknown");
+        private static final MapCodec<WorkbenchWeaponPoisoningRecipe> CODEC =
+                RecordCodecBuilder.mapCodec(instance -> instance.group(
+                                ResourceLocation.CODEC.optionalFieldOf("id", UNKNOWN_ID)
+                                        .forGetter(AbstractWorkbenchRecipe::getId),
+                                Codec.BOOL.optionalFieldOf("requires_passive_skill", false)
+                                        .forGetter(AbstractWorkbenchRecipe::hasPassiveSkillRequirement),
+                                Codec.INT.fieldOf("max_uses")
+                                        .forGetter(recipe -> recipe.maxUses))
+                        .apply(instance, WorkbenchWeaponPoisoningRecipe::new));
+        private static final StreamCodec<RegistryFriendlyByteBuf, WorkbenchWeaponPoisoningRecipe>
+                STREAM_CODEC = StreamCodec.of(Serializer::encode, Serializer::decode);
+
         @Override
-        public @NotNull WorkbenchWeaponPoisoningRecipe fromJson(@NotNull ResourceLocation id, @NotNull JsonObject jsonObject) {
-            boolean requiresPassiveSkill = jsonObject.get("requires_passive_skill").getAsBoolean();
-            int maxUses = jsonObject.get("max_uses").getAsInt();
-            return new WorkbenchWeaponPoisoningRecipe(id, requiresPassiveSkill, maxUses);
+        public @NotNull MapCodec<WorkbenchWeaponPoisoningRecipe> codec() {
+            return CODEC;
         }
 
         @Override
-        public @Nullable WorkbenchWeaponPoisoningRecipe fromNetwork(@NotNull ResourceLocation id, @NotNull FriendlyByteBuf buf) {
-            boolean requiresPassiveSkill = buf.readBoolean();
-            int maxUses = buf.readInt();
-            return new WorkbenchWeaponPoisoningRecipe(id, requiresPassiveSkill, maxUses);
+        public @NotNull StreamCodec<RegistryFriendlyByteBuf, WorkbenchWeaponPoisoningRecipe> streamCodec() {
+            return STREAM_CODEC;
         }
 
-        @Override
-        public void toNetwork(@NotNull FriendlyByteBuf buf, @NotNull WorkbenchWeaponPoisoningRecipe recipe) {
+        private static WorkbenchWeaponPoisoningRecipe decode(RegistryFriendlyByteBuf buf) {
+            return new WorkbenchWeaponPoisoningRecipe(
+                    buf.readResourceLocation(), buf.readBoolean(), buf.readVarInt());
+        }
+
+        private static void encode(
+                RegistryFriendlyByteBuf buf, WorkbenchWeaponPoisoningRecipe recipe) {
+            buf.writeResourceLocation(recipe.getId());
             buf.writeBoolean(recipe.hasPassiveSkillRequirement());
-            buf.writeInt(recipe.maxUses);
+            buf.writeVarInt(recipe.maxUses);
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/SkillBonusProvider.java b/src/main/java/daripher/skilltree/skill/SkillBonusProvider.java
index 174dbf577..5d2d7843e 100644
--- a/src/main/java/daripher/skilltree/skill/SkillBonusProvider.java
+++ b/src/main/java/daripher/skilltree/skill/SkillBonusProvider.java
@@ -66,7 +66,7 @@ private static <T> List<T> getSkillTreeBonuses(Player player, Class<T> type) {
     private static <T> List<T> getEffectBonuses(Player player, Class<T> type) {
         List<T> bonuses = new ArrayList<>();
         for (MobEffectInstance e : player.getActiveEffects()) {
-            if (e.getEffect() instanceof SkillBonusEffect skillEffect) {
+            if (e.getEffect().value() instanceof SkillBonusEffect skillEffect) {
                 SkillBonus<?> bonus = skillEffect.getBonus().copy();
                 if (type.isInstance(bonus)) {
                     bonus = bonus.copy().multiply(e.getAmplifier());
diff --git a/src/main/java/daripher/skilltree/skill/bonus/SkillBonus.java b/src/main/java/daripher/skilltree/skill/bonus/SkillBonus.java
index 16bd79375..841984c28 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/SkillBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/SkillBonus.java
@@ -50,7 +50,7 @@ default MutableComponent getSimpleTooltip() {
     default List<MutableComponent> getFullTooltip() {
         return List.of(getSimpleTooltip());
     }
-    
+
     default void gatherInfo(Consumer<MutableComponent> consumer) {
         TooltipHelper.consumeTranslated(getDescriptionId() + ".info", consumer);
     }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/function/AttributeValueFunction.java b/src/main/java/daripher/skilltree/skill/bonus/function/AttributeValueFunction.java
index 9c0e665eb..49644efae 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/function/AttributeValueFunction.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/function/AttributeValueFunction.java
@@ -9,6 +9,8 @@
 import daripher.skilltree.skill.bonus.SkillBonus;
 import daripher.skilltree.skill.bonus.predicate.living.FloatFunctionEntityPredicate;
 import net.minecraft.ChatFormatting;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
@@ -30,7 +32,10 @@ public AttributeValueFunction(Attribute attribute) {
     @Override
     public float apply(LivingEntity entity) {
         AttributeMap attributes = entity.getAttributes();
-        return attributes.hasAttribute(attribute) ? (float) attributes.getValue(attribute) : 0f;
+        Holder<Attribute> attributeHolder = BuiltInRegistries.ATTRIBUTE.wrapAsHolder(attribute);
+        return attributes.hasAttribute(attributeHolder)
+                ? (float) attributes.getValue(attributeHolder)
+                : 0f;
     }
 
     @Override
@@ -136,7 +141,7 @@ public void serialize(FriendlyByteBuf buf, FloatFunction<?> provider) {
 
         @Override
         public FloatFunction<?> createDefaultInstance() {
-            return new AttributeValueFunction(Attributes.MAX_HEALTH);
+            return new AttributeValueFunction(Attributes.MAX_HEALTH.value());
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/function/EffectAmountFunction.java b/src/main/java/daripher/skilltree/skill/bonus/function/EffectAmountFunction.java
index 6b770f851..d16f2b83f 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/function/EffectAmountFunction.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/function/EffectAmountFunction.java
@@ -29,7 +29,9 @@ public EffectAmountFunction(MobEffectType effectType) {
 
     @Override
     public float apply(LivingEntity entity) {
-        List<MobEffect> effects = entity.getActiveEffects().stream().map(MobEffectInstance::getEffect).toList();
+        List<MobEffect> effects = entity.getActiveEffects().stream()
+                .map(effect -> effect.getEffect().value())
+                .toList();
         return switch (effectType) {
             case ANY -> effects.size();
             case NEUTRAL -> effects.stream().filter(e -> e.getCategory() == MobEffectCategory.NEUTRAL).count();
diff --git a/src/main/java/daripher/skilltree/skill/bonus/function/EnchantmentAmountFunction.java b/src/main/java/daripher/skilltree/skill/bonus/function/EnchantmentAmountFunction.java
index 49b859ae5..b750732ab 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/function/EnchantmentAmountFunction.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/function/EnchantmentAmountFunction.java
@@ -39,7 +39,7 @@ public float apply(LivingEntity entity) {
     }
 
     private int getEnchants(Stream<ItemStack> items) {
-        return items.map(EnchantmentHelper::getEnchantments).map(Map::size).reduce(Integer::sum).orElse(0);
+        return items.map(ItemStack::getEnchantments).mapToInt(enchantments -> enchantments.size()).sum();
     }
 
     @Override
diff --git a/src/main/java/daripher/skilltree/skill/bonus/function/EnchantmentLevelsFunction.java b/src/main/java/daripher/skilltree/skill/bonus/function/EnchantmentLevelsFunction.java
index 8ea5c8a21..600298d99 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/function/EnchantmentLevelsFunction.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/function/EnchantmentLevelsFunction.java
@@ -38,8 +38,11 @@ public float apply(LivingEntity entity) {
     }
 
     private int getEnchantLevels(Stream<ItemStack> items) {
-        return items.map(EnchantmentHelper::getEnchantments).mapToInt(m -> m.values().stream().reduce(Integer::sum).orElse(0))
-                .reduce(Integer::sum).orElse(0);
+        return items.map(ItemStack::getEnchantments)
+                .mapToInt(enchantments -> enchantments.entrySet().stream()
+                        .mapToInt(entry -> entry.getIntValue())
+                        .sum())
+                .sum();
     }
 
     @Override
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/ArrowRetrievalChanceBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/ArrowRetrievalChanceBonusHandler.java
index cb2f6e5c0..481af4fc1 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/ArrowRetrievalChanceBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/ArrowRetrievalChanceBonusHandler.java
@@ -12,19 +12,19 @@
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.entity.projectile.AbstractArrow;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.event.entity.living.LivingDeathEvent;
-import net.minecraftforge.event.entity.living.LivingHurtEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingDeathEvent;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class ArrowRetrievalChanceBonusHandler {
     public static final String STUCK_ARROWS_TAG_NAME = "StuckArrows";
 
     @SubscribeEvent
-    public static void saveStuckArrows(LivingHurtEvent event) {
+    public static void saveStuckArrows(LivingIncomingDamageEvent event) {
         DamageSource damageSource = event.getSource();
         if (!(damageSource.getDirectEntity() instanceof AbstractArrow arrow)) {
             return;
@@ -54,7 +54,7 @@ public static void saveStuckArrows(LivingHurtEvent event) {
         LivingEntity target = event.getEntity();
         CompoundTag targetPersistentData = target.getPersistentData();
         ListTag stuckArrowsTag = targetPersistentData.getList(STUCK_ARROWS_TAG_NAME, Tag.TAG_COMPOUND);
-        stuckArrowsTag.add(arrowStack.save(new CompoundTag()));
+        stuckArrowsTag.add(arrowStack.save(target.registryAccess(), new CompoundTag()));
         targetPersistentData.put(STUCK_ARROWS_TAG_NAME, stuckArrowsTag);
     }
 
@@ -67,7 +67,7 @@ public static void retrieveArrows(LivingDeathEvent event) {
             return;
         }
         for (Tag tag : arrowsTag) {
-            ItemStack arrowStack = ItemStack.of((CompoundTag) tag);
+            ItemStack arrowStack = ItemStack.parseOptional(entity.registryAccess(), (CompoundTag) tag);
             entity.spawnAtLocation(arrowStack);
         }
     }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/BlockBreakSpeedBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/BlockBreakSpeedBonusHandler.java
index f7ce2694a..395f828f1 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/BlockBreakSpeedBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/BlockBreakSpeedBonusHandler.java
@@ -4,13 +4,13 @@
 import daripher.skilltree.skill.SkillBonusProvider;
 import daripher.skilltree.skill.bonus.player.BlockBreakSpeedBonus;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.player.PlayerEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.player.PlayerEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class BlockBreakSpeedBonusHandler {
     @SubscribeEvent
     public static void modifyBlockBreakSpeed(PlayerEvent.BreakSpeed event) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/CriticalHitChanceBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/CriticalHitChanceBonusHandler.java
index aa9beef71..7f21060c0 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/CriticalHitChanceBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/CriticalHitChanceBonusHandler.java
@@ -6,13 +6,12 @@
 import net.minecraft.world.damagesource.DamageSource;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.player.CriticalHitEvent;
-import net.minecraftforge.eventbus.api.Event;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.player.CriticalHitEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class CriticalHitChanceBonusHandler {
     @SubscribeEvent(priority = EventPriority.HIGH)
     public static void applyDirectHitCritChance(CriticalHitEvent event) {
@@ -31,7 +30,7 @@ public static void applyDirectHitCritChance(CriticalHitEvent event) {
             return;
         }
         if (!isVanillaCrit) {
-            event.setResult(Event.Result.ALLOW);
+            event.setCriticalHit(true);
         }
     }
 
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/CriticalHitDamageBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/CriticalHitDamageBonusHandler.java
index 68a0b1095..d7161cf22 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/CriticalHitDamageBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/CriticalHitDamageBonusHandler.java
@@ -9,14 +9,13 @@
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.entity.projectile.AbstractArrow;
-import net.minecraftforge.event.entity.living.LivingHurtEvent;
-import net.minecraftforge.event.entity.player.CriticalHitEvent;
-import net.minecraftforge.eventbus.api.Event;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.neoforge.event.entity.player.CriticalHitEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class CriticalHitDamageBonusHandler {
     @SubscribeEvent(priority = EventPriority.LOW)
     public static void applyCritBonuses(CriticalHitEvent event) {
@@ -27,17 +26,17 @@ public static void applyCritBonuses(CriticalHitEvent event) {
         if (!(event.getTarget() instanceof LivingEntity hurtEntity)) {
             return;
         }
-        boolean isCrit = event.isVanillaCritical() || event.getResult() == Event.Result.ALLOW;
+        boolean isCrit = event.isCriticalHit();
         if (!isCrit) {
             return;
         }
         DamageSource damageSource = player.level().damageSources().playerAttack(player);
         float modCritMultiplier = getCritDamageModifier(player, damageSource, hurtEntity);
-        event.setDamageModifier(1.5f + modCritMultiplier);
+        event.setDamageMultiplier(1.5f + modCritMultiplier);
     }
 
     @SubscribeEvent(priority = EventPriority.LOW)
-    public static void applyIndirectHitCritDamage(LivingHurtEvent event) {
+    public static void applyIndirectHitCritDamage(LivingIncomingDamageEvent event) {
         DamageSource damageSource = event.getSource();
         Entity directDamagingEntity = damageSource.getDirectEntity();
         // direct damage, handled by the method above, ignoring
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/DamageAvoidanceBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/DamageAvoidanceBonusHandler.java
index 031fc3665..1d63354a6 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/DamageAvoidanceBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/DamageAvoidanceBonusHandler.java
@@ -9,18 +9,18 @@
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.entity.projectile.Projectile;
-import net.minecraftforge.event.entity.living.LivingAttackEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class DamageAvoidanceBonusHandler {
     @SubscribeEvent(priority = EventPriority.LOWEST)
-    public static void applyDamageAvoidanceBonuses(LivingAttackEvent event) {
+    public static void applyDamageAvoidanceBonuses(LivingIncomingDamageEvent event) {
         if (!(event.getEntity() instanceof Player player)) {
             return;
         }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/DamageConversionBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/DamageConversionBonusHandler.java
index 76667b50b..0d03a9589 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/DamageConversionBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/DamageConversionBonusHandler.java
@@ -7,22 +7,22 @@
 import net.minecraft.world.damagesource.DamageSource;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.LivingHurtEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class DamageConversionBonusHandler {
     // recursion protection
     private static boolean isProcessingConversion;
 
     @SubscribeEvent(priority = EventPriority.LOWEST)
-    public static void dealConvertedDamage(LivingHurtEvent event) {
+    public static void dealConvertedDamage(LivingIncomingDamageEvent event) {
         if (isProcessingConversion) {
             return;
         }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/EffectDurationBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/EffectDurationBonusHandler.java
index b52f5624d..7bd49028e 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/EffectDurationBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/EffectDurationBonusHandler.java
@@ -10,13 +10,13 @@
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.entity.projectile.Projectile;
-import net.minecraftforge.event.entity.living.MobEffectEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.MobEffectEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class EffectDurationBonusHandler {
     @SubscribeEvent
     public static void applyEffectDurationBonuses(MobEffectEvent.Added event) {
@@ -33,7 +33,7 @@ public static void applyEffectDurationBonuses(MobEffectEvent.Added event) {
         }
         float durationMultiplier = 1f;
         MobEffectInstance effectInstance = event.getEffectInstance();
-        MobEffect mobEffect = effectInstance.getEffect();
+        MobEffect mobEffect = effectInstance.getEffect().value();
         // outgoing effects, inflicted by players
         if (playerEffectSource != null) {
             List<EffectDurationBonus> skillBonuses = SkillBonusProvider.getSkillBonuses(playerEffectSource, EffectDurationBonus.class);
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/EffectImmunityBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/EffectImmunityBonusHandler.java
index e7af35408..7d34965c0 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/EffectImmunityBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/EffectImmunityBonusHandler.java
@@ -5,26 +5,25 @@
 import daripher.skilltree.skill.bonus.player.EffectImmunityBonus;
 import net.minecraft.world.effect.MobEffect;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.MobEffectEvent;
-import net.minecraftforge.eventbus.api.Event;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.MobEffectEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class EffectImmunityBonusHandler {
     @SubscribeEvent(priority = EventPriority.HIGHEST)
     public static void applyEffectImmunity(MobEffectEvent.Applicable event) {
         if (!(event.getEntity() instanceof Player player)) {
             return;
         }
-        MobEffect mobEffect = event.getEffectInstance().getEffect();
+        MobEffect mobEffect = event.getEffectInstance().getEffect().value();
         List<EffectImmunityBonus> skillBonuses = SkillBonusProvider.getSkillBonuses(player, EffectImmunityBonus.class);
         for (EffectImmunityBonus skillBonus : skillBonuses) {
             if (skillBonus.shouldProvideImmunity(mobEffect, player)) {
-                event.setResult(Event.Result.DENY);
+                event.setResult(MobEffectEvent.Applicable.Result.DO_NOT_APPLY);
                 return;
             }
         }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/EffectImmunityBypassBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/EffectImmunityBypassBonusHandler.java
index c55d8e925..7e6e60694 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/EffectImmunityBypassBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/EffectImmunityBypassBonusHandler.java
@@ -6,15 +6,14 @@
 import net.minecraft.world.effect.MobEffect;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.MobEffectEvent;
-import net.minecraftforge.eventbus.api.Event;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.MobEffectEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class EffectImmunityBypassBonusHandler {
     @SubscribeEvent(priority = EventPriority.LOWEST, receiveCanceled = true)
     public static void bypassEffectImmunity(MobEffectEvent.Applicable event) {
@@ -23,10 +22,10 @@ public static void bypassEffectImmunity(MobEffectEvent.Applicable event) {
             return;
         }
         List<EffectImmunityBypassBonus> skillBonuses = SkillBonusProvider.getSkillBonuses(effectSource, EffectImmunityBypassBonus.class);
-        MobEffect mobEffect = event.getEffectInstance().getEffect();
+        MobEffect mobEffect = event.getEffectInstance().getEffect().value();
         for (EffectImmunityBypassBonus skillBonus : skillBonuses) {
             if (skillBonus.shouldIgnoreEffectImmunity(mobEffect, effectSource, affectedEntity)) {
-                event.setResult(Event.Result.ALLOW);
+                event.setResult(MobEffectEvent.Applicable.Result.APPLY);
                 return;
             }
         }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/EventListenerBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/EventListenerBonusHandler.java
index 5257eee90..7be965ba6 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/EventListenerBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/EventListenerBonusHandler.java
@@ -8,23 +8,22 @@
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.LivingDeathEvent;
-import net.minecraftforge.event.entity.living.LivingEntityUseItemEvent;
-import net.minecraftforge.event.entity.living.LivingHurtEvent;
-import net.minecraftforge.event.entity.living.ShieldBlockEvent;
-import net.minecraftforge.event.entity.player.CriticalHitEvent;
-import net.minecraftforge.eventbus.api.Event;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingDeathEvent;
+import net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.neoforge.event.entity.living.LivingShieldBlockEvent;
+import net.neoforged.neoforge.event.entity.player.CriticalHitEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 import java.util.function.BiConsumer;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class EventListenerBonusHandler {
     @SubscribeEvent
-    public static void triggerHurtEvents(LivingHurtEvent event) {
+    public static void triggerHurtEvents(LivingIncomingDamageEvent event) {
         DamageSource damageSource = event.getSource();
         LivingEntity target = event.getEntity();
         Entity damagingEntity = damageSource.getEntity();
@@ -43,9 +42,7 @@ public static void triggerHurtEvents(LivingHurtEvent event) {
 
     @SubscribeEvent(priority = EventPriority.LOWEST)
     public static void triggerCritEvents(CriticalHitEvent event) {
-        Event.Result eventResult = event.getResult();
-        boolean isCrit = eventResult == Event.Result.ALLOW || (eventResult == Event.Result.DEFAULT && event.isVanillaCritical());
-        if (!isCrit) {
+        if (!event.isCriticalHit()) {
             return;
         }
         if (!(event.getTarget() instanceof LivingEntity target)) {
@@ -58,7 +55,7 @@ public static void triggerCritEvents(CriticalHitEvent event) {
     }
 
     @SubscribeEvent
-    public static void triggerShieldBlockEvents(ShieldBlockEvent event) {
+    public static void triggerShieldBlockEvents(LivingShieldBlockEvent event) {
         if (!(event.getEntity() instanceof Player player)) {
             return;
         }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/ExperienceGainMultiplierBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/ExperienceGainMultiplierBonusHandler.java
index ae0a8b8e7..73ab5fedc 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/ExperienceGainMultiplierBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/ExperienceGainMultiplierBonusHandler.java
@@ -5,16 +5,16 @@
 import daripher.skilltree.skill.bonus.player.ExperienceGainMultiplierBonus;
 import net.minecraft.world.entity.ExperienceOrb;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.common.Tags;
-import net.minecraftforge.event.entity.living.LivingExperienceDropEvent;
-import net.minecraftforge.event.entity.player.ItemFishedEvent;
-import net.minecraftforge.event.level.BlockEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.common.Tags;
+import net.neoforged.neoforge.event.entity.living.LivingExperienceDropEvent;
+import net.neoforged.neoforge.event.entity.player.ItemFishedEvent;
+import net.neoforged.neoforge.event.level.BlockDropsEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class ExperienceGainMultiplierBonusHandler {
     @SubscribeEvent
     public static void applyMobExpBonus(LivingExperienceDropEvent event) {
@@ -28,13 +28,16 @@ public static void applyMobExpBonus(LivingExperienceDropEvent event) {
     }
 
     @SubscribeEvent
-    public static void applyOreMiningExpBonus(BlockEvent.BreakEvent event) {
+    public static void applyOreMiningExpBonus(BlockDropsEvent event) {
         if (!event.getState().is(Tags.Blocks.ORES)) {
             return;
         }
+        if (!(event.getBreaker() instanceof Player player)) {
+            return;
+        }
         float multiplier = 1f;
-        multiplier += getExperienceMultiplierBonus(event.getPlayer(), ExperienceGainMultiplierBonus.ExperienceSource.ORE);
-        event.setExpToDrop((int) (event.getExpToDrop() * multiplier));
+        multiplier += getExperienceMultiplierBonus(player, ExperienceGainMultiplierBonus.ExperienceSource.ORE);
+        event.setDroppedExperience((int) (event.getDroppedExperience() * multiplier));
     }
 
     @SubscribeEvent
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/HealthReservationBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/HealthReservationBonusHandler.java
index e2704972f..f8262f83a 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/HealthReservationBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/HealthReservationBonusHandler.java
@@ -4,23 +4,22 @@
 import daripher.skilltree.skill.SkillBonusProvider;
 import daripher.skilltree.skill.bonus.player.HealthReservationBonus;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.TickEvent;
-import net.minecraftforge.event.entity.living.LivingHealEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.LogicalSide;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.tick.PlayerTickEvent;
+import net.neoforged.neoforge.event.entity.living.LivingHealEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class HealthReservationBonusHandler {
     @SubscribeEvent
-    public static void applyHealthReservation(TickEvent.PlayerTickEvent event) {
-        if (event.phase == TickEvent.Phase.END || event.side == LogicalSide.CLIENT) {
+    public static void applyHealthReservation(PlayerTickEvent.Post event) {
+        Player player = event.getEntity();
+        if (player.level().isClientSide) {
             return;
         }
-        Player player = event.player;
         float reservation = getHealthReservation(player);
         if (reservation == 0) {
             return;
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/IncomingDamageBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/IncomingDamageBonusHandler.java
index 354d37172..f2921eb0c 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/IncomingDamageBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/IncomingDamageBonusHandler.java
@@ -7,17 +7,17 @@
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.LivingHurtEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class IncomingDamageBonusHandler {
     @SubscribeEvent
-    public static void modifyIncomingDamage(LivingHurtEvent event) {
+    public static void modifyIncomingDamage(LivingIncomingDamageEvent event) {
         DamageSource damageSource = event.getSource();
         LivingEntity attacker = getAttacker(damageSource);
         if (!(event.getEntity() instanceof Player player)) {
@@ -31,9 +31,9 @@ public static void modifyIncomingDamage(LivingHurtEvent event) {
         float baseDamageMultiplier = 1f;
         float totalDamageMultiplier = 1f;
         for (IncomingDamageBonus bonus : skillBonuses) {
-            flatDamageBonus += bonus.getDamageModifier(AttributeModifier.Operation.ADDITION, damageSource, player, attacker);
-            baseDamageMultiplier += bonus.getDamageModifier(AttributeModifier.Operation.MULTIPLY_BASE, damageSource, player, attacker);
-            totalDamageMultiplier *= 1f + bonus.getDamageModifier(AttributeModifier.Operation.MULTIPLY_TOTAL, damageSource, player, attacker);
+            flatDamageBonus += bonus.getDamageModifier(AttributeModifier.Operation.ADD_VALUE, damageSource, player, attacker);
+            baseDamageMultiplier += bonus.getDamageModifier(AttributeModifier.Operation.ADD_MULTIPLIED_BASE, damageSource, player, attacker);
+            totalDamageMultiplier *= 1f + bonus.getDamageModifier(AttributeModifier.Operation.ADD_MULTIPLIED_TOTAL, damageSource, player, attacker);
         }
         float amount = event.getAmount();
         amount += flatDamageBonus;
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/IncomingHealingBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/IncomingHealingBonusHandler.java
index 896c60c1e..340c2560e 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/IncomingHealingBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/IncomingHealingBonusHandler.java
@@ -4,13 +4,13 @@
 import daripher.skilltree.skill.SkillBonusProvider;
 import daripher.skilltree.skill.bonus.player.IncomingHealingBonus;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.LivingHealEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingHealEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class IncomingHealingBonusHandler {
     @SubscribeEvent
     public static void modifyIncomingHealing(LivingHealEvent event) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUsagePreventionBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUsagePreventionBonusHandler.java
index d08e96083..3a828f373 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUsagePreventionBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUsagePreventionBonusHandler.java
@@ -10,19 +10,20 @@
 import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.client.event.RenderTooltipEvent;
-import net.minecraftforge.event.entity.living.LivingEquipmentChangeEvent;
-import net.minecraftforge.event.entity.player.AttackEntityEvent;
-import net.minecraftforge.event.entity.player.PlayerInteractEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.api.distmarker.OnlyIn;
+import net.neoforged.neoforge.client.event.RenderTooltipEvent;
+import net.neoforged.neoforge.event.entity.living.LivingEquipmentChangeEvent;
+import net.neoforged.neoforge.event.entity.player.AttackEntityEvent;
+import net.neoforged.neoforge.event.entity.player.PlayerInteractEvent;
+import net.neoforged.bus.api.ICancellableEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class ItemUsagePreventionBonusHandler {
     // recursion protection
     private static boolean isProcessingRejection;
@@ -37,13 +38,45 @@ public static void preventItemUsage(AttackEntityEvent event) {
     }
 
     @SubscribeEvent
-    public static void preventItemUsage(PlayerInteractEvent event) {
+    public static void preventItemUsage(PlayerInteractEvent.LeftClickBlock event) {
+        preventInteraction(event);
+    }
+
+    @SubscribeEvent
+    public static void preventItemUsage(PlayerInteractEvent.RightClickBlock event) {
+        preventInteraction(event);
+    }
+
+    @SubscribeEvent
+    public static void preventItemUsage(PlayerInteractEvent.RightClickItem event) {
+        preventInteraction(event);
+    }
+
+    @SubscribeEvent
+    public static void preventItemUsage(PlayerInteractEvent.EntityInteract event) {
+        preventInteraction(event);
+    }
+
+    @SubscribeEvent
+    public static void preventItemUsage(PlayerInteractEvent.EntityInteractSpecific event) {
+        preventInteraction(event);
+    }
+
+    private static void preventInteraction(PlayerInteractEvent event) {
         Player player = event.getEntity();
         ItemStack itemStack = event.getItemStack();
         if (shouldPreventItemUsage(player, itemStack)) {
-            event.setCancellationResult(InteractionResult.FAIL);
-            if (event.isCancelable()) {
-                event.setCanceled(true);
+            if (event instanceof PlayerInteractEvent.RightClickItem rightClickItem) {
+                rightClickItem.setCancellationResult(InteractionResult.FAIL);
+            } else if (event instanceof PlayerInteractEvent.RightClickBlock rightClickBlock) {
+                rightClickBlock.setCancellationResult(InteractionResult.FAIL);
+            } else if (event instanceof PlayerInteractEvent.EntityInteract entityInteract) {
+                entityInteract.setCancellationResult(InteractionResult.FAIL);
+            } else if (event instanceof PlayerInteractEvent.EntityInteractSpecific entityInteractSpecific) {
+                entityInteractSpecific.setCancellationResult(InteractionResult.FAIL);
+            }
+            if (event instanceof ICancellableEvent cancellableEvent) {
+                cancellableEvent.setCanceled(true);
             }
         }
     }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUsageSpeedBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUsageSpeedBonusHandler.java
index e1a53154c..2b55f6f82 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUsageSpeedBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUsageSpeedBonusHandler.java
@@ -4,13 +4,13 @@
 import daripher.skilltree.skill.SkillBonusProvider;
 import daripher.skilltree.skill.bonus.player.ItemUsageSpeedBonus;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.LivingEntityUseItemEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class ItemUsageSpeedBonusHandler {
     @SubscribeEvent
     public static void applyItemUsageSpeed(LivingEntityUseItemEvent.Tick event) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUseMovementSpeedBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUseMovementSpeedBonusHandler.java
index bd68cc668..972a10c66 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUseMovementSpeedBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/ItemUseMovementSpeedBonusHandler.java
@@ -6,14 +6,14 @@
 import net.minecraft.client.player.Input;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.MovementInputUpdateEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.neoforge.client.event.MovementInputUpdateEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID, value = Dist.CLIENT)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID, value = Dist.CLIENT)
 public class ItemUseMovementSpeedBonusHandler {
     @SubscribeEvent
     public static void modifyItemUseMovementSpeed(MovementInputUpdateEvent event) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/JumpHeightBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/JumpHeightBonusHandler.java
index 97b1fce02..748d13ef6 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/JumpHeightBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/JumpHeightBonusHandler.java
@@ -4,13 +4,13 @@
 import daripher.skilltree.skill.SkillBonusProvider;
 import daripher.skilltree.skill.bonus.player.JumpHeightBonus;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.LivingFallEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingFallEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class JumpHeightBonusHandler {
     public static float getJumpHeightMultiplier(Player player) {
         float multiplier = 1f;
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/LootAmountModifierBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/LootAmountModifierBonusHandler.java
index 2f817350c..c87367042 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/LootAmountModifierBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/LootAmountModifierBonusHandler.java
@@ -5,9 +5,12 @@
 import it.unimi.dsi.fastutil.floats.Float2FloatMap;
 import it.unimi.dsi.fastutil.floats.Float2FloatOpenHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.Registries;
 import net.minecraft.util.RandomSource;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.enchantment.Enchantment;
 import net.minecraft.world.item.enchantment.Enchantments;
 import net.minecraft.world.level.storage.loot.LootContext;
 import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
@@ -26,7 +29,10 @@ public class LootAmountModifierBonusHandler {
             }
             if (lootContext.hasParam(LootContextParams.TOOL)) {
                 ItemStack tool = lootContext.getParam(LootContextParams.TOOL);
-                if (tool.getEnchantmentLevel(Enchantments.SILK_TOUCH) > 0) {
+                Holder<Enchantment> silkTouch = lootContext.getLevel().registryAccess()
+                        .lookupOrThrow(Registries.ENCHANTMENT)
+                        .getOrThrow(Enchantments.SILK_TOUCH);
+                if (tool.getEnchantmentLevel(silkTouch) > 0) {
                     return defaultLoot;
                 }
             }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/OutgoingDamageBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/OutgoingDamageBonusHandler.java
index 793f40415..5a3e92ab0 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/OutgoingDamageBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/OutgoingDamageBonusHandler.java
@@ -7,16 +7,16 @@
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.LivingHurtEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class OutgoingDamageBonusHandler {
     @SubscribeEvent
-    public static void modifyOutgoingDamage(LivingHurtEvent event) {
+    public static void modifyOutgoingDamage(LivingIncomingDamageEvent event) {
         DamageSource damageSource = event.getSource();
         if (!(damageSource.getEntity() instanceof Player player)) {
             return;
@@ -30,9 +30,9 @@ public static void modifyOutgoingDamage(LivingHurtEvent event) {
         float baseDamageMultiplier = 1f;
         float totalDamageMultiplier = 1f;
         for (OutgoingDamageBonus bonus : skillBonuses) {
-            flatDamageBonus += bonus.getDamageModifier(AttributeModifier.Operation.ADDITION, damageSource, player, target);
-            baseDamageMultiplier += bonus.getDamageModifier(AttributeModifier.Operation.MULTIPLY_BASE, damageSource, player, target);
-            totalDamageMultiplier *= 1f + bonus.getDamageModifier(AttributeModifier.Operation.MULTIPLY_TOTAL, damageSource, player, target);
+            flatDamageBonus += bonus.getDamageModifier(AttributeModifier.Operation.ADD_VALUE, damageSource, player, target);
+            baseDamageMultiplier += bonus.getDamageModifier(AttributeModifier.Operation.ADD_MULTIPLIED_BASE, damageSource, player, target);
+            totalDamageMultiplier *= 1f + bonus.getDamageModifier(AttributeModifier.Operation.ADD_MULTIPLIED_TOTAL, damageSource, player, target);
         }
         float amount = event.getAmount();
         amount += flatDamageBonus;
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/ProjectileDuplicationBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/ProjectileDuplicationBonusHandler.java
index 6926b7318..192961b5a 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/ProjectileDuplicationBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/ProjectileDuplicationBonusHandler.java
@@ -14,15 +14,15 @@
 import net.minecraft.world.entity.projectile.Projectile;
 import net.minecraft.world.entity.projectile.ThrownPotion;
 import net.minecraft.world.phys.Vec3;
-import net.minecraftforge.event.entity.EntityJoinLevelEvent;
-import net.minecraftforge.event.entity.living.LivingHurtEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.EntityJoinLevelEvent;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class ProjectileDuplicationBonusHandler {
     public static final String IS_DUPLICATED_TAG_NAME = "IS_DUPLICATED";
 
@@ -93,10 +93,10 @@ private static void spawnDuplicateProjectileWithOffset(Projectile original, Play
         projectileTag.putBoolean(IS_DUPLICATED_TAG_NAME, true);
         if (duplicate instanceof AbstractArrow duplicateArrow) {
             AbstractArrow originalArrow = (AbstractArrow) original;
+            CompoundTag arrowData = new CompoundTag();
+            originalArrow.addAdditionalSaveData(arrowData);
+            duplicateArrow.readAdditionalSaveData(arrowData);
             duplicateArrow.pickup = AbstractArrow.Pickup.DISALLOWED;
-            float velocity = (float) movementVector.length();
-            duplicateArrow.setEnchantmentEffectsFromEntity(player, velocity);
-            duplicateArrow.setBaseDamage(originalArrow.getBaseDamage());
         } else if (duplicate instanceof ThrownPotion potion) {
             ThrownPotion originalPotion = (ThrownPotion) original;
             potion.setItem(originalPotion.getItem());
@@ -114,7 +114,7 @@ private static Vec3 rotateVector(Vec3 vector, double angleDegrees) {
     }
 
     @SubscribeEvent(priority = EventPriority.HIGH)
-    public static void removeInvulnerabilityTicksForDupedProjectiles(LivingHurtEvent event) {
+    public static void removeInvulnerabilityTicksForDupedProjectiles(LivingIncomingDamageEvent event) {
         DamageSource damageSource = event.getSource();
         if (!(damageSource.getDirectEntity() instanceof Projectile projectile)) {
             return;
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/ProjectileSpeedBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/ProjectileSpeedBonusHandler.java
index 3229117b4..7c4e697a1 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/ProjectileSpeedBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/ProjectileSpeedBonusHandler.java
@@ -8,14 +8,14 @@
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.entity.projectile.Projectile;
 import net.minecraft.world.phys.Vec3;
-import net.minecraftforge.event.entity.EntityJoinLevelEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.EntityJoinLevelEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class ProjectileSpeedBonusHandler {
     public static final String IS_SPED_UP_TAG_NAME = "IS_SPED_UP";
 
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/RepairEfficiencyBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/RepairEfficiencyBonusHandler.java
index 11cdb5d2f..6e89ae599 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/RepairEfficiencyBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/RepairEfficiencyBonusHandler.java
@@ -5,14 +5,14 @@
 import daripher.skilltree.skill.bonus.player.RepairEfficiencyBonus;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.event.AnvilUpdateEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.AnvilUpdateEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class RepairEfficiencyBonusHandler {
     @SubscribeEvent(priority = EventPriority.HIGH)
     public static void applyRepairEfficiency(AnvilUpdateEvent event) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/SkillBonusHandlerUtils.java b/src/main/java/daripher/skilltree/skill/bonus/handler/SkillBonusHandlerUtils.java
index 8b0101807..50aeb89e4 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/SkillBonusHandlerUtils.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/SkillBonusHandlerUtils.java
@@ -11,20 +11,20 @@
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.Level;
-import net.minecraftforge.event.entity.living.LivingHurtEvent;
-import net.minecraftforge.eventbus.api.EventPriority;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent;
+import net.neoforged.bus.api.EventPriority;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.UUID;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class SkillBonusHandlerUtils {
     public static final String LAST_ATTACK_TARGET_TAG_NAME = "LastAttackTarget";
 
     @SubscribeEvent(priority = EventPriority.HIGH)
-    public static void setLastHurtEntity(LivingHurtEvent event) {
+    public static void setLastHurtEntity(LivingIncomingDamageEvent event) {
         Player attacker = null;
         if (event.getSource().getEntity() instanceof Player player) {
             attacker = player;
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/StealthBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/StealthBonusHandler.java
index fc41bd4f7..18e1a9cd1 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/StealthBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/StealthBonusHandler.java
@@ -5,13 +5,13 @@
 import daripher.skilltree.skill.bonus.player.StealthBonus;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.player.Player;
-import net.minecraftforge.event.entity.living.LivingEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.entity.living.LivingEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class StealthBonusHandler {
     @SubscribeEvent
     public static void applyVisibilityMultiplier(LivingEvent.LivingVisibilityEvent event) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/handler/TickingSkillBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/handler/TickingSkillBonusHandler.java
index 1d7f3ba25..4697abaf7 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/handler/TickingSkillBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/handler/TickingSkillBonusHandler.java
@@ -4,23 +4,20 @@
 import daripher.skilltree.skill.SkillBonusProvider;
 import daripher.skilltree.skill.bonus.TickingSkillBonus;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraftforge.event.TickEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.neoforged.neoforge.event.tick.PlayerTickEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 
 import java.util.List;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID)
 public class TickingSkillBonusHandler {
     @SubscribeEvent
-    public static void tickSkillBonuses(TickEvent.PlayerTickEvent event) {
-        if (event.player.isDeadOrDying()) {
+    public static void tickSkillBonuses(PlayerTickEvent.Post event) {
+        if (event.getEntity().isDeadOrDying()) {
             return;
         }
-        if (!(event.player instanceof ServerPlayer player)) {
-            return;
-        }
-        if (event.phase == TickEvent.Phase.END) {
+        if (!(event.getEntity() instanceof ServerPlayer player)) {
             return;
         }
         List<TickingSkillBonus> skillBonuses = SkillBonusProvider.getSkillBonuses(player, TickingSkillBonus.class);
diff --git a/src/main/java/daripher/skilltree/skill/bonus/item/EquipmentBonus.java b/src/main/java/daripher/skilltree/skill/bonus/item/EquipmentBonus.java
index fb58ef8c2..5b21404b6 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/item/EquipmentBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/item/EquipmentBonus.java
@@ -169,7 +169,7 @@ public void serialize(FriendlyByteBuf buf, ItemBonus<?> bonus) {
 
         @Override
         public ItemBonus<?> createDefaultInstance() {
-            return new EquipmentBonus(new OutgoingDamageBonus(0.1f, AttributeModifier.Operation.MULTIPLY_BASE));
+            return new EquipmentBonus(new OutgoingDamageBonus(0.1f, AttributeModifier.Operation.ADD_MULTIPLIED_BASE));
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/item/GroupedItemBonus.java b/src/main/java/daripher/skilltree/skill/bonus/item/GroupedItemBonus.java
index a3ed964e5..6542eb4e5 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/item/GroupedItemBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/item/GroupedItemBonus.java
@@ -3,6 +3,7 @@
 import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParseException;
+import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.client.tooltip.TooltipHelper;
 import daripher.skilltree.client.widget.editor.SkillTreeEditor;
 import daripher.skilltree.client.widget.editor.menu.EditorMenu;
@@ -263,9 +264,15 @@ public void serialize(FriendlyByteBuf buf, ItemBonus<?> bonus) {
 
         @Override
         public ItemBonus<?> createDefaultInstance() {
-            AttributeModifier defaultModifier = new AttributeModifier("Default Modifier", 1, AttributeModifier.Operation.ADDITION);
-            ItemBonus<?> bonus1 = new EquipmentBonus(new AttributeBonus(Attributes.ARMOR, defaultModifier));
-            ItemBonus<?> bonus2 = new EquipmentBonus(new AttributeBonus(Attributes.ARMOR_TOUGHNESS, defaultModifier));
+            AttributeModifier defaultModifier = new AttributeModifier(
+                    ResourceLocation.fromNamespaceAndPath(
+                            SkillTreeMod.MOD_ID, "default_modifier"),
+                    1,
+                    AttributeModifier.Operation.ADD_VALUE);
+            ItemBonus<?> bonus1 = new EquipmentBonus(
+                    new AttributeBonus(Attributes.ARMOR.value(), defaultModifier));
+            ItemBonus<?> bonus2 = new EquipmentBonus(
+                    new AttributeBonus(Attributes.ARMOR_TOUGHNESS.value(), defaultModifier));
             ArrayList<ItemBonus<?>> bonuses = new ArrayList<>();
             bonuses.add(bonus1);
             bonuses.add(bonus2);
diff --git a/src/main/java/daripher/skilltree/skill/bonus/item/ItemBonusHandler.java b/src/main/java/daripher/skilltree/skill/bonus/item/ItemBonusHandler.java
index ad466ad7f..386be3b81 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/item/ItemBonusHandler.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/item/ItemBonusHandler.java
@@ -14,14 +14,16 @@
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.network.chat.Style;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.core.component.DataComponents;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.ai.attributes.AttributeInstance;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.event.entity.living.LivingEquipmentChangeEvent;
-import net.minecraftforge.event.entity.player.ItemTooltipEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
+import net.minecraft.world.item.component.CustomData;
+import net.neoforged.neoforge.event.entity.living.LivingEquipmentChangeEvent;
+import net.neoforged.neoforge.event.entity.player.ItemTooltipEvent;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -30,7 +32,7 @@
 import java.util.Objects;
 import java.util.Optional;
 
-@Mod.EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE)
+@EventBusSubscriber(modid = SkillTreeMod.MOD_ID, bus = EventBusSubscriber.Bus.GAME)
 public class ItemBonusHandler {
     public static final String UPGRADE_BONUSES_TAG_NAME = "UpgradeBonuses";
     public static final String CRAFTING_BONUSES_TAG_NAME = "CraftingBonuses";
@@ -63,11 +65,11 @@ public static void addEquipmentAttributeBonuses(LivingEquipmentChangeEvent event
             if (!(bonus.getSkillBonus() instanceof AttributeBonus attributeBonus)) {
                 continue;
             }
-            AttributeInstance attributeInstance = entity.getAttribute(attributeBonus.getAttribute());
+            AttributeInstance attributeInstance = entity.getAttribute(attributeBonus.getAttributeHolder());
             if (attributeInstance == null) {
                 continue;
             }
-            attributeInstance.removeModifier(attributeBonus.getModifier().getId());
+            attributeInstance.removeModifier(attributeBonus.getModifier().id());
         }
         for (ItemBonus<?> itemBonus : getItemBonuses(event.getTo(), EquipmentBonus.class)) {
             EquipmentBonus bonus = (EquipmentBonus) itemBonus;
@@ -77,11 +79,11 @@ public static void addEquipmentAttributeBonuses(LivingEquipmentChangeEvent event
             if (attributeBonus.isDynamic()) {
                 continue;
             }
-            AttributeInstance attributeInstance = entity.getAttribute(attributeBonus.getAttribute());
+            AttributeInstance attributeInstance = entity.getAttribute(attributeBonus.getAttributeHolder());
             if (attributeInstance == null) {
                 continue;
             }
-            if (attributeInstance.hasModifier(attributeBonus.getModifier())) {
+            if (attributeInstance.hasModifier(attributeBonus.getModifier().id())) {
                 continue;
             }
             attributeInstance.addTransientModifier(attributeBonus.getModifier());
@@ -95,9 +97,6 @@ public static void addCraftingBonuses(ItemStack itemStack, GroupedItemBonus item
     }
 
     public static List<ItemBonus<?>> getItemBonuses(ItemStack itemStack) {
-        if (!itemStack.hasTag()) {
-            return ImmutableList.of();
-        }
         List<ItemBonus<?>> list = new ArrayList<>();
         list.addAll(getUpgradeBonuses(itemStack));
         list.addAll(getCraftingBonuses(itemStack));
@@ -113,7 +112,9 @@ private static List<ItemBonus<?>> getUpgradeBonuses(ItemStack itemStack) {
     }
 
     private static List<ItemBonus<?>> getBonusesFromTag(ItemStack itemStack, String subTagName) {
-        CompoundTag stackTag = itemStack.getOrCreateTag();
+        CustomData customData =
+                itemStack.getOrDefault(DataComponents.CUSTOM_DATA, CustomData.EMPTY);
+        CompoundTag stackTag = customData.copyTag();
         List<ItemBonus<?>> itemBonuses = new ArrayList<>();
         if (!stackTag.contains(subTagName, Tag.TAG_LIST)) {
             return new ArrayList<>();
@@ -161,7 +162,10 @@ private static void setTagBonuses(ItemStack stack, List<ItemBonus<?>> bonuses, S
         for (ItemBonus<?> itemBonus : bonuses) {
             bonusesTagList.add(serializeBonus(itemBonus));
         }
-        stack.getOrCreateTag().put(tagName, bonusesTagList);
+        CustomData.update(
+                DataComponents.CUSTOM_DATA,
+                stack,
+                tag -> tag.put(tagName, bonusesTagList));
     }
 
     private static CompoundTag serializeBonus(ItemBonus<? extends ItemBonus<?>> bonus) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/multiplier/FloatFunctionMultiplier.java b/src/main/java/daripher/skilltree/skill/bonus/multiplier/FloatFunctionMultiplier.java
index 75b176b48..f12f845b4 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/multiplier/FloatFunctionMultiplier.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/multiplier/FloatFunctionMultiplier.java
@@ -163,7 +163,8 @@ public void serialize(FriendlyByteBuf buf, LivingMultiplier multiplier) {
 
         @Override
         public LivingMultiplier createDefaultInstance() {
-            return new FloatFunctionMultiplier(new AttributeValueFunction(Attributes.MAX_HEALTH), 5f);
+            return new FloatFunctionMultiplier(
+                    new AttributeValueFunction(Attributes.MAX_HEALTH.value()), 5f);
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/AllAttributesBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/AllAttributesBonus.java
index e75f3b3a7..9994db7e7 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/AllAttributesBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/AllAttributesBonus.java
@@ -2,6 +2,7 @@
 
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParseException;
+import daripher.skilltree.SkillTreeMod;
 import daripher.skilltree.attribute.AttributesHelper;
 import daripher.skilltree.client.tooltip.TooltipHelper;
 import daripher.skilltree.client.widget.editor.SkillTreeEditor;
@@ -15,9 +16,12 @@
 import daripher.skilltree.skill.bonus.predicate.living.LivingEntityPredicate;
 import daripher.skilltree.skill.bonus.predicate.living.NoneLivingEntityPredicate;
 import net.minecraft.ChatFormatting;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.ai.attributes.AttributeInstance;
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
@@ -43,14 +47,22 @@ public void onSkillLearned(ServerPlayer player, boolean firstTime) {
         if (playerCondition != NoneLivingEntityPredicate.INSTANCE || playerMultiplier != NoneLivingMultiplier.INSTANCE) {
             return;
         }
-        AttributesHelper.playerAttributesList().stream().map(player::getAttribute).filter(Objects::nonNull).filter(a -> !a.hasModifier(modifier))
+        AttributesHelper.playerAttributesList().stream()
+                .map(BuiltInRegistries.ATTRIBUTE::wrapAsHolder)
+                .map(player::getAttribute)
+                .filter(Objects::nonNull)
+                .filter(a -> !a.hasModifier(modifier.id()))
                 .forEach(a -> applyAttributeModifier(a, modifier, player));
     }
 
     @Override
     public void onSkillRemoved(ServerPlayer player) {
-        AttributesHelper.playerAttributesList().stream().map(player::getAttribute).filter(Objects::nonNull).filter(a -> !a.hasModifier(modifier))
-                .forEach(a -> a.removeModifier(modifier.getId()));
+        AttributesHelper.playerAttributesList().stream()
+                .map(BuiltInRegistries.ATTRIBUTE::wrapAsHolder)
+                .map(player::getAttribute)
+                .filter(Objects::nonNull)
+                .filter(a -> a.hasModifier(modifier.id()))
+                .forEach(a -> a.removeModifier(modifier.id()));
     }
 
     @Override
@@ -72,19 +84,23 @@ public void tick(ServerPlayer player) {
     }
 
     private void applyDynamicAttributeBonus(ServerPlayer player) {
-        AttributesHelper.playerAttributesList().stream().map(player::getAttribute).filter(Objects::nonNull).forEach(playerAttribute -> {
-            AttributeModifier oldModifier = playerAttribute.getModifier(modifier.getId());
-            double value = modifier.getAmount();
+        AttributesHelper.playerAttributesList().stream()
+                .map(BuiltInRegistries.ATTRIBUTE::wrapAsHolder)
+                .map(player::getAttribute)
+                .filter(Objects::nonNull).forEach(playerAttribute -> {
+            AttributeModifier oldModifier = playerAttribute.getModifier(modifier.id());
+            double value = modifier.amount();
             value *= playerMultiplier.getValue(player);
             if (oldModifier != null) {
-                if (oldModifier.getAmount() == value) {
+                if (oldModifier.amount() == value) {
                     return;
                 }
-                playerAttribute.removeModifier(modifier.getId());
+                playerAttribute.removeModifier(modifier.id());
             }
-            AttributeModifier dynamicModifier = new AttributeModifier(modifier.getId(), "Dynamic", value, modifier.getOperation());
+            AttributeModifier dynamicModifier =
+                    new AttributeModifier(modifier.id(), value, modifier.operation());
             applyAttributeModifier(playerAttribute, dynamicModifier, player);
-            if (playerAttribute.getAttribute() == Attributes.MAX_HEALTH) {
+            if (playerAttribute.getAttribute().is(Attributes.MAX_HEALTH)) {
                 player.setHealth(player.getHealth());
             }
         });
@@ -93,7 +109,7 @@ private void applyDynamicAttributeBonus(ServerPlayer player) {
     private void applyAttributeModifier(AttributeInstance instance, AttributeModifier modifier, Player player) {
         float healthPercentage = player.getHealth() / player.getMaxHealth();
         instance.addTransientModifier(modifier);
-        if (AttributesHelper.playerAttributesList().contains(Attributes.MAX_HEALTH)) {
+        if (AttributesHelper.playerAttributesList().contains(Attributes.MAX_HEALTH.value())) {
             player.setHealth(player.getMaxHealth() * healthPercentage);
         }
     }
@@ -105,7 +121,11 @@ public SkillBonus.Serializer getSerializer() {
 
     @Override
     public AllAttributesBonus copy() {
-        AttributeModifier modifier = new AttributeModifier(UUID.randomUUID(), this.modifier.getName(), this.modifier.getAmount(), this.modifier.getOperation());
+        AttributeModifier modifier = new AttributeModifier(
+                ResourceLocation.fromNamespaceAndPath(
+                        SkillTreeMod.MOD_ID, "all_attributes_bonus/" + UUID.randomUUID()),
+                this.modifier.amount(),
+                this.modifier.operation());
         AllAttributesBonus bonus = new AllAttributesBonus(modifier);
         bonus.playerMultiplier = this.playerMultiplier;
         bonus.playerCondition = this.playerCondition;
@@ -114,7 +134,8 @@ public AllAttributesBonus copy() {
 
     @Override
     public AllAttributesBonus multiply(double multiplier) {
-        modifier = new AttributeModifier(modifier.getId(), modifier.getName(), modifier.getAmount() * multiplier, modifier.getOperation());
+        modifier = new AttributeModifier(
+                modifier.id(), modifier.amount() * multiplier, modifier.operation());
         return this;
     }
 
@@ -129,7 +150,7 @@ public boolean canMerge(SkillBonus<?> other) {
         if (!Objects.equals(otherBonus.playerCondition, this.playerCondition)) {
             return false;
         }
-        return otherBonus.modifier.getOperation() == this.modifier.getOperation();
+        return otherBonus.modifier.operation() == this.modifier.operation();
     }
 
     @Override
@@ -137,7 +158,10 @@ public SkillBonus<AllAttributesBonus> merge(SkillBonus<?> other) {
         if (!(other instanceof AllAttributesBonus otherBonus)) {
             throw new IllegalArgumentException();
         }
-        AttributeModifier mergedModifier = new AttributeModifier(this.modifier.getId(), "Merged", this.modifier.getAmount() + otherBonus.modifier.getAmount(), this.modifier.getOperation());
+        AttributeModifier mergedModifier = new AttributeModifier(
+                this.modifier.id(),
+                this.modifier.amount() + otherBonus.modifier.amount(),
+                this.modifier.operation());
         AllAttributesBonus mergedBonus = new AllAttributesBonus(mergedModifier);
         mergedBonus.playerMultiplier = this.playerMultiplier;
         mergedBonus.playerCondition = this.playerCondition;
@@ -146,7 +170,7 @@ public SkillBonus<AllAttributesBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), modifier.getAmount(), modifier.getOperation());
+        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), modifier.amount(), modifier.operation());
         tooltip = playerMultiplier.getTooltip(tooltip, Target.PLAYER);
         tooltip = playerCondition.getTooltip(tooltip, Target.PLAYER);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
@@ -154,7 +178,7 @@ public MutableComponent getSimpleTooltip() {
 
     @Override
     public boolean isPositive() {
-        return modifier.getAmount() > 0;
+        return modifier.amount() > 0;
     }
 
     @Override
@@ -162,8 +186,8 @@ public void addEditorWidgets(SkillTreeEditor editor, Consumer<AllAttributesBonus
         editor.addLabel(110, 0, "Amount", ChatFormatting.GOLD);
         editor.addLabel(0, 0, "Operation", ChatFormatting.GOLD);
         editor.increaseHeight(19);
-        editor.addNumericTextField(110, 0, 50, 14, modifier.getAmount()).setNumericResponder(value -> selectAmount(consumer, value));
-        editor.addOperationSelection(0, 0, 80, modifier.getOperation()).setResponder(operation -> selectOperation(consumer, operation));
+        editor.addNumericTextField(110, 0, 50, 14, modifier.amount()).setNumericResponder(value -> selectAmount(consumer, value));
+        editor.addOperationSelection(0, 0, 80, modifier.operation()).setResponder(operation -> selectOperation(consumer, operation));
         editor.increaseHeight(29);
         editor.addLabel(0, 0, "Player Condition", ChatFormatting.GOLD);
         editor.increaseHeight(19);
@@ -215,11 +239,11 @@ private void addPlayerConditionWidgets(SkillTreeEditor editor, Consumer<AllAttri
     }
 
     public void setAmount(double amount) {
-        this.modifier = new AttributeModifier(modifier.getId(), modifier.getName(), amount, modifier.getOperation());
+        this.modifier = new AttributeModifier(modifier.id(), amount, modifier.operation());
     }
 
     public void setOperation(AttributeModifier.Operation operation) {
-        this.modifier = new AttributeModifier(modifier.getId(), modifier.getName(), modifier.getAmount(), operation);
+        this.modifier = new AttributeModifier(modifier.id(), modifier.amount(), operation);
     }
 
     public SkillBonus<?> setCondition(LivingEntityPredicate condition) {
@@ -294,7 +318,13 @@ public void serialize(FriendlyByteBuf buf, SkillBonus<?> bonus) {
 
         @Override
         public SkillBonus<?> createDefaultInstance() {
-            return new AllAttributesBonus(new AttributeModifier(UUID.randomUUID(), "Skill", 0.05, AttributeModifier.Operation.MULTIPLY_BASE));
+            return new AllAttributesBonus(
+                    new AttributeModifier(
+                            ResourceLocation.fromNamespaceAndPath(
+                                    SkillTreeMod.MOD_ID,
+                                    "all_attributes_bonus/" + UUID.randomUUID()),
+                            0.05,
+                            AttributeModifier.Operation.ADD_MULTIPLIED_BASE));
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/ArrowRetrievalBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/ArrowRetrievalBonus.java
index 81d6723cd..3a58170b5 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/ArrowRetrievalBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/ArrowRetrievalBonus.java
@@ -53,7 +53,7 @@ public SkillBonus<ArrowRetrievalBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        return TooltipHelper.getSkillBonusTooltip(getDescriptionId(), chance, AttributeModifier.Operation.MULTIPLY_BASE)
+        return TooltipHelper.getSkillBonusTooltip(getDescriptionId(), chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE)
                 .withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
     }
 
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/AttributeBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/AttributeBonus.java
index ed3fc0a64..01adf5226 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/AttributeBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/AttributeBonus.java
@@ -17,10 +17,13 @@
 import daripher.skilltree.skill.bonus.predicate.living.LivingEntityPredicate;
 import daripher.skilltree.skill.bonus.predicate.living.NoneLivingEntityPredicate;
 import net.minecraft.ChatFormatting;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.ai.attributes.Attribute;
 import net.minecraft.world.entity.ai.attributes.AttributeInstance;
@@ -49,24 +52,24 @@ public void onSkillLearned(ServerPlayer player, boolean firstTime) {
         if (playerCondition != NoneLivingEntityPredicate.INSTANCE || playerMultiplier != NoneLivingMultiplier.INSTANCE) {
             return;
         }
-        AttributeInstance instance = player.getAttribute(attribute);
+        AttributeInstance instance = player.getAttribute(getAttributeHolder());
         if (instance == null) {
             SkillTreeMod.LOGGER.error("Attempting to add attribute modifier to attribute {}, which is not present for player", attribute);
             return;
         }
-        if (!instance.hasModifier(modifier)) {
+        if (!instance.hasModifier(modifier.id())) {
             applyAttributeModifier(instance, modifier, player);
         }
     }
 
     @Override
     public void onSkillRemoved(ServerPlayer player) {
-        AttributeInstance instance = player.getAttribute(attribute);
+        AttributeInstance instance = player.getAttribute(getAttributeHolder());
         if (instance == null) {
             SkillTreeMod.LOGGER.error("Attempting to remove attribute modifier from attribute {}, which is not present for player", attribute);
             return;
         }
-        instance.removeModifier(modifier.getId());
+        instance.removeModifier(modifier.id());
     }
 
     @Override
@@ -92,29 +95,30 @@ public boolean isDynamic() {
     }
 
     private void applyDynamicAttributeBonus(ServerPlayer player) {
-        AttributeInstance instance = player.getAttribute(attribute);
+        AttributeInstance instance = player.getAttribute(getAttributeHolder());
         if (instance == null) {
             return;
         }
-        AttributeModifier oldModifier = instance.getModifier(modifier.getId());
-        double value = modifier.getAmount();
+        AttributeModifier oldModifier = instance.getModifier(modifier.id());
+        double value = modifier.amount();
         value *= playerMultiplier.getValue(player);
         if (oldModifier != null) {
-            if (oldModifier.getAmount() == value) {
+            if (oldModifier.amount() == value) {
                 return;
             }
         }
-        AttributeModifier dynamicModifier = new AttributeModifier(modifier.getId(), "DynamicBonus", value, modifier.getOperation());
+        AttributeModifier dynamicModifier =
+                new AttributeModifier(modifier.id(), value, modifier.operation());
         applyAttributeModifier(instance, dynamicModifier, player);
     }
 
     private void applyAttributeModifier(AttributeInstance instance, AttributeModifier modifier, Player player) {
         float healthPercentage = player.getHealth() / player.getMaxHealth();
-        if (instance.getModifier(modifier.getId()) != null) {
-            instance.removeModifier(modifier.getId());
+        if (instance.getModifier(modifier.id()) != null) {
+            instance.removeModifier(modifier.id());
         }
         instance.addTransientModifier(modifier);
-        if (attribute == Attributes.MAX_HEALTH) {
+        if (attribute == Attributes.MAX_HEALTH.value()) {
             player.setHealth(player.getMaxHealth() * healthPercentage);
         }
     }
@@ -126,7 +130,11 @@ public SkillBonus.Serializer getSerializer() {
 
     @Override
     public AttributeBonus copy() {
-        AttributeModifier modifier = new AttributeModifier(UUID.randomUUID(), this.modifier.getName(), this.modifier.getAmount(), this.modifier.getOperation());
+        AttributeModifier modifier = new AttributeModifier(
+                ResourceLocation.fromNamespaceAndPath(
+                        SkillTreeMod.MOD_ID, "attribute_bonus/" + UUID.randomUUID()),
+                this.modifier.amount(),
+                this.modifier.operation());
         AttributeBonus bonus = new AttributeBonus(attribute, modifier);
         bonus.playerMultiplier = this.playerMultiplier;
         bonus.playerCondition = this.playerCondition;
@@ -135,7 +143,8 @@ public AttributeBonus copy() {
 
     @Override
     public AttributeBonus multiply(double multiplier) {
-        modifier = new AttributeModifier(modifier.getId(), modifier.getName(), modifier.getAmount() * multiplier, modifier.getOperation());
+        modifier = new AttributeModifier(
+                modifier.id(), modifier.amount() * multiplier, modifier.operation());
         return this;
     }
 
@@ -153,7 +162,7 @@ public boolean canMerge(SkillBonus<?> other) {
         if (!Objects.equals(otherBonus.playerCondition, this.playerCondition)) {
             return false;
         }
-        return otherBonus.modifier.getOperation() == this.modifier.getOperation();
+        return otherBonus.modifier.operation() == this.modifier.operation();
     }
 
     @Override
@@ -161,7 +170,10 @@ public SkillBonus<AttributeBonus> merge(SkillBonus<?> other) {
         if (!(other instanceof AttributeBonus otherBonus)) {
             throw new IllegalArgumentException();
         }
-        AttributeModifier mergedModifier = new AttributeModifier(this.modifier.getId(), "Merged", this.modifier.getAmount() + otherBonus.modifier.getAmount(), this.modifier.getOperation());
+        AttributeModifier mergedModifier = new AttributeModifier(
+                this.modifier.id(),
+                this.modifier.amount() + otherBonus.modifier.amount(),
+                this.modifier.operation());
         AttributeBonus mergedBonus = new AttributeBonus(this.attribute, mergedModifier);
         mergedBonus.playerMultiplier = this.playerMultiplier;
         mergedBonus.playerCondition = this.playerCondition;
@@ -170,7 +182,7 @@ public SkillBonus<AttributeBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        float visibleAmount = (float) modifier.getAmount();
+        float visibleAmount = (float) modifier.amount();
         String descriptionId = attribute.getDescriptionId();
         MutableComponent tooltip;
         if (isPercentageRegeneration()) {
@@ -182,7 +194,7 @@ public MutableComponent getSimpleTooltip() {
             if (isKnockbackResistanceAddition()) {
                 visibleAmount *= 10;
             }
-            AttributeModifier.Operation operation = modifier.getOperation();
+            AttributeModifier.Operation operation = modifier.operation();
             tooltip = TooltipHelper.getSkillBonusTooltip(descriptionId, visibleAmount, operation);
             tooltip = playerMultiplier.getTooltip(tooltip, Target.PLAYER);
         }
@@ -191,11 +203,17 @@ public MutableComponent getSimpleTooltip() {
     }
 
     private boolean isKnockbackResistanceAddition() {
-        return modifier.getOperation() == AttributeModifier.Operation.ADDITION && attribute.equals(Attributes.KNOCKBACK_RESISTANCE);
+        return modifier.operation() == AttributeModifier.Operation.ADD_VALUE
+                && attribute.equals(Attributes.KNOCKBACK_RESISTANCE.value());
     }
 
     private boolean isPercentageRegeneration() {
-        return modifier.getOperation() == AttributeModifier.Operation.ADDITION && playerMultiplier instanceof FloatFunctionMultiplier floatFunctionMultiplier && floatFunctionMultiplier.getFloatFunction() instanceof AttributeValueFunction attributeValueFunction && attributeValueFunction.getAttribute() == Attributes.MAX_HEALTH && floatFunctionMultiplier.getDivisor() == 1;
+        return modifier.operation() == AttributeModifier.Operation.ADD_VALUE
+                && playerMultiplier instanceof FloatFunctionMultiplier floatFunctionMultiplier
+                && floatFunctionMultiplier.getFloatFunction()
+                        instanceof AttributeValueFunction attributeValueFunction
+                && attributeValueFunction.getAttribute() == Attributes.MAX_HEALTH.value()
+                && floatFunctionMultiplier.getDivisor() == 1;
     }
 
     @Override
@@ -206,7 +224,7 @@ public void gatherInfo(Consumer<MutableComponent> consumer) {
 
     @Override
     public boolean isPositive() {
-        return modifier.getAmount() > 0;
+        return modifier.amount() > 0;
     }
 
     @Override
@@ -218,8 +236,8 @@ public void addEditorWidgets(SkillTreeEditor editor, Consumer<AttributeBonus> co
         editor.addLabel(110, 0, "Amount", ChatFormatting.GOLD);
         editor.addLabel(0, 0, "Operation", ChatFormatting.GOLD);
         editor.increaseHeight(19);
-        editor.addNumericTextField(110, 0, 50, 14, modifier.getAmount()).setNumericResponder(value -> selectAmount(consumer, value));
-        editor.addOperationSelection(0, 0, 80, modifier.getOperation()).setResponder(operation -> selectOperation(consumer, operation));
+        editor.addNumericTextField(110, 0, 50, 14, modifier.amount()).setNumericResponder(value -> selectAmount(consumer, value));
+        editor.addOperationSelection(0, 0, 80, modifier.operation()).setResponder(operation -> selectOperation(consumer, operation));
         editor.increaseHeight(29);
         editor.addLabel(0, 0, "Player Condition", ChatFormatting.GOLD);
         editor.increaseHeight(19);
@@ -279,6 +297,10 @@ public Attribute getAttribute() {
         return attribute;
     }
 
+    public Holder<Attribute> getAttributeHolder() {
+        return BuiltInRegistries.ATTRIBUTE.wrapAsHolder(attribute);
+    }
+
     public AttributeModifier getModifier() {
         return modifier;
     }
@@ -288,11 +310,11 @@ public void setAttribute(Attribute attribute) {
     }
 
     public void setAmount(double amount) {
-        this.modifier = new AttributeModifier(modifier.getId(), modifier.getName(), amount, modifier.getOperation());
+        this.modifier = new AttributeModifier(modifier.id(), amount, modifier.operation());
     }
 
     public void setOperation(AttributeModifier.Operation operation) {
-        this.modifier = new AttributeModifier(modifier.getId(), modifier.getName(), modifier.getAmount(), operation);
+        this.modifier = new AttributeModifier(modifier.id(), modifier.amount(), operation);
     }
 
     public SkillBonus<?> setCondition(LivingEntityPredicate condition) {
@@ -373,7 +395,14 @@ public void serialize(FriendlyByteBuf buf, SkillBonus<?> bonus) {
 
         @Override
         public SkillBonus<?> createDefaultInstance() {
-            return new AttributeBonus(Attributes.ARMOR, new AttributeModifier(UUID.randomUUID(), "Skill", 1, AttributeModifier.Operation.ADDITION));
+            return new AttributeBonus(
+                    Attributes.ARMOR.value(),
+                    new AttributeModifier(
+                            ResourceLocation.fromNamespaceAndPath(
+                                    SkillTreeMod.MOD_ID,
+                                    "attribute_bonus/" + UUID.randomUUID()),
+                            1,
+                            AttributeModifier.Operation.ADD_VALUE));
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/BlockBreakSpeedBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/BlockBreakSpeedBonus.java
index 255224038..eaddc620a 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/BlockBreakSpeedBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/BlockBreakSpeedBonus.java
@@ -77,7 +77,7 @@ public SkillBonus<BlockBreakSpeedBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        MutableComponent bonusTooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), multiplier, AttributeModifier.Operation.MULTIPLY_BASE);
+        MutableComponent bonusTooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), multiplier, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         bonusTooltip = playerCondition.getTooltip(bonusTooltip, Target.PLAYER);
         bonusTooltip = playerMultiplier.getTooltip(bonusTooltip, Target.PLAYER);
         return bonusTooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/CritChanceBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/CritChanceBonus.java
index b9c8f7bfa..8ee86a6af 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/CritChanceBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/CritChanceBonus.java
@@ -111,7 +111,7 @@ public SkillBonus<CritChanceBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        AttributeModifier.Operation operation = AttributeModifier.Operation.MULTIPLY_BASE;
+        AttributeModifier.Operation operation = AttributeModifier.Operation.ADD_MULTIPLIED_BASE;
         MutableComponent tooltip;
         if (damageCondition == NoneDamageCondition.INSTANCE) {
             tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), chance, operation);
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/CritDamageBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/CritDamageBonus.java
index 64d06b917..94b34638e 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/CritDamageBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/CritDamageBonus.java
@@ -111,7 +111,7 @@ public SkillBonus<CritDamageBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        AttributeModifier.Operation operation = AttributeModifier.Operation.MULTIPLY_BASE;
+        AttributeModifier.Operation operation = AttributeModifier.Operation.ADD_MULTIPLIED_BASE;
         MutableComponent tooltip;
         if (damageCondition == NoneDamageCondition.INSTANCE) {
             tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), amount, operation);
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/DamageAvoidanceChanceBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/DamageAvoidanceChanceBonus.java
index 4c72635d7..231633ed8 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/DamageAvoidanceChanceBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/DamageAvoidanceChanceBonus.java
@@ -121,7 +121,7 @@ public SkillBonus<DamageAvoidanceChanceBonus> merge(SkillBonus<?> other) {
     @Override
     public MutableComponent getSimpleTooltip() {
         MutableComponent tooltip = Component.translatable(getDescriptionId(), damageCondition.getTooltip());
-        tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+        tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         tooltip = playerMultiplier.getTooltip(tooltip, Target.PLAYER);
         tooltip = attackerMultiplier.getTooltip(tooltip, Target.ENEMY);
         tooltip = playerCondition.getTooltip(tooltip, Target.PLAYER);
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/EffectDurationBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/EffectDurationBonus.java
index 1d35d3bbf..9b14ae5d1 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/EffectDurationBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/EffectDurationBonus.java
@@ -126,7 +126,7 @@ public MutableComponent getSimpleTooltip() {
         Component effectTypeDescription = effectPredicate.getTooltip("plural");
         String key = getDescriptionId() + "." + target.getName();
         MutableComponent tooltip = Component.translatable(key, effectTypeDescription);
-        tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, duration, AttributeModifier.Operation.MULTIPLY_BASE);
+        tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, duration, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         tooltip = playerMultiplier.getTooltip(tooltip, target);
         tooltip = playerCondition.getTooltip(tooltip, target);
         tooltip = enemyMultiplier.getTooltip(tooltip, target);
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/EffectImmunityBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/EffectImmunityBonus.java
index 462f81bb5..bd67e0e12 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/EffectImmunityBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/EffectImmunityBonus.java
@@ -186,7 +186,8 @@ private EffectImmunityBonus validateBonus(SkillBonus<?> bonus) {
 
         @Override
         public SkillBonus<?> createDefaultInstance() {
-            return new EffectImmunityBonus(new MobEffectIdPredicate(MobEffects.POISON));
+            return new EffectImmunityBonus(
+                    new MobEffectIdPredicate(MobEffects.POISON.value()));
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/EffectImmunityBypassBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/EffectImmunityBypassBonus.java
index f8df17c60..ff74481f4 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/EffectImmunityBypassBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/EffectImmunityBypassBonus.java
@@ -222,7 +222,8 @@ private EffectImmunityBypassBonus validateBonus(SkillBonus<?> bonus) {
 
         @Override
         public SkillBonus<?> createDefaultInstance() {
-            return new EffectImmunityBypassBonus(new MobEffectIdPredicate(MobEffects.POISON));
+            return new EffectImmunityBypassBonus(
+                    new MobEffectIdPredicate(MobEffects.POISON.value()));
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/EnchantingExperienceRefundBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/EnchantingExperienceRefundBonus.java
index 5672755b7..64826be77 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/EnchantingExperienceRefundBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/EnchantingExperienceRefundBonus.java
@@ -99,7 +99,7 @@ public MutableComponent getSimpleTooltip() {
         MutableComponent tooltip;
         if (chance < 1f) {
             tooltip = Component.translatable(getDescriptionId() + ".chance", itemStackPredicate.getTooltip());
-            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         } else {
             tooltip = Component.translatable(getDescriptionId(), itemStackPredicate.getTooltip("plural"));
         }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/ExperienceGainMultiplierBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/ExperienceGainMultiplierBonus.java
index be2ebb3cf..4a062ffc9 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/ExperienceGainMultiplierBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/ExperienceGainMultiplierBonus.java
@@ -76,7 +76,7 @@ public SkillBonus<ExperienceGainMultiplierBonus> merge(SkillBonus<?> other) {
     public MutableComponent getSimpleTooltip() {
         Component sourceDescription = Component.translatable(experienceSource.getDescriptionId());
         MutableComponent tooltip = Component.translatable(getDescriptionId(), sourceDescription);
-        tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, multiplier, AttributeModifier.Operation.MULTIPLY_BASE);
+        tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, multiplier, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         tooltip = playerMultiplier.getTooltip(tooltip, Target.PLAYER);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
     }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/GrantExperienceBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/GrantExperienceBonus.java
index 30854487a..62f24a992 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/GrantExperienceBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/GrantExperienceBonus.java
@@ -99,7 +99,7 @@ public MutableComponent getSimpleTooltip() {
         }
         MutableComponent tooltip = Component.translatable(bonusDescription, amount);
         if (chance < 1) {
-            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         }
         tooltip = eventListener.getTooltip(tooltip);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/GrantItemBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/GrantItemBonus.java
index c3750cf94..a3efa0e23 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/GrantItemBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/GrantItemBonus.java
@@ -20,7 +20,7 @@
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
-import net.minecraftforge.registries.ForgeRegistries;
+import daripher.skilltree.util.ForgeRegistries;
 
 import java.util.List;
 import java.util.Map;
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/HealthReservationBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/HealthReservationBonus.java
index de6314712..0d1a0d20a 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/HealthReservationBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/HealthReservationBonus.java
@@ -82,7 +82,7 @@ public SkillBonus<HealthReservationBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), amount, AttributeModifier.Operation.MULTIPLY_BASE);
+        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), amount, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         tooltip = playerMultiplier.getTooltip(tooltip, Target.PLAYER);
         tooltip = playerCondition.getTooltip(tooltip, Target.PLAYER);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/IncomingDamageBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/IncomingDamageBonus.java
index 9ee42f949..84c39602a 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/IncomingDamageBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/IncomingDamageBonus.java
@@ -339,7 +339,7 @@ public CompoundTag serialize(SkillBonus<?> bonus) {
         @Override
         public IncomingDamageBonus deserialize(FriendlyByteBuf buf) {
             float amount = buf.readFloat();
-            AttributeModifier.Operation operation = AttributeModifier.Operation.fromValue(buf.readInt());
+            AttributeModifier.Operation operation = AttributeModifier.Operation.BY_ID.apply(buf.readInt());
             IncomingDamageBonus bonus = new IncomingDamageBonus(amount, operation);
             bonus.playerMultiplier = NetworkHelper.readLivingMultiplier(buf);
             bonus.attackerMultiplier = NetworkHelper.readLivingMultiplier(buf);
@@ -355,7 +355,7 @@ public void serialize(FriendlyByteBuf buf, SkillBonus<?> bonus) {
                 throw new IllegalArgumentException();
             }
             buf.writeFloat(aBonus.amount);
-            buf.writeInt(aBonus.operation.toValue());
+            buf.writeInt(aBonus.operation.id());
             NetworkHelper.writeLivingMultiplier(buf, aBonus.playerMultiplier);
             NetworkHelper.writeLivingMultiplier(buf, aBonus.attackerMultiplier);
             NetworkHelper.writeLivingCondition(buf, aBonus.playerCondition);
@@ -365,7 +365,7 @@ public void serialize(FriendlyByteBuf buf, SkillBonus<?> bonus) {
 
         @Override
         public SkillBonus<?> createDefaultInstance() {
-            return new IncomingDamageBonus(0.1f, AttributeModifier.Operation.MULTIPLY_BASE).setDamageCondition(new MeleeDamageCondition());
+            return new IncomingDamageBonus(0.1f, AttributeModifier.Operation.ADD_MULTIPLIED_BASE).setDamageCondition(new MeleeDamageCondition());
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/IncomingHealingBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/IncomingHealingBonus.java
index 5996c437b..54e73c2b0 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/IncomingHealingBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/IncomingHealingBonus.java
@@ -85,7 +85,7 @@ public SkillBonus<IncomingHealingBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), multiplier, AttributeModifier.Operation.MULTIPLY_BASE);
+        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), multiplier, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         tooltip = playerMultiplier.getTooltip(tooltip, Target.PLAYER);
         tooltip = playerCondition.getTooltip(tooltip, Target.PLAYER);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/InflictDamageBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/InflictDamageBonus.java
index dd95f523e..b7114d250 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/InflictDamageBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/InflictDamageBonus.java
@@ -106,7 +106,7 @@ public MutableComponent getSimpleTooltip() {
         }
         MutableComponent tooltip = Component.translatable(key, damageDescription, damageTypeDescription);
         if (chance < 1) {
-            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         }
         tooltip = eventListener.getTooltip(tooltip);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/InflictIgniteBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/InflictIgniteBonus.java
index 6c928c191..39b3ed6a5 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/InflictIgniteBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/InflictIgniteBonus.java
@@ -43,7 +43,7 @@ public InflictIgniteBonus(float chance, int duration) {
     @Override
     public void applyEffect(LivingEntity target, @Nullable LivingEntity source) {
         if (target.getRandom().nextFloat() < chance) {
-            target.setSecondsOnFire(duration);
+            target.igniteForSeconds(duration);
         }
     }
 
@@ -84,7 +84,7 @@ public SkillBonus<EventListenerBonus<InflictIgniteBonus>> merge(SkillBonus<?> ot
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        String durationDescription = StringUtil.formatTickDuration(duration * 20);
+        String durationDescription = StringUtil.formatTickDuration(duration * 20, 20f);
         String targetDescription = eventListener.getTarget().name().toLowerCase(Locale.ROOT);
         String bonusDescription = getDescriptionId() + "." + targetDescription;
         if (chance < 1) {
@@ -92,7 +92,7 @@ public MutableComponent getSimpleTooltip() {
         }
         MutableComponent tooltip = Component.translatable(bonusDescription, durationDescription);
         if (chance < 1) {
-            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         }
         tooltip = eventListener.getTooltip(tooltip);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/InflictMobEffectBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/InflictMobEffectBonus.java
index 30374568e..b24bf41ad 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/InflictMobEffectBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/InflictMobEffectBonus.java
@@ -13,6 +13,8 @@
 import daripher.skilltree.skill.bonus.event.SkillEventListener;
 import daripher.skilltree.skill.bonus.event.TickingEventListener;
 import net.minecraft.ChatFormatting;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
@@ -53,14 +55,17 @@ public void applyEffect(LivingEntity target, @Nullable LivingEntity source) {
             return;
         }
         MobEffectInstance effectInstanceCopy = new MobEffectInstance(effectInstance);
-        MobEffect effect = effectInstance.getEffect();
+        Holder<MobEffect> effect = effectInstance.getEffect();
         if (maxStacks > 1) {
             effectInstanceCopy = getEffectInstanceAfterStacking(target, effect, effectInstanceCopy);
         }
         target.addEffect(effectInstanceCopy, source);
     }
 
-    private MobEffectInstance getEffectInstanceAfterStacking(LivingEntity target, MobEffect effect, MobEffectInstance effectInstance) {
+    private MobEffectInstance getEffectInstanceAfterStacking(
+            LivingEntity target,
+            Holder<MobEffect> effect,
+            MobEffectInstance effectInstance) {
         MobEffectInstance activeEffectInstance = target.getEffect(effect);
         if (activeEffectInstance == null) {
             return effectInstance;
@@ -147,7 +152,7 @@ public MutableComponent getSimpleTooltip() {
             tooltip = Component.translatable(bonusDescription, effectDescription, "");
         }
         if (chance < 1) {
-            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         }
         tooltip = eventListener.getTooltip(tooltip);
         if (maxStacks > 1) {
@@ -171,8 +176,8 @@ public void gatherInfo(Consumer<MutableComponent> consumer) {
 
     @Override
     public boolean isPositive() {
-        return chance > 0 ^ eventListener.getTarget() == Target.PLAYER ^ effectInstance.getEffect()
-                .getCategory() != MobEffectCategory.HARMFUL;
+        return chance > 0 ^ eventListener.getTarget() == Target.PLAYER
+                ^ effectInstance.getEffect().value().getCategory() != MobEffectCategory.HARMFUL;
     }
 
     @Override
@@ -185,7 +190,8 @@ public void addEditorWidgets(SkillTreeEditor editor, Consumer<EventListenerBonus
         editor.addLabel(0, 0, "Effect", ChatFormatting.GOLD);
         editor.addLabel(150, 0, "Chance", ChatFormatting.GOLD);
         editor.increaseHeight(19);
-        editor.addSelectionMenu(0, 0, 145, effectInstance.getEffect()).setResponder(effect -> selectEffect(consumer, effect));
+        editor.addSelectionMenu(0, 0, 145, effectInstance.getEffect().value())
+                .setResponder(effect -> selectEffect(consumer, effect));
         editor.addNumericTextField(150, 0, 50, 14, chance).setNumericResponder(value -> selectChance(consumer, value));
         editor.increaseHeight(19);
         editor.addLabel(0, 0, "Duration", ChatFormatting.GOLD);
@@ -250,7 +256,10 @@ public void setChance(float chance) {
     }
 
     public void setEffectInstance(MobEffect effectInstance) {
-        this.effectInstance = new MobEffectInstance(effectInstance, this.effectInstance.getDuration(), this.effectInstance.getAmplifier());
+        this.effectInstance = new MobEffectInstance(
+                BuiltInRegistries.MOB_EFFECT.wrapAsHolder(effectInstance),
+                this.effectInstance.getDuration(),
+                this.effectInstance.getAmplifier());
     }
 
     public void setDuration(int duration) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/ItemDurabilityLossPreventionBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/ItemDurabilityLossPreventionBonus.java
index 4d84064ef..bce08928d 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/ItemDurabilityLossPreventionBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/ItemDurabilityLossPreventionBonus.java
@@ -99,7 +99,7 @@ public MutableComponent getSimpleTooltip() {
         MutableComponent tooltip;
         if (chance < 1f) {
             tooltip = Component.translatable(getDescriptionId() + ".chance", itemStackPredicate.getTooltip());
-            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         } else {
             tooltip = Component.translatable(getDescriptionId(), itemStackPredicate.getTooltip());
         }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/JumpHeightBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/JumpHeightBonus.java
index 8205cf2e2..892609381 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/JumpHeightBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/JumpHeightBonus.java
@@ -75,7 +75,7 @@ public SkillBonus<JumpHeightBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), multiplier, AttributeModifier.Operation.MULTIPLY_BASE);
+        MutableComponent tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), multiplier, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         tooltip = playerCondition.getTooltip(tooltip, Target.PLAYER);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
     }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/LootAmountModifierBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/LootAmountModifierBonus.java
index ab15b4a07..dafb95b21 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/LootAmountModifierBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/LootAmountModifierBonus.java
@@ -18,6 +18,7 @@
 import net.minecraft.world.entity.ai.attributes.AttributeModifier;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.component.ItemAttributeModifiers;
 import net.minecraft.world.level.storage.loot.LootContext;
 import net.minecraft.world.level.storage.loot.parameters.LootContextParam;
 import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
@@ -84,13 +85,14 @@ public MutableComponent getSimpleTooltip() {
         } else if (multiplier == -1) {
             multiplierDescription = Component.translatable(descriptionId + ".none");
         } else {
-            String formattedMultiplier = ItemStack.ATTRIBUTE_MODIFIER_FORMAT.format(multiplier * 100);
+            String formattedMultiplier =
+                    ItemAttributeModifiers.ATTRIBUTE_MODIFIER_FORMAT.format(multiplier * 100);
             multiplierDescription = Component.translatable(descriptionId + ".multiplier", formattedMultiplier);
         }
         MutableComponent bonusDescription;
         if (chance < 1) {
             bonusDescription = Component.translatable(descriptionId, multiplierDescription, lootDescription);
-            bonusDescription = TooltipHelper.getSkillBonusTooltip(bonusDescription, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            bonusDescription = TooltipHelper.getSkillBonusTooltip(bonusDescription, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         } else {
             descriptionId += ".guaranteed";
             if (multiplier == -1) {
@@ -209,7 +211,7 @@ public boolean canAffect(LootContext lootContext) {
 
         public LootContextParam<Entity> getPlayerLootContextParam() {
             return switch (this) {
-                case MOBS, FISHING -> LootContextParams.KILLER_ENTITY;
+                case MOBS, FISHING -> LootContextParams.ATTACKING_ENTITY;
                 case GEMS, CHESTS, ORE, ARCHAEOLOGY -> LootContextParams.THIS_ENTITY;
             };
         }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/OutgoingDamageBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/OutgoingDamageBonus.java
index f15f1c9ab..65d94e9b9 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/OutgoingDamageBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/OutgoingDamageBonus.java
@@ -329,7 +329,7 @@ public CompoundTag serialize(SkillBonus<?> bonus) {
         @Override
         public OutgoingDamageBonus deserialize(FriendlyByteBuf buf) {
             float amount = buf.readFloat();
-            AttributeModifier.Operation operation = AttributeModifier.Operation.fromValue(buf.readInt());
+            AttributeModifier.Operation operation = AttributeModifier.Operation.BY_ID.apply(buf.readInt());
             OutgoingDamageBonus bonus = new OutgoingDamageBonus(amount, operation);
             bonus.playerMultiplier = NetworkHelper.readLivingMultiplier(buf);
             bonus.targetMultiplier = NetworkHelper.readLivingMultiplier(buf);
@@ -345,7 +345,7 @@ public void serialize(FriendlyByteBuf buf, SkillBonus<?> bonus) {
                 throw new IllegalArgumentException();
             }
             buf.writeFloat(aBonus.amount);
-            buf.writeInt(aBonus.operation.toValue());
+            buf.writeInt(aBonus.operation.id());
             NetworkHelper.writeLivingMultiplier(buf, aBonus.playerMultiplier);
             NetworkHelper.writeLivingMultiplier(buf, aBonus.targetMultiplier);
             NetworkHelper.writeLivingCondition(buf, aBonus.playerCondition);
@@ -355,7 +355,7 @@ public void serialize(FriendlyByteBuf buf, SkillBonus<?> bonus) {
 
         @Override
         public SkillBonus<?> createDefaultInstance() {
-            return new OutgoingDamageBonus(0.1f, AttributeModifier.Operation.MULTIPLY_BASE).setDamageCondition(new MeleeDamageCondition());
+            return new OutgoingDamageBonus(0.1f, AttributeModifier.Operation.ADD_MULTIPLIED_BASE).setDamageCondition(new MeleeDamageCondition());
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/ProjectileDuplicationBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/ProjectileDuplicationBonus.java
index e6547e430..86d319c93 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/ProjectileDuplicationBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/ProjectileDuplicationBonus.java
@@ -88,7 +88,7 @@ public SkillBonus<ProjectileDuplicationBonus> merge(SkillBonus<?> other) {
     public MutableComponent getSimpleTooltip() {
         MutableComponent tooltip;
         if (chance < 1f || chance % 1 != 0) {
-            tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId() + ".chance", chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId() + ".chance", chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         } else if (chance == 1f) {
             tooltip = Component.translatable(getDescriptionId());
         } else {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/ProjectileSpeedBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/ProjectileSpeedBonus.java
index d7a19174e..0b13bacb5 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/ProjectileSpeedBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/ProjectileSpeedBonus.java
@@ -77,7 +77,7 @@ public SkillBonus<ProjectileSpeedBonus> merge(SkillBonus<?> other) {
 
     @Override
     public MutableComponent getSimpleTooltip() {
-        MutableComponent bonusTooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), multiplier, AttributeModifier.Operation.MULTIPLY_BASE);
+        MutableComponent bonusTooltip = TooltipHelper.getSkillBonusTooltip(getDescriptionId(), multiplier, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         bonusTooltip = playerCondition.getTooltip(bonusTooltip, Target.PLAYER);
         bonusTooltip = playerMultiplier.getTooltip(bonusTooltip, Target.PLAYER);
         return bonusTooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/RecipeUnlockBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/RecipeUnlockBonus.java
index dd210f031..038349bfc 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/RecipeUnlockBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/RecipeUnlockBonus.java
@@ -16,7 +16,7 @@
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.network.chat.Style;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.crafting.Recipe;
+import net.minecraft.world.item.crafting.RecipeHolder;
 import net.minecraft.world.item.crafting.RecipeManager;
 
 import javax.annotation.Nonnull;
@@ -86,7 +86,9 @@ public void addEditorWidgets(SkillTreeEditor editor, Consumer<RecipeUnlockBonus>
         ClientLevel clientLevel = Minecraft.getInstance().level;
         Objects.requireNonNull(clientLevel);
         RecipeManager recipesManager = clientLevel.getRecipeManager();
-        List<ResourceLocation> artisanRecipes = recipesManager.getAllRecipesFor(PSTRecipeTypes.WORKBENCH).stream().map(Recipe::getId)
+        List<ResourceLocation> artisanRecipes = recipesManager
+                .getAllRecipesFor(PSTRecipeTypes.WORKBENCH.get()).stream()
+                .map(RecipeHolder::id)
                 .toList();
         editor.addSelectionMenu(0, 0, 200, artisanRecipes).setValue(recipeId).setResponder(id -> selectRecipeId(editor, consumer, id));
         editor.increaseHeight(19);
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/RemoveMobEffectBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/RemoveMobEffectBonus.java
index 00264da92..efbd359ae 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/RemoveMobEffectBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/RemoveMobEffectBonus.java
@@ -40,7 +40,11 @@ public RemoveMobEffectBonus(float chance, MobEffectPredicate effectPredicate, Sk
 
     @Override
     public void applyEffect(LivingEntity target, @Nullable LivingEntity source) {
-        target.getActiveEffects().stream().map(MobEffectInstance::getEffect).filter(effectPredicate).forEach(target::removeEffect);
+        target.getActiveEffects().stream()
+                .filter(instance -> effectPredicate.test(instance.getEffect().value()))
+                .map(MobEffectInstance::getEffect)
+                .toList()
+                .forEach(target::removeEffect);
     }
 
     @Override
@@ -90,7 +94,7 @@ public MutableComponent getSimpleTooltip() {
         }
         MutableComponent tooltip = Component.translatable(descriptioId, effectDescription);
         if (chance < 1) {
-            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         }
         tooltip = eventListener.getTooltip(tooltip);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/RepairEfficiencyBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/RepairEfficiencyBonus.java
index cbcb8b922..d006119f7 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/RepairEfficiencyBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/RepairEfficiencyBonus.java
@@ -72,7 +72,7 @@ public SkillBonus<RepairEfficiencyBonus> merge(SkillBonus<?> other) {
     @Override
     public MutableComponent getSimpleTooltip() {
         Component itemDescription = itemStackPredicate.getTooltip("plural.type");
-        AttributeModifier.Operation operation = AttributeModifier.Operation.MULTIPLY_BASE;
+        AttributeModifier.Operation operation = AttributeModifier.Operation.ADD_MULTIPLIED_BASE;
         Component bonusDescription = Component.translatable(getDescriptionId() + ".bonus");
         bonusDescription = TooltipHelper.getSkillBonusTooltip(bonusDescription, multiplier, operation)
                 .withStyle(TooltipHelper.getSkillBonusSecondStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/player/RestoreHealthBonus.java b/src/main/java/daripher/skilltree/skill/bonus/player/RestoreHealthBonus.java
index a1e3753cd..287c9c3db 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/player/RestoreHealthBonus.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/player/RestoreHealthBonus.java
@@ -116,7 +116,7 @@ public MutableComponent getSimpleTooltip() {
         }
         MutableComponent tooltip = Component.translatable(bonusDescription, amountDescription);
         if (chance < 1) {
-            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.MULTIPLY_BASE);
+            tooltip = TooltipHelper.getSkillBonusTooltip(tooltip, chance, AttributeModifier.Operation.ADD_MULTIPLIED_BASE);
         }
         tooltip = eventListener.getTooltip(tooltip);
         return tooltip.withStyle(TooltipHelper.getSkillBonusStyle(isPositive()));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/effect/MobEffectIdPredicate.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/effect/MobEffectIdPredicate.java
index ecf941cb9..6ef9dda04 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/effect/MobEffectIdPredicate.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/effect/MobEffectIdPredicate.java
@@ -132,7 +132,7 @@ private MobEffectIdPredicate validatePredicate(MobEffectPredicate predicate) {
 
         @Override
         public MobEffectPredicate createDefaultInstance() {
-            return new MobEffectIdPredicate(MobEffects.POISON);
+            return new MobEffectIdPredicate(MobEffects.POISON.value());
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/ArmorEnchantmentCondition.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/ArmorEnchantmentCondition.java
index 9611b018e..198b183f9 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/ArmorEnchantmentCondition.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/ArmorEnchantmentCondition.java
@@ -5,7 +5,7 @@
 import daripher.skilltree.init.predicate.PSTEnchantmentPredicates;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.item.enchantment.EnchantmentCategory;
+import daripher.skilltree.enchantment.EnchantmentCategory;
 
 import java.util.Objects;
 
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/EnchantmentCondition.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/EnchantmentCondition.java
index 792f2309a..a4e775175 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/EnchantmentCondition.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/EnchantmentCondition.java
@@ -2,7 +2,7 @@
 
 import daripher.skilltree.init.PSTRegistries;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.enchantment.EnchantmentCategory;
+import daripher.skilltree.enchantment.EnchantmentCategory;
 
 import java.util.Objects;
 
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/NoneEnchantmentCondition.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/NoneEnchantmentCondition.java
index a2e335397..10e0eee6b 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/NoneEnchantmentCondition.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/NoneEnchantmentCondition.java
@@ -5,7 +5,7 @@
 import daripher.skilltree.init.predicate.PSTEnchantmentPredicates;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.item.enchantment.EnchantmentCategory;
+import daripher.skilltree.enchantment.EnchantmentCategory;
 
 public enum NoneEnchantmentCondition implements EnchantmentCondition {
     INSTANCE;
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/WeaponEnchantmentCondition.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/WeaponEnchantmentCondition.java
index 08ee8dd35..f5a063794 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/WeaponEnchantmentCondition.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/enchantment/WeaponEnchantmentCondition.java
@@ -5,7 +5,7 @@
 import daripher.skilltree.init.predicate.PSTEnchantmentPredicates;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.item.enchantment.EnchantmentCategory;
+import daripher.skilltree.enchantment.EnchantmentCategory;
 
 import java.util.Objects;
 
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/EnchantedStackPredicate.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/EnchantedStackPredicate.java
index f1e49fa2c..a5cdb7ac0 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/EnchantedStackPredicate.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/EnchantedStackPredicate.java
@@ -26,7 +26,7 @@ public EnchantedStackPredicate(ItemStackPredicate itemStackPredicate) {
 
     @Override
     public boolean test(ItemStack stack) {
-        return !EnchantmentHelper.getEnchantments(stack).isEmpty() && itemStackPredicate.test(stack);
+        return !stack.getEnchantments().isEmpty() && itemStackPredicate.test(stack);
     }
 
     @Override
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/EquipmentPredicate.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/EquipmentPredicate.java
index 7642578c5..729b2bc15 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/EquipmentPredicate.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/EquipmentPredicate.java
@@ -14,8 +14,8 @@
 import net.minecraft.tags.ItemTags;
 import net.minecraft.world.entity.EquipmentSlot;
 import net.minecraft.world.item.*;
-import net.minecraftforge.common.Tags;
-import net.minecraftforge.registries.ForgeRegistries;
+import net.neoforged.neoforge.common.Tags;
+import daripher.skilltree.util.ForgeRegistries;
 
 import java.util.Locale;
 import java.util.Objects;
@@ -66,7 +66,9 @@ public static boolean isMeleeWeapon(ItemStack stack) {
     }
 
     public static boolean isLeggings(ItemStack stack) {
-        return stack.getItem() instanceof ArmorItem armor && armor.getEquipmentSlot() == EquipmentSlot.LEGS || stack.is(Tags.Items.ARMORS_LEGGINGS);
+        return stack.getItem() instanceof ArmorItem armor
+                        && armor.getEquipmentSlot() == EquipmentSlot.LEGS
+                || stack.is(ItemTags.LEG_ARMOR);
     }
 
     public static boolean isTrident(ItemStack stack) {
@@ -74,7 +76,7 @@ public static boolean isTrident(ItemStack stack) {
         if (Objects.requireNonNull(id).toString().equals("tetra:modular_single")) {
             return true;
         }
-        return stack.getItem() instanceof TridentItem || stack.is(Tags.Items.TOOLS_TRIDENTS);
+        return stack.getItem() instanceof TridentItem || stack.is(Tags.Items.TOOLS_SPEAR);
     }
 
     public static boolean isPickaxe(ItemStack stack) {
@@ -86,7 +88,7 @@ public static boolean isCrossbow(ItemStack stack) {
         if (Objects.requireNonNull(id).toString().equals("tetra:modular_crossbow")) {
             return true;
         }
-        return stack.getItem() instanceof CrossbowItem || stack.is(Tags.Items.TOOLS_CROSSBOWS);
+        return stack.getItem() instanceof CrossbowItem || stack.is(Tags.Items.TOOLS_CROSSBOW);
     }
 
     public static boolean isWeapon(ItemStack stack) {
@@ -98,7 +100,9 @@ public static boolean isPotion(ItemStack stack) {
     }
 
     public static boolean isChestplate(ItemStack stack) {
-        return stack.getItem() instanceof ArmorItem armor && armor.getEquipmentSlot() == EquipmentSlot.CHEST || stack.is(Tags.Items.ARMORS_CHESTPLATES);
+        return stack.getItem() instanceof ArmorItem armor
+                        && armor.getEquipmentSlot() == EquipmentSlot.CHEST
+                || stack.is(ItemTags.CHEST_ARMOR);
     }
 
     public static boolean isShovel(ItemStack stack) {
@@ -110,11 +114,13 @@ public static boolean isShield(ItemStack stack) {
         if (Objects.requireNonNull(id).toString().equals("tetra:modular_shield")) {
             return true;
         }
-        return stack.getItem() instanceof ShieldItem || stack.is(Tags.Items.TOOLS_SHIELDS);
+        return stack.getItem() instanceof ShieldItem || stack.is(Tags.Items.TOOLS_SHIELD);
     }
 
     public static boolean isHelmet(ItemStack stack) {
-        return stack.getItem() instanceof ArmorItem armor && armor.getEquipmentSlot() == EquipmentSlot.HEAD || stack.is(Tags.Items.ARMORS_HELMETS);
+        return stack.getItem() instanceof ArmorItem armor
+                        && armor.getEquipmentSlot() == EquipmentSlot.HEAD
+                || stack.is(ItemTags.HEAD_ARMOR);
     }
 
     public static boolean isSword(ItemStack stack) {
@@ -138,11 +144,13 @@ public static boolean isBow(ItemStack stack) {
         if (Objects.requireNonNull(id).toString().equals("tetra:modular_bow")) {
             return true;
         }
-        return stack.getItem() instanceof BowItem || stack.is(Tags.Items.TOOLS_BOWS);
+        return stack.getItem() instanceof BowItem || stack.is(Tags.Items.TOOLS_BOW);
     }
 
     public static boolean isBoots(ItemStack stack) {
-        return stack.getItem() instanceof ArmorItem armor && armor.getEquipmentSlot() == EquipmentSlot.FEET || stack.is(Tags.Items.ARMORS_BOOTS);
+        return stack.getItem() instanceof ArmorItem armor
+                        && armor.getEquipmentSlot() == EquipmentSlot.FEET
+                || stack.is(ItemTags.FOOT_ARMOR);
     }
 
     public static boolean isAxe(ItemStack stack) {
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/ItemIdPredicate.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/ItemIdPredicate.java
index 14f73510d..bdef513d4 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/ItemIdPredicate.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/ItemIdPredicate.java
@@ -11,7 +11,7 @@
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.registries.ForgeRegistries;
+import daripher.skilltree.util.ForgeRegistries;
 
 import java.util.Objects;
 import java.util.function.Consumer;
@@ -74,7 +74,7 @@ private void selectItemId(Consumer<ItemStackPredicate> consumer, String text) {
     }
 
     private static boolean isItemId(String text) {
-        if (!ResourceLocation.isValidResourceLocation(text)) {
+        if (ResourceLocation.tryParse(text) == null) {
             return false;
         }
         return ForgeRegistries.ITEMS.containsKey(ResourceLocation.parse(text));
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/ItemTagPredicate.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/ItemTagPredicate.java
index 171ba99ee..35275e4e4 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/ItemTagPredicate.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/ItemTagPredicate.java
@@ -10,7 +10,7 @@
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.tags.ItemTags;
 import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.common.Tags;
+import net.neoforged.neoforge.common.Tags;
 
 import java.util.Objects;
 import java.util.function.Consumer;
@@ -58,7 +58,8 @@ public ItemStackPredicate.Serializer getSerializer() {
     public void addEditorWidgets(SkillTreeEditor editor, Consumer<ItemStackPredicate> consumer) {
         editor.addLabel(0, 0, "Tag", ChatFormatting.GREEN);
         editor.increaseHeight(19);
-        editor.addTextField(0, 0, 200, 14, tagId.toString()).setSoftFilter(ResourceLocation::isValidResourceLocation)
+        editor.addTextField(0, 0, 200, 14, tagId.toString())
+                .setSoftFilter(text -> ResourceLocation.tryParse(text) != null)
                 .setResponder(text -> selectTagId(consumer, text));
         editor.increaseHeight(19);
     }
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/PotionStackPredicate.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/PotionStackPredicate.java
index 075883547..658c7bedf 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/item/PotionStackPredicate.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/item/PotionStackPredicate.java
@@ -7,6 +7,7 @@
 import daripher.skilltree.init.predicate.PSTItemPredicates;
 import daripher.skilltree.network.NetworkHelper;
 import net.minecraft.ChatFormatting;
+import net.minecraft.core.component.DataComponents;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
@@ -14,11 +15,12 @@
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.PotionItem;
-import net.minecraft.world.item.alchemy.PotionUtils;
+import net.minecraft.world.item.alchemy.PotionContents;
 
 import java.util.Locale;
 import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.stream.StreamSupport;
 
 public final class PotionStackPredicate implements ItemStackPredicate {
     private Type type;
@@ -41,8 +43,11 @@ public boolean test(ItemStack stack) {
     }
 
     public static boolean hasEffects(ItemStack stack, MobEffectCategory category) {
-        return PotionUtils.getAllEffects(stack.getOrCreateTag()).stream().map(MobEffectInstance::getEffect)
-                .anyMatch(effect -> effect.getCategory() == category);
+        PotionContents contents =
+                stack.getOrDefault(DataComponents.POTION_CONTENTS, PotionContents.EMPTY);
+        return StreamSupport.stream(contents.getAllEffects().spliterator(), false)
+                .map(MobEffectInstance::getEffect)
+                .anyMatch(effect -> effect.value().getCategory() == category);
     }
 
     @Override
diff --git a/src/main/java/daripher/skilltree/skill/bonus/predicate/living/HasEffectEntityPredicate.java b/src/main/java/daripher/skilltree/skill/bonus/predicate/living/HasEffectEntityPredicate.java
index 5156ef08b..870c907ab 100644
--- a/src/main/java/daripher/skilltree/skill/bonus/predicate/living/HasEffectEntityPredicate.java
+++ b/src/main/java/daripher/skilltree/skill/bonus/predicate/living/HasEffectEntityPredicate.java
@@ -8,6 +8,8 @@
 import daripher.skilltree.network.NetworkHelper;
 import daripher.skilltree.skill.bonus.SkillBonus;
 import net.minecraft.ChatFormatting;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
@@ -37,10 +39,11 @@ public HasEffectEntityPredicate(@Nonnull MobEffect effect, int amplifier) {
 
     @Override
     public boolean test(LivingEntity living) {
+        Holder<MobEffect> effectHolder = BuiltInRegistries.MOB_EFFECT.wrapAsHolder(this.effect);
         if (amplifier == 0) {
-            return living.hasEffect(this.effect);
+            return living.hasEffect(effectHolder);
         }
-        MobEffectInstance effect = living.getEffect(this.effect);
+        MobEffectInstance effect = living.getEffect(effectHolder);
         return effect != null && effect.getAmplifier() >= this.amplifier;
     }
 
@@ -164,7 +167,7 @@ public void serialize(FriendlyByteBuf buf, LivingEntityPredicate predicate) {
 
         @Override
         public LivingEntityPredicate createDefaultInstance() {
-            return new HasEffectEntityPredicate(MobEffects.POISON);
+            return new HasEffectEntityPredicate(MobEffects.POISON.value());
         }
     }
 }
diff --git a/src/main/java/daripher/skilltree/skill/requirement/AdvancementRequirement.java b/src/main/java/daripher/skilltree/skill/requirement/AdvancementRequirement.java
index 340f12176..1e1789b25 100644
--- a/src/main/java/daripher/skilltree/skill/requirement/AdvancementRequirement.java
+++ b/src/main/java/daripher/skilltree/skill/requirement/AdvancementRequirement.java
@@ -6,7 +6,7 @@
 import daripher.skilltree.init.PSTSkillRequirements;
 import daripher.skilltree.mixin.ClientAdvancementsAccessor;
 import net.minecraft.ChatFormatting;
-import net.minecraft.advancements.Advancement;
+import net.minecraft.advancements.AdvancementHolder;
 import net.minecraft.advancements.AdvancementProgress;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.multiplayer.ClientAdvancements;
@@ -40,7 +40,7 @@ public boolean test(Player player) {
             LocalPlayer localPlayer = (LocalPlayer) player;
             ClientAdvancements advancements = localPlayer.connection.getAdvancements();
             ClientAdvancementsAccessor advancementsAccessor = (ClientAdvancementsAccessor) advancements;
-            Advancement advancement = advancements.getAdvancements().get(advancementId);
+            AdvancementHolder advancement = advancements.get(advancementId);
             AdvancementProgress progress = advancementsAccessor.getProgress().get(advancement);
             if (progress == null) {
                 return false;
@@ -54,7 +54,7 @@ public boolean test(Player player) {
             }
             ServerAdvancementManager advancementManager = server.getAdvancements();
             PlayerAdvancements advancements = serverPlayer.getAdvancements();
-            Advancement advancement = advancementManager.getAdvancement(advancementId);
+            AdvancementHolder advancement = advancementManager.get(advancementId);
             if (advancement == null) {
                 return false;
             }
@@ -77,7 +77,8 @@ public void addEditorWidgets(SkillTreeEditor editor, Consumer<AdvancementRequire
         ClientAdvancements advancements = localPlayer.connection.getAdvancements();
         editor.addLabel(0, 0, "Advancement ID", ChatFormatting.GOLD);
         editor.increaseHeight(19);
-        List<ResourceLocation> advancementIds = advancements.getAdvancements().getAllAdvancements().stream().map(Advancement::getId)
+        List<ResourceLocation> advancementIds = advancements.getTree().nodes().stream()
+                .map(node -> node.holder().id())
                 .toList();
         editor.addSelectionMenu(0, 0, 200, advancementIds).setValue(getAdvancementId())
                 .setElementNameGetter(v -> Component.literal(v.toString())).setResponder(v -> selectAdvancementId(consumer, v));
diff --git a/src/main/java/daripher/skilltree/skill/requirement/StatRequirement.java b/src/main/java/daripher/skilltree/skill/requirement/StatRequirement.java
index cc7f03e48..cb2defe25 100644
--- a/src/main/java/daripher/skilltree/skill/requirement/StatRequirement.java
+++ b/src/main/java/daripher/skilltree/skill/requirement/StatRequirement.java
@@ -19,9 +19,9 @@
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.registries.ForgeRegistries;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.api.distmarker.OnlyIn;
+import daripher.skilltree.util.ForgeRegistries;
 
 import javax.annotation.Nonnull;
 import java.util.Objects;
diff --git a/src/main/java/daripher/skilltree/util/ForgeRegistries.java b/src/main/java/daripher/skilltree/util/ForgeRegistries.java
new file mode 100644
index 000000000..8741d1f1f
--- /dev/null
+++ b/src/main/java/daripher/skilltree/util/ForgeRegistries.java
@@ -0,0 +1,315 @@
+package daripher.skilltree.util;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+import net.neoforged.neoforge.registries.callback.RegistryCallback;
+import net.neoforged.neoforge.registries.datamaps.DataMapType;
+import net.neoforged.neoforge.registries.IRegistryExtension;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.HolderOwner;
+import net.minecraft.core.HolderSet;
+import net.minecraft.core.Registry;
+import net.minecraft.core.RegistrationInfo;
+import net.minecraft.core.registries.BuiltInRegistries;
+import com.mojang.serialization.Lifecycle;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.stats.StatType;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.ai.attributes.Attribute;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.alchemy.Potion;
+import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraft.world.level.block.Block;
+
+public final class ForgeRegistries {
+  public static final ForgeRegistry<Item> ITEMS = new ForgeRegistry<>(BuiltInRegistries.ITEM);
+  public static final ForgeRegistry<Block> BLOCKS = new ForgeRegistry<>(BuiltInRegistries.BLOCK);
+  public static final ForgeRegistry<MobEffect> MOB_EFFECTS =
+      new ForgeRegistry<>(BuiltInRegistries.MOB_EFFECT);
+  public static final ForgeRegistry<Potion> POTIONS = new ForgeRegistry<>(BuiltInRegistries.POTION);
+  public static final ForgeRegistry<MenuType<?>> MENU_TYPES =
+      new ForgeRegistry<>(BuiltInRegistries.MENU);
+  public static final ForgeRegistry<RecipeSerializer<?>> RECIPE_SERIALIZERS =
+      new ForgeRegistry<>(BuiltInRegistries.RECIPE_SERIALIZER);
+  public static final ForgeRegistry<RecipeType<?>> RECIPE_TYPES =
+      new ForgeRegistry<>(BuiltInRegistries.RECIPE_TYPE);
+  public static final ForgeRegistry<Attribute> ATTRIBUTES =
+      new ForgeRegistry<>(BuiltInRegistries.ATTRIBUTE);
+  public static final ForgeRegistry<EntityType<?>> ENTITY_TYPES =
+      new ForgeRegistry<>(BuiltInRegistries.ENTITY_TYPE);
+  public static final ForgeRegistry<StatType<?>> STAT_TYPES =
+      new ForgeRegistry<>(BuiltInRegistries.STAT_TYPE);
+
+  private ForgeRegistries() {}
+
+  public static final class ForgeRegistry<T> implements Registry<T> {
+    private final Registry<T> registry;
+
+    public ForgeRegistry(Registry<T> registry) {
+      this.registry = registry;
+    }
+
+    public T getValue(ResourceLocation id) {
+      return registry.get(id);
+    }
+
+    public Collection<T> getValues() {
+      return registry.stream().toList();
+    }
+
+    public Set<Map.Entry<ResourceKey<T>, T>> getEntries() {
+      return registry.entrySet();
+    }
+
+    public Set<ResourceLocation> getKeys() {
+      return registry.keySet();
+    }
+
+    public T register(String id, T value) {
+      return Registry.register(registry, id, value);
+    }
+
+    public T register(ResourceLocation id, T value) {
+      return Registry.register(registry, id, value);
+    }
+
+    @Override
+    public ResourceKey<? extends Registry<T>> key() {
+      return registry.key();
+    }
+
+    private IRegistryExtension<T> extension() {
+      return registry;
+    }
+
+    @Override
+    public ResourceLocation getKey(T value) {
+      return registry.getKey(value);
+    }
+
+    @Override
+    public Optional<ResourceKey<T>> getResourceKey(T value) {
+      return registry.getResourceKey(value);
+    }
+
+    @Override
+    public int getId(T value) {
+      return registry.getId(value);
+    }
+
+    @Override
+    public T byId(int id) {
+      return registry.byId(id);
+    }
+
+    @Override
+    public int size() {
+      return registry.size();
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      return registry.iterator();
+    }
+
+    @Override
+    public T get(ResourceKey<T> key) {
+      return registry.get(key);
+    }
+
+    @Override
+    public T get(ResourceLocation id) {
+      return registry.get(id);
+    }
+
+    @Override
+    public Optional<RegistrationInfo> registrationInfo(ResourceKey<T> key) {
+      return registry.registrationInfo(key);
+    }
+
+    @Override
+    public Lifecycle registryLifecycle() {
+      return registry.registryLifecycle();
+    }
+
+    @Override
+    public Optional<Holder.Reference<T>> getAny() {
+      return registry.getAny();
+    }
+
+    @Override
+    public Set<ResourceLocation> keySet() {
+      return registry.keySet();
+    }
+
+    @Override
+    public Set<Map.Entry<ResourceKey<T>, T>> entrySet() {
+      return registry.entrySet();
+    }
+
+    @Override
+    public Set<ResourceKey<T>> registryKeySet() {
+      return registry.registryKeySet();
+    }
+
+    @Override
+    public Optional<Holder.Reference<T>> getRandom(net.minecraft.util.RandomSource random) {
+      return registry.getRandom(random);
+    }
+
+    @Override
+    public boolean containsKey(ResourceLocation id) {
+      return registry.containsKey(id);
+    }
+
+    @Override
+    public boolean containsKey(ResourceKey<T> key) {
+      return registry.containsKey(key);
+    }
+
+    @Override
+    public Registry<T> freeze() {
+      return registry.freeze();
+    }
+
+    @Override
+    public Holder.Reference<T> createIntrusiveHolder(T value) {
+      return registry.createIntrusiveHolder(value);
+    }
+
+    @Override
+    public Optional<Holder.Reference<T>> getHolder(int id) {
+      return registry.getHolder(id);
+    }
+
+    @Override
+    public Optional<Holder.Reference<T>> getHolder(ResourceLocation id) {
+      return registry.getHolder(id);
+    }
+
+    @Override
+    public Optional<Holder.Reference<T>> getHolder(ResourceKey<T> key) {
+      return registry.getHolder(key);
+    }
+
+    @Override
+    public Holder<T> wrapAsHolder(T value) {
+      return registry.wrapAsHolder(value);
+    }
+
+    @Override
+    public Stream<Holder.Reference<T>> holders() {
+      return registry.holders();
+    }
+
+    @Override
+    public Optional<HolderSet.Named<T>> getTag(net.minecraft.tags.TagKey<T> tag) {
+      return registry.getTag(tag);
+    }
+
+    @Override
+    public HolderSet.Named<T> getOrCreateTag(net.minecraft.tags.TagKey<T> tag) {
+      return registry.getOrCreateTag(tag);
+    }
+
+    @Override
+    public Stream<com.mojang.datafixers.util.Pair<net.minecraft.tags.TagKey<T>, HolderSet.Named<T>>>
+        getTags() {
+      return registry.getTags();
+    }
+
+    @Override
+    public Stream<net.minecraft.tags.TagKey<T>> getTagNames() {
+      return registry.getTagNames();
+    }
+
+    @Override
+    public void resetTags() {
+      registry.resetTags();
+    }
+
+    @Override
+    public void bindTags(Map<net.minecraft.tags.TagKey<T>, java.util.List<Holder<T>>> tags) {
+      registry.bindTags(tags);
+    }
+
+    @Override
+    public HolderOwner<T> holderOwner() {
+      return registry.holderOwner();
+    }
+
+    @Override
+    public HolderLookup.RegistryLookup<T> asLookup() {
+      return registry.asLookup();
+    }
+
+    @Override
+    public HolderLookup.RegistryLookup<T> asTagAddingLookup() {
+      return registry.asTagAddingLookup();
+    }
+
+    @Override
+    public boolean doesSync() {
+      return extension().doesSync();
+    }
+
+    @Override
+    public int getMaxId() {
+      return extension().getMaxId();
+    }
+
+    @Override
+    public void addCallback(RegistryCallback<T> callback) {
+      extension().addCallback(callback);
+    }
+
+    @Override
+    public void addAlias(ResourceLocation from, ResourceLocation to) {
+      extension().addAlias(from, to);
+    }
+
+    @Override
+    public ResourceLocation resolve(ResourceLocation id) {
+      return extension().resolve(id);
+    }
+
+    @Override
+    public ResourceKey<T> resolve(ResourceKey<T> key) {
+      return extension().resolve(key);
+    }
+
+    @Override
+    public int getId(ResourceKey<T> key) {
+      return extension().getId(key);
+    }
+
+    @Override
+    public int getId(ResourceLocation id) {
+      return extension().getId(id);
+    }
+
+    @Override
+    public boolean containsValue(T value) {
+      return extension().containsValue(value);
+    }
+
+    @Override
+    public <A> A getData(DataMapType<T, A> type, ResourceKey<T> key) {
+      return extension().getData(type, key);
+    }
+
+    @Override
+    public <A> Map<ResourceKey<T>, A> getDataMap(DataMapType<T, A> type) {
+      return extension().getDataMap(type);
+    }
+  }
+}
diff --git a/src/main/resources/META-INF/mods.toml b/src/main/resources/META-INF/mods.toml
deleted file mode 100644
index e2aade41a..000000000
--- a/src/main/resources/META-INF/mods.toml
+++ /dev/null
@@ -1,38 +0,0 @@
-modLoader="javafml"
-loaderVersion="${loader_version_range}"
-license="${mod_license}"
-
-[[mods]]
-	modId="${mod_id}"
-	version="${mod_version}"
-	displayName="${mod_name}"
-	authors="${mod_authors}"
-	description='''${mod_description}'''
-
-[[dependencies.${mod_id}]]
-    modId="forge"
-    mandatory=true
-    versionRange="${forge_version_range}"
-    ordering="NONE"
-    side="BOTH"
-
-[[dependencies.${mod_id}]]
-    modId="minecraft"
-    mandatory=true
-    versionRange="${minecraft_version_range}"
-    ordering="NONE"
-    side="BOTH"
-
-[[dependencies.${mod_id}]]
-    modId="attributefix"
-    mandatory=true
-    versionRange="[21.0.1,)"
-    ordering="NONE"
-    side="BOTH"
-
-[[dependencies.${mod_id}]]
-    modId="curios"
-    mandatory=false
-    versionRange="[5.3.1+1.20.1,)"
-    ordering="AFTER"
-    side="BOTH"
\ No newline at end of file
diff --git a/src/main/resources/META-INF/neoforge.mods.toml b/src/main/resources/META-INF/neoforge.mods.toml
new file mode 100644
index 000000000..b246b4081
--- /dev/null
+++ b/src/main/resources/META-INF/neoforge.mods.toml
@@ -0,0 +1,41 @@
+modLoader="javafml"
+loaderVersion="${loader_version_range}"
+license="${mod_license}"
+
+[[mods]]
+modId="${mod_id}"
+version="${mod_version}"
+displayName="${mod_name}"
+authors="${mod_authors}"
+description='''${mod_description}'''
+
+[[mixins]]
+config="${mod_id}.mixins.json"
+
+[[dependencies.${mod_id}]]
+modId="neoforge"
+mandatory=true
+versionRange="[${neo_version},)"
+ordering="NONE"
+side="BOTH"
+
+[[dependencies.${mod_id}]]
+modId="minecraft"
+mandatory=true
+versionRange="${minecraft_version_range}"
+ordering="NONE"
+side="BOTH"
+
+[[dependencies.${mod_id}]]
+modId="attributefix"
+mandatory=true
+versionRange="[21.1.1,)"
+ordering="NONE"
+side="BOTH"
+
+[[dependencies.${mod_id}]]
+modId="curios"
+mandatory=false
+versionRange="[9.4.2+1.21.1,)"
+ordering="AFTER"
+side="BOTH"
diff --git a/src/main/resources/assets/skilltree/lang/ko_kr.json b/src/main/resources/assets/skilltree/lang/ko_kr.json
index 0c8d041dc..f989d197a 100644
--- a/src/main/resources/assets/skilltree/lang/ko_kr.json
+++ b/src/main/resources/assets/skilltree/lang/ko_kr.json
@@ -302,7 +302,7 @@
   "item_tag.curios:ring": "반지",
   "item_tag.curios:ring.plural": "반지",
   "item_tag.curios:ring.plural.type": "반지",
-  "item_tag.forge:curios/jewelry": "장신구",
+  "item_tag.curios:jewelry": "장신구",
   "key.categories.skilltree": "Passive Skill Tree",
   "key.display_skill_tree": "스킬 트리 열기",
   "living_condition.skilltree.attribute_value.max": "%s (%s이 %s %s 이하일 때)",
@@ -1035,4 +1035,4 @@
   "widget.skill_button.multiple_bonuses": "%s 및 %s",
   "widget.skill_button.not_learned": "스킬을 배우지 않음",
   "widget.skill_points_left": "남은 포인트: %s"
-}
\ No newline at end of file
+}
diff --git a/src/main/resources/assets/skilltree/lang/pt_br.json b/src/main/resources/assets/skilltree/lang/pt_br.json
index b67c88f38..6d4f61b52 100644
--- a/src/main/resources/assets/skilltree/lang/pt_br.json
+++ b/src/main/resources/assets/skilltree/lang/pt_br.json
@@ -111,7 +111,7 @@
   "item_tag.curios:necklace.plural": "Colares",
   "item_tag.curios:ring": "Anel",
   "item_tag.curios:ring.plural": "Anéis",
-  "item_tag.forge:curios/jewelry": "Joias",
+  "item_tag.curios:jewelry": "Joias",
   "item_tag.skilltree:armors/leather": "Armadura de Couro",
   "item_tag.skilltree:armors/leather.plural": "Armaduras de Couro",
   "key.categories.skilltree": "Árvore de Habilidades Passivas",
@@ -525,4 +525,4 @@
   "widget.skill_button.multiple_bonuses": "%s e %s",
   "widget.skill_button.not_learned": "Habilidade não aprendida",
   "widget.skill_points_left": "Pontos restantes: %s"
-}
\ No newline at end of file
+}
diff --git a/src/main/resources/assets/skilltree/lang/zh_cn.json b/src/main/resources/assets/skilltree/lang/zh_cn.json
index 5416cc641..8f2579b8d 100644
--- a/src/main/resources/assets/skilltree/lang/zh_cn.json
+++ b/src/main/resources/assets/skilltree/lang/zh_cn.json
@@ -302,7 +302,7 @@
   "item_tag.curios:ring": "戒指",
   "item_tag.curios:ring.plural": "戒指",
   "item_tag.curios:ring.plural.type": "戒指",
-  "item_tag.forge:curios/jewelry": "珠宝",
+  "item_tag.curios:jewelry": "珠宝",
   "key.categories.skilltree": "被动技能树",
   "key.display_skill_tree": "打开技能页面",
   "living_condition.skilltree.attribute_value.max": "%s，如果%s有%s以下的%s",
@@ -1035,4 +1035,4 @@
   "widget.skill_button.multiple_bonuses": "%s and %s",
   "widget.skill_button.not_learned": "技能未学习",
   "widget.skill_points_left": "剩余技能点: %s"
-}
\ No newline at end of file
+}
diff --git a/src/main/resources/data/skilltree/recipes/potion_mixing.json b/src/main/resources/data/skilltree/recipe/potion_mixing.json
similarity index 68%
rename from src/main/resources/data/skilltree/recipes/potion_mixing.json
rename to src/main/resources/data/skilltree/recipe/potion_mixing.json
index dcd317ec8..15c44312c 100644
--- a/src/main/resources/data/skilltree/recipes/potion_mixing.json
+++ b/src/main/resources/data/skilltree/recipe/potion_mixing.json
@@ -1,4 +1,5 @@
 {
   "type": "skilltree:workbench_potion_mixing",
+  "id": "skilltree:potion_mixing",
   "requires_passive_skill": true
-}
\ No newline at end of file
+}
diff --git a/src/main/resources/data/skilltree/recipes/weapon_poisoning.json b/src/main/resources/data/skilltree/recipe/weapon_poisoning.json
similarity index 72%
rename from src/main/resources/data/skilltree/recipes/weapon_poisoning.json
rename to src/main/resources/data/skilltree/recipe/weapon_poisoning.json
index 93637d113..675f69e37 100644
--- a/src/main/resources/data/skilltree/recipes/weapon_poisoning.json
+++ b/src/main/resources/data/skilltree/recipe/weapon_poisoning.json
@@ -1,5 +1,6 @@
 {
   "type": "skilltree:workbench_weapon_poisoning",
+  "id": "skilltree:weapon_poisoning",
   "max_uses": 20,
   "requires_passive_skill": true
-}
\ No newline at end of file
+}
diff --git a/src/main/resources/pack.mcmeta b/src/main/resources/pack.mcmeta
index eca79ae4a..b90fdd4df 100644
--- a/src/main/resources/pack.mcmeta
+++ b/src/main/resources/pack.mcmeta
@@ -3,6 +3,6 @@
     "description": {
       "text": "${mod_id} resources"
     },
-    "pack_format": 15
+    "pack_format": 34
   }
-}
\ No newline at end of file
+}
diff --git a/src/main/resources/skilltree.mixins.json b/src/main/resources/skilltree.mixins.json
index 855488c9c..2a1ace61d 100644
--- a/src/main/resources/skilltree.mixins.json
+++ b/src/main/resources/skilltree.mixins.json
@@ -1,7 +1,7 @@
 {
   "required": true,
   "minVersion": "0.8",
-  "compatibilityLevel": "JAVA_17",
+  "compatibilityLevel": "JAVA_21",
   "package": "daripher.skilltree.mixin",
   "mixins": [
     "minecraft/PlayerMixin",
@@ -14,10 +14,11 @@
   ],
   "client": [
     "EditBoxAccessor",
-    "ClientAdvancementsAccessor"
+    "ClientAdvancementsAccessor",
+    "minecraft/ClientPacketListenerMixin"
   ],
   "injectors": {
     "defaultRequire": 1
   },
   "refmap": "skilltree.refmap.json"
-}
\ No newline at end of file
+}