Bump CC:T to 1.111.1

Update NF and NG
- Rename ToolActions to ItemAbilities. Closes #1881. - Remove our source set helper, as NG has built-in support for this now. - Remove our code to generate new JavaExec tasks from runs, as NG now generates JavaExec tasks normally.
2025-10-15 22:17:39 +00:00 · 2024-07-04 19:08:06 +01:00 · 2024-06-29 12:58:03 +01:00 · 2024-06-29 10:50:44 +01:00 · 2024-06-27 20:57:43 +01:00 · 2024-06-26 18:06:48 +01:00
1278 changed files with 20950 additions and 24440 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -18,6 +18,11 @@ ij_any_if_brace_force = if_multiline
 ij_any_for_brace_force = if_multiline
 ij_any_spaces_within_array_initializer_braces = true

+ij_kotlin_allow_trailing_comma = true
+ij_kotlin_allow_trailing_comma_on_call_site = true
+ij_kotlin_method_parameters_wrap = off
+ij_kotlin_call_parameters_wrap = off
+
 [*.md]
 trim_trailing_whitespace = false

@@ -26,27 +31,3 @@ indent_size = 2

 [*.yml]
 indent_size = 2
-
-[*.{kt,kts}]
-ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL
-ij_kotlin_continuation_indent_size = 4
-ij_kotlin_spaces_around_equality_operators = true
-
-ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true
-
-# Prefer to handle these manually
-ij_kotlin_method_parameters_wrap = off
-ij_kotlin_call_parameters_wrap = off
-ij_kotlin_extends_list_wrap = off
-
-ktlint_code_style = intellij_idea
-ktlint_standard_class-naming = disabled
-ktlint_standard_class-signature = disabled
-ktlint_standard_function-naming = disabled
-ktlint_standard_no-wildcard-imports = disabled
-
-# FIXME: These two are disable right now as they're over-eager in putting things
-#  on the same line. We should set max_line_length and handle this properly.
-ktlint_standard_function-signature = disabled
-ktlint_standard_function-expression-body = disabled
--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
@@ -1,18 +1,15 @@
 name: Bug report
 description: Report some misbehaviour in the mod
 labels: [ bug ]
-type: bug
 body:
 - type: dropdown
  id: mc-version
  attributes:
    label: Minecraft Version
-    description: |
-        What version of Minecraft are you using? If your version is not listed, please try to reproduce on one of the supported versions.
+    description: What version of Minecraft are you using?
    options:
      - 1.20.1
-      - 1.21.1
-      - 1.21.7
+      - 1.21.x
  validations:
    required: true
 - type: input
@@ -29,7 +26,8 @@ body:
    label: Details
    description: |
      Description of the bug. Please include the following:
-      - Logs: These will be located in the `logs/` directory of your Minecraft instance. This is always useful, even if it doesn't include errors, so please upload this!
-      - Detailed reproduction steps: sometimes I can spot a bug pretty easily, but often it's much more obscure. The more information I have to help reproduce it, the quicker it'll get fixed.
-
-      ![A gif of burning text reading "Upload your logs!!!"](https://tweaked.cc/images/logs.gif)
+      - Logs: These will be located in the `logs/` directory of your Minecraft
+        instance. Please upload them as a gist or directly into this editor.
+      - Detailed reproduction steps: sometimes I can spot a bug pretty easily,
+        but often it's much more obscure. The more information I have to help
+        reproduce it, the quicker it'll get fixed.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -2,7 +2,6 @@
 name: Feature request
 about: Suggest an idea or improvement
 labels: enhancement
-type: feature
 ---

 <!--
--- a/.github/workflows/main-ci.yml
+++ b/.github/workflows/main-ci.yml
@@ -14,7 +14,7 @@ jobs:
    - name: 📥 Set up Java
      uses: actions/setup-java@v4
      with:
-        java-version: 17
+        java-version: 21
        distribution: 'temurin'

    - name: 📥 Setup Gradle
@@ -30,6 +30,27 @@ jobs:
    - name: ⚒️ Build
      run: ./gradlew assemble || ./gradlew assemble

+    - name: 💡 Lint
+      uses: pre-commit/action@v3.0.0
+
+    - name: 🧪 Run tests
+      run: ./gradlew test validateMixinNames checkChangelog
+
+    - name: 📥 Download assets for game tests
+      run: ./gradlew downloadAssets || ./gradlew downloadAssets
+
+    - name: 🧪 Run integration tests
+      run: ./gradlew runGametest
+
+    - name: 🧪 Run client tests
+      run: ./gradlew runGametestClient # Not checkClient, as no point running rendering tests.
+      # These are a little flaky on GH actions: its useful to run them, but don't break the build.
+      continue-on-error: true
+
+    - name: 🧪 Parse test reports
+      run: ./tools/parse-reports.py
+      if: ${{ failure() }}
+
    - name: 📦 Prepare Jars
      run: |
        # Find the main jar and append the git hash onto it.
@@ -42,29 +63,8 @@ jobs:
        name: CC-Tweaked
        path: ./jars

-    - name: Cache pre-commit
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/pre-commit
-        key: pre-commit-3|${{ env.pythonLocation }}|${{ hashFiles('.pre-commit-config.yaml') }}
-
-    - name: 💡 Lint
-      run: |
-        pipx install pre-commit
-        pre-commit run --show-diff-on-failure --color=always
-
-    - name: 🧪 Run tests
-      run: ./gradlew test validateMixinNames checkChangelog
-
-    - name: 📥 Download assets for game tests
-      run: ./gradlew downloadAssets || ./gradlew downloadAssets
-
-    - name: 🧪 Run integration tests
-      run: ./gradlew runGametest
-
-    - name: 🧪 Parse test reports
-      run: ./tools/parse-reports.py
-      if: ${{ failure() }}
+    - name: 📤 Upload coverage
+      uses: codecov/codecov-action@v4

  build-core:
    strategy:
@@ -87,7 +87,7 @@ jobs:
    - name: 📥 Set up Java
      uses: actions/setup-java@v4
      with:
-        java-version: 17
+        java-version: 21
        distribution: 'temurin'

    - name: 📥 Setup Gradle
--- a/.github/workflows/make-doc.yml
+++ b/.github/workflows/make-doc.yml
@@ -17,7 +17,7 @@ jobs:
    - name: 📥 Set up Java
      uses: actions/setup-java@v4
      with:
-        java-version: 17
+        java-version: 21
        distribution: 'temurin'

    - name: 📥 Setup Gradle
--- a/.gitignore
+++ b/.gitignore
@@ -27,7 +27,6 @@
 *.iml
 .idea
 .gradle
-.kotlin
 *.DS_Store

 /.classpath
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -6,7 +6,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v5.0.0
+  rev: v4.4.0
  hooks:
  - id: trailing-whitespace
  - id: end-of-file-fixer
@@ -27,7 +27,7 @@ repos:
    exclude: "^(.*\\.(bat)|LICENSE)$"

 - repo: https://github.com/fsfe/reuse-tool
-  rev: v5.0.2
+  rev: v2.1.0
  hooks:
  - id: reuse

@@ -58,7 +58,6 @@ repos:
 exclude: |
  (?x)^(
    projects/[a-z]+/src/generated|
-    projects/[a-z]+/src/examples/generatedResources|
    projects/core/src/test/resources/test-rom/data/json-parsing/|
    .*\.dfpwm
  )
--- a/.reuse/dep5
+++ b/.reuse/dep5
@@ -0,0 +1,100 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Source: https://github.com/cc-tweaked/cc-tweaked
+Upstream-Name: CC: Tweaked
+Upstream-Contact: Jonathan Coates <git@squiddev.cc>
+
+Files:
+  projects/common/src/main/resources/assets/computercraft/sounds.json
+  projects/common/src/main/resources/assets/computercraft/sounds/empty.ogg
+  projects/common/src/testMod/resources/data/cctest/computercraft/turtle_upgrade/*
+  projects/common/src/testMod/resources/data/cctest/structures/*
+  projects/*/src/generated/*
+  projects/web/src/htmlTransform/export/index.json
+  projects/web/src/htmlTransform/export/items/minecraft/*
+Comment: Generated/data files are CC0.
+Copyright: The CC: Tweaked Developers
+License: CC0-1.0
+
+Files:
+  doc/images/*
+  package.json
+  package-lock.json
+  projects/common/src/client/resources/computercraft-client.mixins.json
+  projects/common/src/main/resources/assets/minecraft/shaders/core/computercraft/monitor_tbo.json
+  projects/common/src/main/resources/computercraft.mixins.json
+  projects/common/src/testMod/resources/computercraft-gametest.mixins.json
+  projects/common/src/testMod/resources/data/computercraft/loot_tables/treasure_disk.json
+  projects/common/src/testMod/resources/pack.mcmeta
+  projects/core/src/main/resources/data/computercraft/lua/rom/modules/command/.ignoreme
+  projects/core/src/main/resources/data/computercraft/lua/rom/modules/main/.ignoreme
+  projects/core/src/main/resources/data/computercraft/lua/rom/modules/turtle/.ignoreme
+  projects/core/src/main/resources/data/computercraft/lua/rom/motd.txt
+  projects/fabric-api/src/main/modJson/fabric.mod.json
+  projects/fabric/src/client/resources/computercraft-client.fabric.mixins.json
+  projects/fabric/src/main/resources/computercraft.fabric.mixins.json
+  projects/fabric/src/main/resources/fabric.mod.json
+  projects/fabric/src/testMod/resources/computercraft-gametest.fabric.mixins.json
+  projects/fabric/src/testMod/resources/fabric.mod.json
+  projects/forge/src/client/resources/computercraft-client.forge.mixins.json
+  projects/forge/src/main/resources/computercraft.forge.mixins.json
+  projects/web/src/frontend/mount/.settings
+  projects/web/src/frontend/mount/example.nfp
+  projects/web/src/frontend/mount/example.nft
+  projects/web/src/frontend/mount/expr_template.lua
+  projects/web/tsconfig.json
+Comment: Several assets where it's inconvenient to create a .license file.
+Copyright: The CC: Tweaked Developers
+License: MPL-2.0
+
+Files:
+  doc/logo.png
+  doc/logo-darkmode.png
+  projects/common/src/main/resources/assets/computercraft/models/*
+  projects/common/src/main/resources/assets/computercraft/textures/*
+  projects/common/src/main/resources/pack.mcmeta
+  projects/common/src/main/resources/pack.png
+  projects/core/src/main/resources/assets/computercraft/textures/gui/term_font.png
+  projects/core/src/main/resources/data/computercraft/lua/rom/autorun/.ignoreme
+  projects/core/src/main/resources/data/computercraft/lua/rom/help/*
+  projects/core/src/main/resources/data/computercraft/lua/rom/programs/fun/advanced/levels/*
+  projects/web/src/htmlTransform/export/items/computercraft/*
+Comment: Bulk-license original assets as CCPL.
+Copyright: 2011 Daniel Ratcliffe
+License: LicenseRef-CCPL
+
+Files:
+  projects/common/src/main/resources/assets/computercraft/lang/cs_cz.json
+  projects/common/src/main/resources/assets/computercraft/lang/ko_kr.json
+  projects/common/src/main/resources/assets/computercraft/lang/pl_pl.json
+  projects/common/src/main/resources/assets/computercraft/lang/pt_br.json
+  projects/common/src/main/resources/assets/computercraft/lang/ru_ru.json
+  projects/common/src/main/resources/assets/computercraft/lang/uk_ua.json
+  projects/common/src/main/resources/assets/computercraft/lang/zh_cn.json
+Comment: Community-contributed license files
+Copyright: 2017 The CC: Tweaked Developers
+License: LicenseRef-CCPL
+
+Files:
+  projects/common/src/main/resources/assets/computercraft/lang/*
+Comment: Community-contributed license files
+Copyright: 2017 The CC: Tweaked Developers
+License: MPL-2.0
+
+Files:
+  .github/*
+Comment:
+  GitHub build scripts are CC0. While we could add a header to each file,
+  it's unclear if it will break actions or issue templates in some way.
+Copyright: Jonathan Coates <git@squiddev.cc>
+License: CC0-1.0
+
+Files:
+  gradle/wrapper/*
+  gradlew
+  gradlew.bat
+Copyright: Gradle Inc
+License: Apache-2.0
+
+Files: projects/core/src/test/resources/test-rom/data/json-parsing/*
+Copyright: 2016 Nicolas Seriot
+License: MIT
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -22,15 +22,16 @@ If you have a bug, suggestion, or other feedback, the best thing to do is [file
 use the issue templates - they provide a useful hint on what information to provide.

 ## Translations
-Translations are managed through [CrowdIn], an online interface for managing language strings.
+Translations are managed through [Weblate], an online interface for managing language strings. This is synced
+automatically with GitHub, so please don't submit PRs adding/changing translations!

 ## Setting up a development environment
 In order to develop CC: Tweaked, you'll need to download the source code and then run it.

 - Make sure you've got the following software installed:
-   - Java Development Kit 17 (JDK). This can be downloaded from [Adoptium].
+   - Java Development Kit (JDK). This can be downloaded from [Adoptium].
   - [Git](https://git-scm.com/).
-   - [NodeJS 20 or later][node].
+   - [NodeJS][node].

 - Download CC: Tweaked's source code:
   ```
@@ -48,12 +49,9 @@ If you want to run CC:T in a normal Minecraft instance, run `./gradlew assemble`
 `projects/forge/build/libs` (for Forge) or `projects/fabric/build/libs` (for Fabric).

 ## Developing CC: Tweaked
-Before making any major changes to CC: Tweaked, I'd recommend starting opening an issue or starting a discussion on
-GitHub first. It's often helpful to discuss features before spending time developing them!
-
-Once you're ready to start programming, have a read of the [the architecture document][architecture] first. While it's
-not a comprehensive document, it gives a good hint of where you should start looking to make your changes. As always, if
-you're not sure, [do ask the community][community]!
+Before making any major changes to CC: Tweaked, I'd recommend you have a read of the [the architecture
+document][architecture] first. While it's not a comprehensive document, it gives a good hint of where you should start
+looking to make your changes. As always, if you're not sure, [do ask the community][community]!

 ### Testing
 When making larger changes, it may be useful to write a test to make sure your code works as expected.
@@ -88,8 +86,8 @@ You'll first need to [set up a development environment as above](#setting-up-a-d

 Once this is set up, you can now run `./gradlew docWebsite`. This generates documentation from our Lua and Java code,
 writing the resulting HTML into `./projects/web/build/site`, which can then be opened in a browser. When iterating on
-documentation, you can instead run `./gradlew :web:assemble -x :web:compileTeaVM -t`, which will rebuild documentation
-every time you change a file.
+documentation, you can instead run `./gradlew docWebsite -t`, which will rebuild documentation every time you change a
+file.

 Documentation is built using [illuaminate] which, while not currently documented (somewhat ironic), is largely the same
 as [ldoc][ldoc]. Documentation comments are written in Markdown, though note that we do not support many GitHub-specific
@@ -103,10 +101,10 @@ about how you can build on that until you've covered everything!
 [community]: README.md#community "Get in touch with the community."
 [Adoptium]: https://adoptium.net/temurin/releases?version=17 "Download OpenJDK 17"
 [illuaminate]: https://github.com/SquidDev/illuaminate/ "Illuaminate on GitHub"
+[weblate]: https://i18n.tweaked.cc/projects/cc-tweaked/minecraft/ "CC: Tweaked weblate instance"
 [docs]: https://tweaked.cc/ "CC: Tweaked documentation"
 [ldoc]: http://stevedonovan.github.io/ldoc/ "ldoc, a Lua documentation generator."
 [mc-test]: https://www.youtube.com/watch?v=vXaWOJTCYNg
 [busted]: https://github.com/Olivine-Labs/busted "busted: Elegant Lua unit testing."
 [node]: https://nodejs.org/en/ "Node.js"
 [architecture]: projects/ARCHITECTURE.md
-[Crowdin]: https://crowdin.com/project/cc-tweaked/
--- a/README.md
+++ b/README.md
@@ -11,13 +11,14 @@ SPDX-License-Identifier: MPL-2.0
 </picture>

 [![Current build status](https://github.com/cc-tweaked/CC-Tweaked/workflows/Build/badge.svg)](https://github.com/cc-tweaked/CC-Tweaked/actions "Current build status")
+[![Download CC: Tweaked on CurseForge](https://img.shields.io/static/v1?label=Download&message=CC:%20Tweaked&color=E04E14&logoColor=E04E14&logo=CurseForge)][CurseForge]
 [![Download CC: Tweaked on Modrinth](https://img.shields.io/static/v1?label=Download&color=00AF5C&logoColor=00AF5C&logo=Modrinth&message=CC:%20Tweaked)][Modrinth]

 CC: Tweaked is a mod for Minecraft which adds programmable computers, turtles and more to the game. A fork of the
 much-beloved [ComputerCraft], it continues its legacy with improved performance and stability, along with a wealth of
 new features.

-CC: Tweaked can be installed from [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
+CC: Tweaked can be installed from [CurseForge] or [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].

 ## Contributing
 Any contribution is welcome, be that using the mod, reporting bugs or contributing code. If you want to get started
@@ -25,9 +26,8 @@ developing the mod, [check out the instructions here](CONTRIBUTING.md#developing

 ## Community
 If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
-ComputerCraft, do check out our [GitHub discussions page][GitHub discussions]! There's also a fairly populated,
-albeit quiet IRC channel on [EsperNet], if that's more your cup of tea. You can join `#computercraft` through your
-desktop client, or online using [KiwiIRC].
+ComputerCraft, do check out our [forum] and [GitHub discussions page][GitHub discussions]! There's also a fairly
+populated, albeit quiet [IRC channel][irc], if that's more your cup of tea.

 We also host fairly comprehensive documentation at [tweaked.cc](https://tweaked.cc/ "The CC: Tweaked website").

@@ -51,9 +51,8 @@ dependencies {
  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-common-api:$cctVersion")

  // Forge Gradle
-  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-core-api:$cctVersion")
-  compileOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$cctVersion"))
-  runtimeOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge:$cctVersion"))
+  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$cctVersion")
+  runtimeOnly("cc.tweaked:cc-tweaked-$mcVersion-forge:$cctVersion")

  // Fabric Loom
  modCompileOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric-api:$cctVersion")
@@ -61,6 +60,19 @@ dependencies {
 }
 ```

+When using ForgeGradle, you may also need to add the following:
+
+```groovy
+minecraft {
+    runs {
+        configureEach {
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg"
+        }
+    }
+}
+```
+
 You should also be careful to only use classes within the `dan200.computercraft.api` package. Non-API classes are
 subject to change at any point. If you depend on functionality outside the API (or need to mixin to CC:T), please file
 an issue to let me know!
@@ -69,9 +81,10 @@ We bundle the API sources with the jar, so documentation should be easily viewab
 the generated documentation [can be browsed online](https://tweaked.cc/javadoc/).

 [computercraft]: https://github.com/dan200/ComputerCraft "ComputerCraft on GitHub"
+[curseforge]: https://minecraft.curseforge.com/projects/cc-tweaked "Download CC: Tweaked from CurseForge"
 [modrinth]: https://modrinth.com/mod/gu7yAYhd "Download CC: Tweaked from Modrinth"
 [Minecraft Forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
 [Fabric]: https://fabricmc.net/use/installer/ "Download Fabric."
+[forum]: https://forums.computercraft.cc/
 [GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[EsperNet]: https://www.esper.net/
-[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#computercraft "#computercraft on EsperNet"
+[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
--- a/REUSE.toml
+++ b/REUSE.toml
@@ -1,100 +0,0 @@
-# SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: MPL-2.0
-
-version = 1
-SPDX-PackageName = "CC: Tweaked"
-SPDX-PackageSupplier = "Jonathan Coates <git@squiddev.cc>"
-SPDX-PackageDownloadLocation = "https://github.com/cc-tweaked/cc-tweaked"
-
-[[annotations]]
-SPDX-FileCopyrightText = "The CC: Tweaked Developers"
-SPDX-License-Identifier = "CC0-1.0"
-path = [
-    # Generated/data files are CC0.
-    "gradle/gradle-daemon-jvm.properties",
-    "projects/common/src/main/resources/assets/computercraft/sounds.json",
-    "projects/common/src/main/resources/assets/computercraft/sounds/empty.ogg",
-    "projects/common/src/testMod/resources/data/cctest/computercraft/turtle_upgrades/**",
-    "projects/common/src/testMod/resources/data/cctest/structures/**",
-    "projects/*/src/generated/**",
-    "projects/web/src/htmlTransform/export/index.json",
-    "projects/web/src/htmlTransform/export/items/minecraft/**",
-    # GitHub build scripts are CC0. While we could add a header to each file,
-    # it's unclear if it will break actions or issue templates in some way.
-    ".github/**",
-    # Example mod is CC0.
-    "projects/*/src/examples/**"
-]
-
-[[annotations]]
-# Several assets where it's inconvenient to create a .license file.
-SPDX-FileCopyrightText = "The CC: Tweaked Developers"
-SPDX-License-Identifier = "MPL-2.0"
-path = [
-    "doc/images/**",
-    "package.json",
-    "package-lock.json",
-    "projects/*/src/*/resources/*.mixins.json",
-    "projects/fabric/src/*/resources/fabric.mod.json",
-    "projects/common/src/main/resources/assets/minecraft/shaders/core/computercraft/monitor_tbo.json",
-    "projects/common/src/testMod/resources/data/computercraft/loot_tables/treasure_disk.json",
-    "projects/common/src/testMod/resources/pack.mcmeta",
-    "projects/core/src/main/resources/data/computercraft/lua/rom/modules/command/.ignoreme",
-    "projects/core/src/main/resources/data/computercraft/lua/rom/modules/main/.ignoreme",
-    "projects/core/src/main/resources/data/computercraft/lua/rom/modules/turtle/.ignoreme",
-    "projects/core/src/main/resources/data/computercraft/lua/rom/motd.txt",
-    "projects/web/src/frontend/mount/.settings",
-    "projects/web/src/frontend/mount/example.nfp",
-    "projects/web/src/frontend/mount/example.nft",
-    "projects/web/src/frontend/mount/expr_template.lua",
-    "projects/web/tsconfig.json",
-]
-
-[[annotations]]
-# Bulk-license original assets as CCPL.
-SPDX-FileCopyrightText = "2011 Daniel Ratcliffe"
-SPDX-License-Identifier = "LicenseRef-CCPL"
-path = [
-    "doc/logo.png",
-    "doc/logo-darkmode.png",
-    "projects/common/src/main/resources/assets/computercraft/models/**",
-    "projects/common/src/main/resources/assets/computercraft/textures/**",
-    "projects/common/src/main/resources/pack.mcmeta",
-    "projects/common/src/main/resources/pack.png",
-    "projects/core/src/main/resources/assets/computercraft/textures/gui/term_font.png",
-    "projects/core/src/main/resources/data/computercraft/lua/rom/autorun/.ignoreme",
-    "projects/core/src/main/resources/data/computercraft/lua/rom/help/**",
-    "projects/core/src/main/resources/data/computercraft/lua/rom/programs/fun/advanced/levels/**",
-    "projects/web/src/htmlTransform/export/items/computercraft/**",
-]
-
-[[annotations]]
-# Community-contributed language files
-SPDX-FileCopyrightText = "2017 The CC: Tweaked Developers"
-SPDX-License-Identifier = "LicenseRef-CCPL"
-path = [
-    "projects/common/src/main/resources/assets/computercraft/lang/cs_cz.json",
-    "projects/common/src/main/resources/assets/computercraft/lang/ko_kr.json",
-    "projects/common/src/main/resources/assets/computercraft/lang/pl_pl.json",
-    "projects/common/src/main/resources/assets/computercraft/lang/pt_br.json",
-    "projects/common/src/main/resources/assets/computercraft/lang/ru_ru.json",
-    "projects/common/src/main/resources/assets/computercraft/lang/uk_ua.json",
-    "projects/common/src/main/resources/assets/computercraft/lang/zh_cn.json",
-]
-
-[[annotations]]
-# Community-contributed language files
-SPDX-FileCopyrightText = "2017 The CC: Tweaked Developers"
-SPDX-License-Identifier = "MPL-2.0"
-path = "projects/common/src/main/resources/assets/computercraft/lang/**"
-
-[[annotations]]
-path = ["gradle/wrapper/**"]
-SPDX-FileCopyrightText = "Gradle Inc"
-SPDX-License-Identifier = "Apache-2.0"
-
-[[annotations]]
-path = "projects/core/src/test/resources/test-rom/data/json-parsing/**"
-SPDX-FileCopyrightText = "2016 Nicolas Seriot"
-SPDX-License-Identifier = "MIT"
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -24,19 +24,21 @@ val mcVersion: String by extra

 githubRelease {
    token(findProperty("githubApiKey") as String? ?: "")
-    owner = "cc-tweaked"
-    repo = "CC-Tweaked"
-    targetCommitish = cct.gitBranch
+    owner.set("cc-tweaked")
+    repo.set("CC-Tweaked")
+    targetCommitish.set(cct.gitBranch)

-    tagName = "v$mcVersion-$modVersion"
-    releaseName = "[$mcVersion] $modVersion"
-    body = provider {
-        "## " + project(":core").file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
-            .readLines()
-            .takeWhile { it != "Type \"help changelog\" to see the full version history." }
-            .joinToString("\n").trim()
-    }
-    prerelease = isUnstable
+    tagName.set("v$mcVersion-$modVersion")
+    releaseName.set("[$mcVersion] $modVersion")
+    body.set(
+        provider {
+            "## " + project(":core").file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
+                .readLines()
+                .takeWhile { it != "Type \"help changelog\" to see the full version history." }
+                .joinToString("\n").trim()
+        },
+    )
+    prerelease.set(isUnstable)
 }

 tasks.publish { dependsOn(tasks.githubRelease) }
@@ -116,7 +118,7 @@ idea.project.settings.compiler.javac {
 }

 versionCatalogUpdate {
-    sortByKey = false
+    sortByKey.set(false)
    pin { versions.addAll("fastutil", "guava", "netty", "slf4j") }
-    keep { keepUnusedLibraries = true }
+    keep { keepUnusedLibraries.set(true) }
 }
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@@ -14,10 +14,14 @@ repositories {
    mavenCentral()
    gradlePluginPortal()

-    maven("https://maven.neoforged.net") {
+    maven("https://maven.neoforged.net/releases") {
        name = "NeoForge"
        content {
+            includeGroup("net.minecraftforge")
            includeGroup("net.neoforged")
+            includeGroup("net.neoforged.gradle")
+            includeModule("codechicken", "DiffPatch")
+            includeModule("net.covers1624", "Quack")
        }
    }

@@ -41,10 +45,11 @@ dependencies {
    implementation(libs.kotlin.plugin)
    implementation(libs.spotless)

+    implementation(libs.curseForgeGradle)
    implementation(libs.fabric.loom)
    implementation(libs.ideaExt)
    implementation(libs.minotaur)
-    implementation(libs.modDevGradle)
+    implementation(libs.neoGradle.userdev)
    implementation(libs.vanillaExtract)
 }

@@ -68,7 +73,7 @@ gradlePlugin {
 }

 versionCatalogUpdate {
-    sortByKey = false
-    keep { keepUnusedLibraries = true }
-    catalogFile = file("../gradle/libs.versions.toml")
+    sortByKey.set(false)
+    keep { keepUnusedLibraries.set(true) }
+    catalogFile.set(file("../gradle/libs.versions.toml"))
 }
--- a/buildSrc/src/main/kotlin/cc-tweaked.fabric.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.fabric.gradle.kts
@@ -30,7 +30,7 @@ repositories {

 loom {
    splitEnvironmentSourceSets()
-    splitModDependencies = true
+    splitModDependencies.set(true)
 }

 MinecraftConfigurations.setup(project)
--- a/buildSrc/src/main/kotlin/cc-tweaked.forge.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.forge.gradle.kts
@@ -6,22 +6,25 @@

 import cc.tweaked.gradle.CCTweakedExtension
 import cc.tweaked.gradle.CCTweakedPlugin
+import cc.tweaked.gradle.IdeaRunConfigurations
 import cc.tweaked.gradle.MinecraftConfigurations

 plugins {
    id("cc-tweaked.java-convention")
-    id("net.neoforged.moddev.legacyforge")
+    id("net.neoforged.gradle.userdev")
 }

 plugins.apply(CCTweakedPlugin::class.java)

 val mcVersion: String by extra

-legacyForge {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    version = "$mcVersion-${libs.findVersion("forge").get()}"
+minecraft {
+    modIdentifier("computercraft")
+}

+subsystems {
    parchment {
+        val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
        minecraftVersion = libs.findVersion("parchmentMc").get().toString()
        mappingsVersion = libs.findVersion("parchment").get().toString()
    }
--- a/buildSrc/src/main/kotlin/cc-tweaked.gametest.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.gametest.gradle.kts
@@ -2,34 +2,44 @@
 //
 // SPDX-License-Identifier: MPL-2.0

+import cc.tweaked.gradle.clientClasses
+import cc.tweaked.gradle.commonClasses
+
 /**
 * Sets up the configurations for writing game tests.
 *
 * See notes in [cc.tweaked.gradle.MinecraftConfigurations] for the general design behind these cursed ideas.
 */

-import cc.tweaked.gradle.MinecraftConfigurations
-import cc.tweaked.gradle.clientClasses
-import cc.tweaked.gradle.commonClasses
-
 plugins {
-    kotlin("jvm")
+    id("cc-tweaked.kotlin-convention")
    id("cc-tweaked.java-convention")
 }

 val main = sourceSets["main"]
 val client = sourceSets["client"]

-MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.DATAGEN)
-MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.EXAMPLES)
-MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.TEST_MOD)
+// Both testMod and testFixtures inherit from the main and client classpath, just so we have access to Minecraft classes.
+val testMod by sourceSets.creating {
+    compileClasspath += main.compileClasspath + client.compileClasspath
+    runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
+}

-// Set up generated resources
-sourceSets.main { resources.srcDir("src/generated/resources") }
-sourceSets.named("examples") { resources.srcDir("src/examples/generatedResources") }
+configurations {
+    named(testMod.compileClasspathConfigurationName) {
+        shouldResolveConsistentlyWith(compileClasspath.get())
+    }

-// Make sure our examples compile.
-tasks.check { dependsOn(tasks.named("compileExamplesJava")) }
+    named(testMod.runtimeClasspathConfigurationName) {
+        shouldResolveConsistentlyWith(runtimeClasspath.get())
+    }
+}
+
+// Like the main test configurations, we're safe to depend on source set outputs.
+dependencies {
+    add(testMod.implementationConfigurationName, main.output)
+    add(testMod.implementationConfigurationName, client.output)
+}

 // Similar to java-test-fixtures, but tries to avoid putting the obfuscated jar on the classpath.

--- a/buildSrc/src/main/kotlin/cc-tweaked.java-convention.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.java-convention.gradle.kts
@@ -29,7 +29,7 @@ base.archivesName.convention("cc-tweaked-$mcVersion-${project.name}")

 java {
    toolchain {
-        languageVersion = CCTweakedPlugin.JAVA_VERSION
+        languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
    }

    withSourcesJar()
@@ -47,7 +47,6 @@ repositories {
        filter {
            includeGroup("cc.tweaked")
            // Things we mirror
-            includeGroup("com.simibubi.create")
            includeGroup("commoble.morered")
            includeGroup("dev.architectury")
            includeGroup("dev.emi")
@@ -57,7 +56,6 @@ repositories {
            includeGroup("mezz.jei")
            includeGroup("org.teavm")
            includeModule("com.terraformersmc", "modmenu")
-            includeModule("me.lucko", "fabric-permissions-api")
        }
    }
 }
@@ -79,20 +77,27 @@ dependencies {
 // Configure default JavaCompile tasks with our arguments.
 sourceSets.all {
    tasks.named(compileJavaTaskName, JavaCompile::class.java) {
-        // Processing just gives us "No processor claimed any of these annotations", so skip that!
-        options.compilerArgs.addAll(listOf("-Xlint", "-Xlint:-processing"))
+
+        options.compilerArgs.addAll(
+            listOf(
+                "-Xlint",
+                // Processing just gives us "No processor claimed any of these annotations", so skip that!
+                "-Xlint:-processing",
+                // We violate this pattern too often for it to be a helpful warning. Something to improve one day!
+                "-Xlint:-this-escape",
+            ),
+        )

        options.errorprone {
            check("InvalidBlockTag", CheckSeverity.OFF) // Broken by @cc.xyz
+            check("InvalidParam", CheckSeverity.OFF) // Broken by records.
            check("InlineMeSuggester", CheckSeverity.OFF) // Minecraft uses @Deprecated liberally
            // Too many false positives right now. Maybe we need an indirection for it later on.
-            check("AssignmentExpression", CheckSeverity.OFF) // I'm a bad person.
            check("ReferenceEquality", CheckSeverity.OFF)
            check("EnumOrdinal", CheckSeverity.OFF) // For now. We could replace most of these with EnumMap.
            check("OperatorPrecedence", CheckSeverity.OFF) // For now.
            check("NonOverridingEquals", CheckSeverity.OFF) // Peripheral.equals makes this hard to avoid
            check("FutureReturnValueIgnored", CheckSeverity.OFF) // Too many false positives with Netty
-            check("InvalidInlineTag", CheckSeverity.OFF) // Triggered by @snippet. Can be removed on Java 21.

            check("NullAway", CheckSeverity.ERROR)
            option(
@@ -115,6 +120,7 @@ tasks.compileTestJava {
    }
 }

+
 tasks.withType(JavaCompile::class.java).configureEach {
    options.encoding = "UTF-8"
 }
@@ -148,7 +154,7 @@ tasks.javadoc {
    options {
        val stdOptions = this as StandardJavadocDocletOptions
        stdOptions.addBooleanOption("Xdoclint:all,-missing", true)
-        stdOptions.links("https://docs.oracle.com/en/java/javase/17/docs/api/")
+        stdOptions.links("https://docs.oracle.com/en/java/javase/21/docs/api/")
    }
 }

@@ -162,8 +168,8 @@ tasks.test {
 }

 tasks.withType(JacocoReport::class.java).configureEach {
-    reports.xml.required = true
-    reports.html.required = true
+    reports.xml.required.set(true)
+    reports.html.required.set(true)
 }

 project.plugins.withType(CCTweakedPlugin::class.java) {
@@ -187,23 +193,30 @@ spotless {
    fun FormatExtension.defaults() {
        endWithNewline()
        trimTrailingWhitespace()
-        leadingTabsToSpaces(4)
+        indentWithSpaces(4)
    }

    java {
        defaults()
-        importOrder("", "javax|java", "\\#")
        removeUnusedImports()
    }

+    val ktlintConfig = mapOf(
+        "ktlint_standard_no-wildcard-imports" to "disabled",
+        "ktlint_standard_class-naming" to "disabled",
+        "ktlint_standard_function-naming" to "disabled",
+        "ij_kotlin_allow_trailing_comma" to "true",
+        "ij_kotlin_allow_trailing_comma_on_call_site" to "true",
+    )
+
    kotlinGradle {
        defaults()
-        ktlint()
+        ktlint().editorConfigOverride(ktlintConfig)
    }

    kotlin {
        defaults()
-        ktlint()
+        ktlint().editorConfigOverride(ktlintConfig)
    }
 }

@@ -212,5 +225,6 @@ idea.module {

    // Force Gradle to write to inherit the output directory from the parent, instead of writing to out/xxx/classes.
    // This is required for Loom, and we patch Forge's run configurations to work there.
+    // TODO: Submit a patch to Forge to support ProjectRootManager.
    inheritOutputDirs = true
 }
--- a/buildSrc/src/main/kotlin/cc-tweaked.kotlin-convention.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.kotlin-convention.gradle.kts
@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+import cc.tweaked.gradle.CCTweakedPlugin
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    kotlin("jvm")
+}
+
+kotlin {
+    jvmToolchain {
+        languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
+    }
+}
+
+tasks.withType(KotlinCompile::class.java).configureEach {
+    // So technically we shouldn't need to do this as the toolchain sets it above. However, the option only appears
+    // to be set when the task executes, so doesn't get picked up by IDEs.
+    kotlinOptions.jvmTarget = when {
+        CCTweakedPlugin.JAVA_VERSION.asInt() > 8 -> CCTweakedPlugin.JAVA_VERSION.toString()
+        else -> "1.${CCTweakedPlugin.JAVA_VERSION.asInt()}"
+    }
+}
--- a/buildSrc/src/main/kotlin/cc-tweaked.mod-publishing.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.mod-publishing.gradle.kts
@@ -2,9 +2,11 @@
 //
 // SPDX-License-Identifier: MPL-2.0

+import net.darkhax.curseforgegradle.TaskPublishCurseForge
 import cc.tweaked.gradle.setProvider

 plugins {
+    id("net.darkhax.curseforgegradle")
    id("com.modrinth.minotaur")
    id("cc-tweaked.publishing")
 }
@@ -23,17 +25,34 @@ val isUnstable = project.properties["isUnstable"] == "true"
 val modVersion: String by extra
 val mcVersion: String by extra

+val publishCurseForge by tasks.registering(TaskPublishCurseForge::class) {
+    group = PublishingPlugin.PUBLISH_TASK_GROUP
+    description = "Upload artifacts to CurseForge"
+
+    apiToken = findProperty("curseForgeApiKey") ?: ""
+    enabled = apiToken != ""
+
+    val mainFile = upload("282001", modPublishing.output)
+    mainFile.changelog =
+        "Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion)."
+    mainFile.changelogType = "markdown"
+    mainFile.releaseType = if (isUnstable) "alpha" else "release"
+    mainFile.gameVersions.add(mcVersion)
+}
+
+tasks.publish { dependsOn(publishCurseForge) }
+
 modrinth {
-    token = findProperty("modrinthApiKey") as String? ?: ""
-    projectId = "gu7yAYhd"
-    versionNumber = modVersion
-    versionName = modVersion
-    versionType = if (isUnstable) "alpha" else "release"
+    token.set(findProperty("modrinthApiKey") as String? ?: "")
+    projectId.set("gu7yAYhd")
+    versionNumber.set(modVersion)
+    versionName.set(modVersion)
+    versionType.set(if (isUnstable) "alpha" else "release")
    uploadFile.setProvider(modPublishing.output)
    gameVersions.add(mcVersion)
-    changelog = "Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion)."
+    changelog.set("Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion).")

-    syncBodyFrom = provider { rootProject.file("doc/mod-page.md").readText() }
+    syncBodyFrom.set(provider { rootProject.file("doc/mod-page.md").readText() })
 }

 tasks.publish { dependsOn(tasks.modrinth) }
--- a/buildSrc/src/main/kotlin/cc-tweaked.publishing.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.publishing.gradle.kts
@@ -12,26 +12,25 @@ publishing {
        register<MavenPublication>("maven") {
            artifactId = base.archivesName.get()
            from(components["java"])
-            suppressAllPomMetadataWarnings()

            pom {
-                name = "CC: Tweaked"
-                description = "CC: Tweaked is a fork of ComputerCraft, adding programmable computers, turtles and more to Minecraft."
-                url = "https://github.com/cc-tweaked/CC-Tweaked"
+                name.set("CC: Tweaked")
+                description.set("CC: Tweaked is a fork of ComputerCraft, adding programmable computers, turtles and more to Minecraft.")
+                url.set("https://github.com/cc-tweaked/CC-Tweaked")

                scm {
-                    url = "https://github.com/cc-tweaked/CC-Tweaked.git"
+                    url.set("https://github.com/cc-tweaked/CC-Tweaked.git")
                }

                issueManagement {
-                    system = "github"
-                    url = "https://github.com/cc-tweaked/CC-Tweaked/issues"
+                    system.set("github")
+                    url.set("https://github.com/cc-tweaked/CC-Tweaked/issues")
                }

                licenses {
                    license {
-                        name = "ComputerCraft Public License, Version 1.0"
-                        url = "https://github.com/cc-tweaked/CC-Tweaked/blob/HEAD/LICENSE"
+                        name.set("ComputerCraft Public License, Version 1.0")
+                        url.set("https://github.com/cc-tweaked/CC-Tweaked/blob/HEAD/LICENSE")
                    }
                }
            }
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/CCTweakedExtension.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/CCTweakedExtension.kt
@@ -10,16 +10,23 @@ import org.gradle.api.GradleException
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.attributes.TestSuiteType
+import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Provider
 import org.gradle.api.provider.SetProperty
+import org.gradle.api.reporting.ReportingExtension
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.bundling.Jar
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.api.tasks.javadoc.Javadoc
+import org.gradle.configurationcache.extensions.capitalized
 import org.gradle.language.base.plugins.LifecycleBasePlugin
 import org.gradle.language.jvm.tasks.ProcessResources
 import org.gradle.process.JavaForkOptions
+import org.gradle.testing.jacoco.plugins.JacocoCoverageReport
 import org.gradle.testing.jacoco.plugins.JacocoPluginExtension
 import org.gradle.testing.jacoco.plugins.JacocoTaskExtension
 import org.gradle.testing.jacoco.tasks.JacocoReport
@@ -30,40 +37,54 @@ import java.io.IOException
 import java.net.URI
 import java.util.regex.Pattern

-abstract class CCTweakedExtension(private val project: Project) {
+abstract class CCTweakedExtension(
+    private val project: Project,
+    private val fs: FileSystemOperations,
+) {
    /** Get the hash of the latest git commit. */
-    val gitHash: Provider<String> =
-        gitProvider("<no git commit>", listOf("rev-parse", "HEAD")) { it.trim() }
+    val gitHash: Provider<String> = gitProvider(project, "<no git hash>") {
+        ProcessHelpers.captureOut("git", "-C", project.rootProject.projectDir.absolutePath, "rev-parse", "HEAD").trim()
+    }

    /** Get the current git branch. */
-    val gitBranch: Provider<String> =
-        gitProvider("<no git branch>", listOf("rev-parse", "--abbrev-ref", "HEAD")) { it.trim() }
+    val gitBranch: Provider<String> = gitProvider(project, "<no git branch>") {
+        ProcessHelpers.captureOut("git", "-C", project.rootProject.projectDir.absolutePath, "rev-parse", "--abbrev-ref", "HEAD")
+            .trim()
+    }

    /** Get a list of all contributors to the project. */
-    val gitContributors: Provider<List<String>> =
-        gitProvider(listOf(), listOf("shortlog", "-ns", "--group=author", "--group=trailer:co-authored-by", "HEAD")) { input ->
-            input.lineSequence()
-                .filter { it.isNotEmpty() }
-                .map {
-                    val matcher = COMMIT_COUNTS.matcher(it)
-                    matcher.find()
-                    matcher.group(1)
-                }
-                .filter { !IGNORED_USERS.contains(it) }
-                .toList()
-                .sortedWith(String.CASE_INSENSITIVE_ORDER)
-        }
+    val gitContributors: Provider<List<String>> = gitProvider(project, listOf()) {
+        ProcessHelpers.captureLines(
+            "git", "-C", project.rootProject.projectDir.absolutePath, "shortlog", "-ns",
+            "--group=author", "--group=trailer:co-authored-by", "HEAD",
+        )
+            .asSequence()
+            .map {
+                val matcher = COMMIT_COUNTS.matcher(it)
+                matcher.find()
+                matcher.group(1)
+            }
+            .filter { !IGNORED_USERS.contains(it) }
+            .toList()
+            .sortedWith(String.CASE_INSENSITIVE_ORDER)
+    }

    /**
     * References to other sources
     */
    val sourceDirectories: SetProperty<SourceSetReference> = project.objects.setProperty(SourceSetReference::class.java)

+    /**
+     * Dependencies excluded from published artifacts.
+     */
+    private val excludedDeps: ListProperty<Dependency> = project.objects.listProperty(Dependency::class.java)
+
    /** All source sets referenced by this project. */
    val sourceSets = sourceDirectories.map { x -> x.map { it.sourceSet } }

    init {
        sourceDirectories.finalizeValueOnRead()
+        excludedDeps.finalizeValueOnRead()
        project.afterEvaluate { sourceDirectories.disallowChanges() }
    }

@@ -89,13 +110,14 @@ abstract class CCTweakedExtension(private val project: Project) {
        val otherJava = otherProject.extensions.getByType(JavaPluginExtension::class.java)
        val main = otherJava.sourceSets.getByName("main")
        val client = otherJava.sourceSets.getByName("client")
+        val testMod = otherJava.sourceSets.findByName("testMod")
+        val testFixtures = otherJava.sourceSets.findByName("testFixtures")

        // Pull in sources from the other project.
        extendSourceSet(otherProject, main)
        extendSourceSet(otherProject, client)
-        for (sourceSet in listOf(MinecraftConfigurations.DATAGEN, MinecraftConfigurations.EXAMPLES, MinecraftConfigurations.TEST_MOD, "testFixtures")) {
-            otherJava.sourceSets.findByName(sourceSet)?.let { extendSourceSet(otherProject, it) }
-        }
+        if (testMod != null) extendSourceSet(otherProject, testMod)
+        if (testFixtures != null) extendSourceSet(otherProject, testFixtures)

        // The extra source-processing tasks should include these files too.
        project.tasks.named(main.javadocTaskName, Javadoc::class.java) { source(main.allJava, client.allJava) }
@@ -158,19 +180,23 @@ abstract class CCTweakedExtension(private val project: Project) {
    }

    fun <T> jacoco(task: NamedDomainObjectProvider<T>) where T : Task, T : JavaForkOptions {
-        val reportTaskName = "jacoco${task.name.capitalise()}Report"
+        val classDump = project.layout.buildDirectory.dir("jacocoClassDump/${task.name}")
+        val reportTaskName = "jacoco${task.name.capitalized()}Report"

        val jacoco = project.extensions.getByType(JacocoPluginExtension::class.java)
        task.configure {
            finalizedBy(reportTaskName)
-            jacoco.applyTo(this)

+            doFirst("Clean class dump directory") { fs.delete { delete(classDump) } }
+
+            jacoco.applyTo(this)
            extensions.configure(JacocoTaskExtension::class.java) {
                includes = listOf("dan200.computercraft.*")
-                excludes = listOf(
-                    "dan200.computercraft.mixin.*", // Exclude mixins, as they're not executed at runtime.
-                    "dan200.computercraft.shared.Capabilities$*", // Exclude capability tokens, as Forge rewrites them.
-                )
+                classDumpDir = classDump.get().asFile
+
+                // Older versions of modlauncher don't include a protection domain (and thus no code
+                // source). Jacoco skips such classes by default, so we need to explicitly include them.
+                isIncludeNoLocationClasses = true
            }
        }

@@ -179,11 +205,15 @@ abstract class CCTweakedExtension(private val project: Project) {
            description = "Generates code coverage report for the ${task.name} task."

            executionData(task.get())
+            classDirectories.from(classDump)

-            // Don't want to use sourceSets(...) here as we don't use all class directories.
-            for (ref in this@CCTweakedExtension.sourceDirectories.get()) {
-                sourceDirectories.from(ref.sourceSet.allSource.sourceDirectories)
-                if (ref.classes) classDirectories.from(ref.sourceSet.output)
+            // Don't want to use sourceSets(...) here as we have a custom class directory.
+            for (ref in sourceSets.get()) sourceDirectories.from(ref.allSource.sourceDirectories)
+        }
+
+        project.extensions.configure(ReportingExtension::class.java) {
+            reports.register("${task.name}CodeCoverageReport", JacocoCoverageReport::class.java) {
+                testType.set(TestSuiteType.INTEGRATION_TEST)
            }
        }
    }
@@ -223,31 +253,40 @@ abstract class CCTweakedExtension(private val project: Project) {
        ).resolve().single()
    }

-    private fun <T> gitProvider(default: T, command: List<String>, process: (String) -> T): Provider<T> {
-        val baseResult = project.providers.exec {
-            commandLine = listOf("git", "-C", project.rootDir.absolutePath) + command
-        }
+    /**
+     * Exclude a dependency from being published in Maven.
+     */
+    fun exclude(dep: Dependency) {
+        excludedDeps.add(dep)
+    }

-        return project.provider {
-            val res = try {
-                baseResult.standardOutput.asText.get()
-            } catch (e: IOException) {
-                project.logger.error("Cannot read Git repository: ${e.message}", e)
-                return@provider default
-            } catch (e: GradleException) {
-                project.logger.error("Cannot read Git repository: ${e.message}", e)
-                return@provider default
-            }
-            process(res)
-        }
+    /**
+     * Configure a [MavenDependencySpec].
+     */
+    fun configureExcludes(spec: MavenDependencySpec) {
+        for (dep in excludedDeps.get()) spec.exclude(dep)
    }

    companion object {
        private val COMMIT_COUNTS = Pattern.compile("""^\s*[0-9]+\s+(.*)$""")
        private val IGNORED_USERS = setOf(
-            "GitHub", "Daniel Ratcliffe", "NotSquidDev", "Weblate",
+            "GitHub", "Daniel Ratcliffe", "Weblate",
        )

+        private fun <T> gitProvider(project: Project, default: T, supplier: () -> T): Provider<T> {
+            return project.provider {
+                try {
+                    supplier()
+                } catch (e: IOException) {
+                    project.logger.error("Cannot read Git repository: ${e.message}")
+                    default
+                } catch (e: GradleException) {
+                    project.logger.error("Cannot read Git repository: ${e.message}")
+                    default
+                }
+            }
+        }
+
        private val isIdeSync: Boolean
            get() = java.lang.Boolean.parseBoolean(System.getProperty("idea.sync.active", "false"))
    }
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/CCTweakedPlugin.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/CCTweakedPlugin.kt
@@ -42,6 +42,6 @@ class CCTweakedPlugin : Plugin<Project> {
    }

    companion object {
-        val JAVA_VERSION = JavaLanguageVersion.of(17)
+        val JAVA_VERSION = JavaLanguageVersion.of(21)
    }
 }
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/DependencyCheck.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/DependencyCheck.kt
@@ -22,19 +22,19 @@ import org.gradle.language.base.plugins.LifecycleBasePlugin

 abstract class DependencyCheck : DefaultTask() {
    @get:Input
-    protected abstract val dependencies: ListProperty<DependencyResult>
+    abstract val configuration: ListProperty<Configuration>

    /**
     * A mapping of module coordinates (`group:module`) to versions, overriding the requested version.
     */
    @get:Input
-    protected abstract val overrides: MapProperty<String, String>
+    abstract val overrides: MapProperty<String, String>

    init {
        description = "Check :core's dependencies are consistent with Minecraft's."
        group = LifecycleBasePlugin.VERIFICATION_GROUP

-        dependencies.finalizeValueOnRead()
+        configuration.finalizeValueOnRead()
        overrides.finalizeValueOnRead()
    }

@@ -45,19 +45,13 @@ abstract class DependencyCheck : DefaultTask() {
        overrides.putAll(project.provider { mutableMapOf(module.get().module.toString() to version) })
    }

-    /**
-     * Add a configuration to check.
-     */
-    fun configuration(configuration: Provider<Configuration>) {
-        // We can't store the Configuration in the cache, so store the resolved dependencies instead.
-        dependencies.addAll(configuration.map { it.incoming.resolutionResult.allDependencies })
-    }
-
    @TaskAction
    fun run() {
        var ok = true
-        for (configuration in dependencies.get()) {
-            if (!check(configuration)) ok = false
+        for (configuration in configuration.get()) {
+            configuration.incoming.resolutionResult.allDependencies {
+                if (!check(this@allDependencies)) ok = false
+            }
        }

        if (!ok) {
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/ExecTasks.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/ExecTasks.kt
@@ -5,8 +5,10 @@
 package cc.tweaked.gradle

 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.AbstractExecTask
 import org.gradle.api.tasks.OutputDirectory
+import java.io.File

 abstract class ExecToDir : AbstractExecTask<ExecToDir>(ExecToDir::class.java) {
    @get:OutputDirectory
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/Extensions.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/Extensions.kt
@@ -9,6 +9,7 @@ import org.gradle.api.file.FileSystemLocation
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.JavaExec
+import org.gradle.kotlin.dsl.getByName
 import org.gradle.process.BaseExecSpec
 import org.gradle.process.JavaExecSpec
 import org.gradle.process.ProcessForkOptions
@@ -46,6 +47,21 @@ fun JavaExec.copyToFull(spec: JavaExec) {
    copyToExec(spec)
 }

+/**
+ * Base this [JavaExec] task on an existing task.
+ */
+fun JavaExec.copyFromTask(task: JavaExec) {
+    for (dep in task.dependsOn) dependsOn(dep)
+    task.copyToFull(this)
+}
+
+/**
+ * Base this [JavaExec] task on an existing task.
+ */
+fun JavaExec.copyFromTask(task: String) {
+    copyFromTask(project.tasks.getByName<JavaExec>(task))
+}
+
 /**
 * Copy additional [BaseExecSpec] options which aren't handled by [ProcessForkOptions.copyTo].
 */
@@ -143,7 +159,7 @@ fun getNextVersion(version: String): String {
    val lastIndex = mainVersion.lastIndexOf('.')
    if (lastIndex < 0) throw IllegalArgumentException("Cannot parse version format \"$version\"")
    val lastVersion = try {
-        mainVersion.substring(lastIndex + 1).toInt()
+        version.substring(lastIndex + 1).toInt()
    } catch (e: NumberFormatException) {
        throw IllegalArgumentException("Cannot parse version format \"$version\"", e)
    }
@@ -155,15 +171,3 @@ fun getNextVersion(version: String): String {
    if (dashIndex >= 0) out.append(version, dashIndex, version.length)
    return out.toString()
 }
-
-/**
- * Capitalise the first letter of the string.
- *
- * This is a replacement for the now deprecated [String.capitalize].
- */
-fun String.capitalise(): String {
-    if (isEmpty()) return this
-    val first = this[0]
-    val firstTitle = first.titlecaseChar()
-    return if (first == firstTitle) this else firstTitle + substring(1)
-}
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/IdeaRunConfigurations.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/IdeaRunConfigurations.kt
@@ -25,6 +25,7 @@ import javax.xml.xpath.XPathFactory
 * Would be good to PR some (or all) of these changes upstream at some point.
 *
 * @see net.fabricmc.loom.configuration.ide.idea.IdeaSyncTask
+ * @see net.minecraftforge.gradle.common.util.runs.IntellijRunGenerator
 */
 internal class IdeaRunConfigurations(project: Project) {
    private val rootProject = project.rootProject
@@ -34,6 +35,22 @@ internal class IdeaRunConfigurations(project: Project) {
    private val writer = TransformerFactory.newInstance().newTransformer()

    private val ideaDir = rootProject.file(".idea/")
+    private val buildDir: Lazy<String?> = lazy {
+        val ideaMisc = ideaDir.resolve("misc.xml")
+
+        try {
+            val doc = Files.newBufferedReader(ideaMisc.toPath()).use {
+                documentBuilder.parse(InputSource(it))
+            }
+            val node =
+                xpath.evaluate("//component[@name=\"ProjectRootManager\"]/output", doc, XPathConstants.NODE) as Node
+            val attr = node.attributes.getNamedItem("url") as Attr
+            attr.value.removePrefix("file://")
+        } catch (e: Exception) {
+            LOGGER.error("Failed to find root directory", e)
+            null
+        }
+    }

    fun patch() = synchronized(LOCK) {
        val runConfigDir = ideaDir.resolve("runConfigurations")
@@ -41,9 +58,10 @@ internal class IdeaRunConfigurations(project: Project) {

        Files.list(runConfigDir.toPath()).use {
            for (configuration in it) {
-                val filename = configuration.fileName.toString()
+                val filename = configuration.fileName.toString();
                when {
                    filename.endsWith("_fabric.xml") -> patchFabric(configuration)
+                    filename.startsWith("forge_") && filename.endsWith(".xml") -> patchForge(configuration)
                    else -> {}
                }
            }
@@ -54,6 +72,65 @@ internal class IdeaRunConfigurations(project: Project) {
        setXml("//configuration", "folderName") { "Fabric" }
    }

+    private fun patchForge(path: Path) = withXml(path) {
+        val configId = path.fileName.toString().removePrefix("forge_").removeSuffix(".xml")
+        val sourceSet = forgeConfigs[configId]
+        if (sourceSet == null) {
+            LOGGER.error("[{}] Cannot map run configuration to a known source set", path)
+            return@withXml
+        }
+
+        setXml("//configuration", "folderName") { "Forge" }
+        setXml("//configuration/module", "name") { "${rootProject.name}.forge.$sourceSet" }
+
+        if (buildDir.value == null) return@withXml
+        setXml("//configuration/envs/env[@name=\"MOD_CLASSES\"]", "value") { classpath ->
+            val classes = classpath!!.split(':')
+            val newClasses = mutableListOf<String>()
+            fun appendUnique(x: String) {
+                if (!newClasses.contains(x)) newClasses.add(x)
+            }
+
+            for (entry in classes) {
+                if (!entry.contains("/out/")) {
+                    appendUnique(entry)
+                    continue
+                }
+
+                val match = CLASSPATH_ENTRY.matchEntire(entry)
+                if (match != null) {
+                    val modId = match.groups["modId"]!!.value
+                    val proj = match.groups["proj"]!!.value
+                    var component = match.groups["component"]!!.value
+                    if (component == "production") component = "main"
+
+                    appendUnique(forgeModEntry(modId, proj, component))
+                } else {
+                    LOGGER.warn("[{}] Unknown classpath entry {}", path, entry)
+                    appendUnique(entry)
+                }
+            }
+
+            // Ensure common code is on the classpath
+            for (proj in listOf("common", "common-api")) {
+                for (component in listOf("main", "client")) {
+                    appendUnique(forgeModEntry("computercraft", proj, component))
+                }
+            }
+
+            if (newClasses.any { it.startsWith("cctest%%") }) {
+                appendUnique(forgeModEntry("cctest", "core", "testFixtures"))
+                appendUnique(forgeModEntry("cctest", "common", "testFixtures"))
+                appendUnique(forgeModEntry("cctest", "common", "testMod"))
+            }
+
+            newClasses.joinToString(":")
+        }
+    }
+
+    private fun forgeModEntry(mod: String, project: String, component: String) =
+        "$mod%%${buildDir.value}/production/${rootProject.name}.$project.$component"
+
    private fun LocatedDocument.setXml(xpath: String, attribute: String, value: (String?) -> String) {
        val node = this@IdeaRunConfigurations.xpath.evaluate(xpath, document, XPathConstants.NODE) as Node?
        if (node == null) {
@@ -82,5 +159,16 @@ internal class IdeaRunConfigurations(project: Project) {
    companion object {
        private val LOGGER = Logging.getLogger(IdeaRunConfigurations::class.java)
        private val LOCK = Any()
+
+        private val CLASSPATH_ENTRY =
+            Regex("(?<modId>[a-z]+)%%\\\$PROJECT_DIR\\\$/projects/(?<proj>[a-z-]+)/out/(?<component>\\w+)/(?<type>[a-z]+)\$")
+
+        private val forgeConfigs = mapOf(
+            "runClient" to "client",
+            "runData" to "main",
+            "runGameTestServer" to "testMod",
+            "runServer" to "main",
+            "runTestClient" to "testMod",
+        )
    }
 }
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/MavenDependencySpec.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/MavenDependencySpec.kt
@@ -0,0 +1,73 @@
+// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package cc.tweaked.gradle
+
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.MinimalExternalModuleDependency
+import org.gradle.api.artifacts.ProjectDependency
+import org.gradle.api.plugins.BasePluginExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.specs.Spec
+
+/**
+ * A dependency in a POM file.
+ */
+data class MavenDependency(val groupId: String?, val artifactId: String?, val version: String?, val scope: String?)
+
+/**
+ * A spec specifying which dependencies to include/exclude.
+ */
+class MavenDependencySpec {
+    private val excludeSpecs = mutableListOf<Spec<MavenDependency>>()
+
+    fun exclude(spec: Spec<MavenDependency>) {
+        excludeSpecs.add(spec)
+    }
+
+    fun exclude(dep: Dependency) {
+        exclude {
+            // We have to cheat a little for project dependencies, as the project name doesn't match the artifact group.
+            val name = when (dep) {
+                is ProjectDependency -> dep.dependencyProject.extensions.getByType(BasePluginExtension::class.java).archivesName.get()
+                else -> dep.name
+            }
+            (dep.group.isNullOrEmpty() || dep.group == it.groupId) &&
+                (name.isNullOrEmpty() || name == it.artifactId) &&
+                (dep.version.isNullOrEmpty() || dep.version == it.version)
+        }
+    }
+
+    fun exclude(dep: MinimalExternalModuleDependency) {
+        exclude {
+            dep.module.group == it.groupId && dep.module.name == it.artifactId
+        }
+    }
+
+    fun isIncluded(dep: MavenDependency) = !excludeSpecs.any { it.isSatisfiedBy(dep) }
+}
+
+/**
+ * Configure dependencies present in this publication's POM file.
+ *
+ * While this approach is very ugly, it's the easiest way to handle it!
+ */
+fun MavenPublication.mavenDependencies(action: MavenDependencySpec.() -> Unit) {
+    val spec = MavenDependencySpec()
+    action(spec)
+
+    pom.withXml {
+        val dependencies = XmlUtil.findChild(asNode(), "dependencies") ?: return@withXml
+        dependencies.children().map { it as groovy.util.Node }.forEach {
+            val dep = MavenDependency(
+                groupId = XmlUtil.findChild(it, "groupId")?.text(),
+                artifactId = XmlUtil.findChild(it, "artifactId")?.text(),
+                version = XmlUtil.findChild(it, "version")?.text(),
+                scope = XmlUtil.findChild(it, "scope")?.text(),
+            )
+
+            if (!spec.isIncluded(dep)) it.parent().remove(it)
+        }
+    }
+}
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/MinecraftConfigurations.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/MinecraftConfigurations.kt
@@ -24,6 +24,7 @@ class MinecraftConfigurations private constructor(private val project: Project)
    private val java = project.extensions.getByType(JavaPluginExtension::class.java)
    private val sourceSets = java.sourceSets
    private val configurations = project.configurations
+    private val objects = project.objects

    private val main = sourceSets[SourceSet.MAIN_SOURCE_SET_NAME]
    private val test = sourceSets[SourceSet.TEST_SOURCE_SET_NAME]
@@ -36,7 +37,13 @@ class MinecraftConfigurations private constructor(private val project: Project)
        val client = sourceSets.maybeCreate("client")

        // Ensure the client classpaths behave the same as the main ones.
-        consistentWithMain(client)
+        configurations.named(client.compileClasspathConfigurationName) {
+            shouldResolveConsistentlyWith(configurations[main.compileClasspathConfigurationName])
+        }
+
+        configurations.named(client.runtimeClasspathConfigurationName) {
+            shouldResolveConsistentlyWith(configurations[main.runtimeClasspathConfigurationName])
+        }

        // Set up an API configuration for clients (to ensure it's consistent with the main source set).
        val clientApi = configurations.maybeCreate(client.apiConfigurationName).apply {
@@ -78,16 +85,6 @@ class MinecraftConfigurations private constructor(private val project: Project)
        setupBasic()
    }

-    private fun consistentWithMain(sourceSet: SourceSet) {
-        configurations.named(sourceSet.compileClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.compileClasspathConfigurationName])
-        }
-
-        configurations.named(sourceSet.runtimeClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.runtimeClasspathConfigurationName])
-        }
-    }
-
    private fun setupBasic() {
        val client = sourceSets["client"]

@@ -99,30 +96,13 @@ class MinecraftConfigurations private constructor(private val project: Project)
        val checkDependencyConsistency =
            project.tasks.register("checkDependencyConsistency", DependencyCheck::class.java) {
                // We need to check both the main and client classpath *configurations*, as the actual configuration
-                configuration(configurations.named(main.runtimeClasspathConfigurationName))
-                configuration(configurations.named(client.runtimeClasspathConfigurationName))
+                configuration.add(configurations.named(main.runtimeClasspathConfigurationName))
+                configuration.add(configurations.named(client.runtimeClasspathConfigurationName))
            }
        project.tasks.named("check") { dependsOn(checkDependencyConsistency) }
    }

-    /**
-     * Create a new configuration that pulls in the main and client classes from the mod.
-     */
-    private fun createDerivedConfiguration(name: String) {
-        val client = sourceSets["client"]
-        val sourceSet = sourceSets.create(name)
-        sourceSet.compileClasspath += main.compileClasspath + client.compileClasspath
-        sourceSet.runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
-        consistentWithMain(sourceSet)
-        project.dependencies.add(sourceSet.implementationConfigurationName, main.output)
-        project.dependencies.add(sourceSet.implementationConfigurationName, client.output)
-    }
-
    companion object {
-        const val DATAGEN = "datagen"
-        const val EXAMPLES = "examples"
-        const val TEST_MOD = "testMod"
-
        fun setupBasic(project: Project) {
            MinecraftConfigurations(project).setupBasic()
        }
@@ -130,10 +110,6 @@ class MinecraftConfigurations private constructor(private val project: Project)
        fun setup(project: Project) {
            MinecraftConfigurations(project).setup()
        }
-
-        fun createDerivedConfiguration(project: Project, name: String) {
-            MinecraftConfigurations(project).createDerivedConfiguration(name)
-        }
    }
 }

--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/MinecraftExec.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/MinecraftExec.kt
@@ -4,7 +4,6 @@

 package cc.tweaked.gradle

-import net.neoforged.moddevgradle.internal.RunGameTask
 import org.gradle.api.GradleException
 import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.invocation.Gradle
@@ -65,22 +64,6 @@ abstract class ClientJavaExec : JavaExec() {
        setTestProperties()
    }

-    fun copyFromForge(path: String) = copyFromForge(project.tasks.getByName(path, RunGameTask::class))
-
-    /**
-     * Set this task to run a given [RunGameTask].
-     */
-    fun copyFromForge(task: RunGameTask) {
-        copyFrom(task)
-
-        // Eagerly evaluate the behaviour of RunGameTask.exec
-        environment.putAll(task.environmentProperty.get())
-        classpath(task.classpathProvider)
-        workingDir = task.gameDirectory.get().asFile
-
-        setTestProperties() // setRunConfig may clobber some properties, ensure everything is set.
-    }
-
    /**
     * Copy configuration from a task with the given name.
     */
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/Node.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/Node.kt
@@ -11,9 +11,7 @@ import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
-import org.gradle.process.ExecOperations
 import java.io.File
-import javax.inject.Inject

 class NodePlugin : Plugin<Project> {
    override fun apply(project: Project) {
@@ -45,12 +43,9 @@ abstract class NpmInstall : DefaultTask() {
    @get:OutputDirectory
    val nodeModules: Provider<Directory> = projectRoot.dir("node_modules")

-    @get:Inject
-    protected abstract val execOperations: ExecOperations
-
    @TaskAction
    fun install() {
-        execOperations.exec {
+        project.exec {
            commandLine(ProcessHelpers.getExecutable("npm"), "ci")
            workingDir = projectRoot.get().asFile
        }
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/ProcessHelpers.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/ProcessHelpers.kt
@@ -4,10 +4,45 @@

 package cc.tweaked.gradle

+import org.codehaus.groovy.runtime.ProcessGroovyMethods
 import org.gradle.api.GradleException
+import java.io.BufferedReader
 import java.io.File
+import java.io.InputStreamReader
+import java.nio.charset.StandardCharsets

 internal object ProcessHelpers {
+    fun startProcess(vararg command: String): Process {
+        // Something randomly passes in "GIT_DIR=" as an environment variable which clobbers everything else. Don't
+        // inherit the environment array!
+        return ProcessBuilder()
+            .command(*command)
+            .redirectError(ProcessBuilder.Redirect.INHERIT)
+            .also { it.environment().clear() }
+            .start()
+    }
+
+    fun captureOut(vararg command: String): String {
+        val process = startProcess(*command)
+        process.outputStream.close()
+
+        val result = ProcessGroovyMethods.getText(process)
+        process.waitForOrThrow("Failed to run command")
+        return result
+    }
+
+    fun captureLines(vararg command: String): List<String> {
+        val process = startProcess(*command)
+        process.outputStream.close()
+
+        val out = BufferedReader(InputStreamReader(process.inputStream, StandardCharsets.UTF_8)).use { reader ->
+            reader.lines().filter { it.isNotEmpty() }.toList()
+        }
+        ProcessGroovyMethods.closeStreams(process)
+        process.waitForOrThrow("Failed to run command")
+        return out
+    }
+
    fun onPath(name: String): Boolean {
        val path = System.getenv("PATH") ?: return false
        return path.splitToSequence(File.pathSeparator).any { File(it, name).exists() }
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/XmlUtil.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/XmlUtil.kt
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package cc.tweaked.gradle
+
+import groovy.util.Node
+import groovy.util.NodeList
+
+object XmlUtil {
+    fun findChild(node: Node, name: String): Node? = when (val child = node.get(name)) {
+        is Node -> child
+        is NodeList -> child.singleOrNull() as Node?
+        else -> null
+    }
+}
--- a/config/checkstyle/checkstyle.xml
+++ b/config/checkstyle/checkstyle.xml
@@ -92,10 +92,7 @@ SPDX-License-Identifier: MPL-2.0
        <module name="InvalidJavadocPosition" />
        <module name="JavadocBlockTagLocation" />
        <module name="JavadocMethod"/>
-        <module name="JavadocType">
-            <!-- Seems to complain about @hidden!? -->
-            <property name="allowUnknownTags" value="true" />
-        </module>
+        <module name="JavadocType"/>
        <module name="JavadocStyle">
            <property name="checkHtml" value="false" />
        </module>
@@ -127,7 +124,7 @@ SPDX-License-Identifier: MPL-2.0
        </module>
        <module name="MethodTypeParameterName" />
        <module name="PackageName">
-            <property name="format" value="^(dan200\.computercraft|cc\.tweaked|com\.example\.examplemod)(\.[a-z][a-z0-9]*)*" />
+            <property name="format" value="^(dan200\.computercraft|cc\.tweaked)(\.[a-z][a-z0-9]*)*" />
        </module>
        <module name="ParameterName" />
        <module name="StaticVariableName">
@@ -146,10 +143,7 @@ SPDX-License-Identifier: MPL-2.0
        <module name="NoWhitespaceAfter">
            <property name="tokens" value="AT,INC,DEC,UNARY_MINUS,UNARY_PLUS,BNOT,LNOT,DOT,ARRAY_DECLARATOR,INDEX_OP,METHOD_REF" />
        </module>
-        <module name="NoWhitespaceBefore">
-            <!-- Allow whitespace before "..." for @Nullable annotations -->
-            <property name="tokens" value="COMMA,SEMI,POST_INC,POST_DEC,LABELED_STAT" />
-        </module>
+        <module name="NoWhitespaceBefore" />
        <!-- TODO: Decide on an OperatorWrap style. -->
        <module name="ParenPad" />
        <module name="SeparatorWrap">
--- a/config/checkstyle/suppressions.xml
+++ b/config/checkstyle/suppressions.xml
@@ -22,4 +22,7 @@ SPDX-License-Identifier: MPL-2.0

    <!-- Allow underscores in our test classes. -->
    <suppress checks="MethodName" files=".*(Contract|Test).java" />
+
+    <!-- Allow underscores in Mixin classes -->
+    <suppress checks="TypeName" files=".*[\\/]mixin[\\/].*.java" />
 </suppressions>
--- a/crowdin.yml
+++ b/crowdin.yml
@@ -1,29 +0,0 @@
-# SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: MPL-2.0
-
-files:
-  - source: projects/common/src/generated/resources/assets/computercraft/lang/en_us.json
-    translation: /projects/common/src/main/resources/assets/computercraft/lang/%locale_with_underscore%.json
-    languages_mapping:
-      locale_with_underscore:
-        cs: cs_cz    # Czech
-        da: da_dk    # Danish
-        de: de_de    # German
-        es-ES: es_es # Spanish
-        fr: fr_fr    # French
-        hu: hu_hu    # Hungarian
-        it: it_it    # Italian
-        ja: ja_jp    # Japanese
-        ko: ko_kr    # Korean
-        nb: nb_no    # Norwegian Bokmal
-        nl: nl_nl    # Dutch
-        pl: pl_pl    # Polish
-        pt-BR: pt_br # Portuguese, Brazilian
-        ru: ru_ru    # Russian
-        sv-SE: sv_se # Sweedish
-        tok: tok     # Toki Pona
-        tr: tr_tr    # Turkish
-        uk: uk_ua    # Ukraine
-        vi: vi_vn    # Vietnamese
-        zh-CN: zh_cn # Chinese Simplified
--- a/doc/events/monitor_resize.md
+++ b/doc/events/monitor_resize.md
@@ -8,7 +8,7 @@ SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 SPDX-License-Identifier: MPL-2.0
 -->

-The [`monitor_resize`] event is fired when an adjacent or networked [monitor's][`monitor`] size is changed.
+The [`monitor_resize`] event is fired when an adjacent or networked monitor's size is changed.

 ## Return Values
 1. [`string`]: The event name.
--- a/doc/events/monitor_touch.md
+++ b/doc/events/monitor_touch.md
@@ -8,7 +8,7 @@ SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 SPDX-License-Identifier: MPL-2.0
 -->

-The [`monitor_touch`] event is fired when an adjacent or networked [Advanced Monitor][`monitor`] is right-clicked.
+The [`monitor_touch`] event is fired when an adjacent or networked Advanced Monitor is right-clicked.

 ## Return Values
 1. [`string`]: The event name.
--- a/doc/events/redstone.md
+++ b/doc/events/redstone.md
@@ -8,7 +8,7 @@ SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 SPDX-License-Identifier: MPL-2.0
 -->

-The [`event!redstone`] event is fired whenever any redstone inputs on the computer or [relay][`redstone_relay`] change.
+The [`event!redstone`] event is fired whenever any redstone inputs on the computer change.

 ## Return values
 1. [`string`]: The event name.
@@ -21,7 +21,3 @@ while true do
  print("A redstone input has changed!")
 end
 ```
-
-## See also
- - [The `redstone` API on computers][`module!redstone`]
- - [The `redstone_relay` peripheral][`redstone_relay`]
--- a/doc/guides/speaker_audio.md
+++ b/doc/guides/speaker_audio.md
@@ -191,7 +191,7 @@ end

 > [Confused?][!NOTE]
 > Don't worry if you don't understand this example. It's quite advanced, and does use some ideas that this guide doesn't
-> cover. That said, don't be afraid to ask [the community for help][community].
+> cover. That said, don't be afraid to ask on [GitHub Discussions] or [IRC] either!

 It's worth noting that the examples of audio processing we've mentioned here are about manipulating the _amplitude_ of
 the wave. If you wanted to modify the _frequency_ (for instance, shifting the pitch), things get rather more complex.
@@ -205,4 +205,5 @@ This is, I'm afraid, left as an exercise to the reader.
 [PCM]: https://en.wikipedia.org/wiki/Pulse-code_modulation "Pulse-code Modulation - Wikipedia"
 [Ring Buffer]: https://en.wikipedia.org/wiki/Circular_buffer "Circular buffer - Wikipedia"
 [Sine Wave]: https://en.wikipedia.org/wiki/Sine_wave "Sine wave - Wikipedia"
-[Community]: /#community
+[GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
+[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
--- a/doc/index.md
+++ b/doc/index.md
@@ -16,7 +16,7 @@ CC: Tweaked is a mod for Minecraft which adds programmable computers, turtles an
 much-beloved [ComputerCraft], it continues its legacy with improved performance and stability, along with a wealth of
 new features.

-CC: Tweaked can be installed from [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
+CC: Tweaked can be installed from [CurseForge] or [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].

 ## Features
 Controlled using the [Lua programming language][lua], CC: Tweaked's computers provides all the tools you need to start
@@ -50,11 +50,7 @@ little daunting getting started. Thankfully, there's several fantastic tutorials
 Once you're a little more familiar with the mod, the sidebar and links below provide more detailed documentation on the
 various APIs and peripherals provided by the mod.

-<h2 id="community">Community</h2>
-If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
-ComputerCraft, do check out our [GitHub discussions page][GitHub discussions]! There's also a fairly populated,
-albeit quiet IRC channel on [EsperNet], if that's more your cup of tea. You can join `#computercraft` through your
-desktop client, or online using [KiwiIRC].
+If you get stuck, do [ask a question on GitHub][GitHub Discussions] or pop in to the ComputerCraft's [IRC channel][IRC].

 ## Get Involved
 CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please do [create an issue][bug].
@@ -62,11 +58,11 @@ CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please
 [github]: https://github.com/cc-tweaked/CC-Tweaked/ "CC: Tweaked on GitHub"
 [bug]: https://github.com/cc-tweaked/CC-Tweaked/issues/new/choose
 [computercraft]: https://github.com/dan200/ComputerCraft "ComputerCraft on GitHub"
+[curseforge]: https://minecraft.curseforge.com/projects/cc-tweaked "Download CC: Tweaked from CurseForge"
 [modrinth]: https://modrinth.com/mod/gu7yAYhd "Download CC: Tweaked from Modrinth"
 [forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
 [Minecraft Forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
 [Fabric]: https://fabricmc.net/use/installer/ "Download Fabric."
 [lua]: https://www.lua.org/ "Lua's main website"
 [GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[EsperNet]: https://www.esper.net/
-[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#computercraft "#computercraft on EsperNet"
+[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
--- a/doc/mod-page.md
+++ b/doc/mod-page.md
@@ -50,11 +50,7 @@ little daunting getting started. Thankfully, there's several fantastic tutorials
 Once you're a little more familiar with the mod, the [wiki](https://tweaked.cc/) provides more detailed documentation on the
 various APIs and peripherals provided by the mod.

-## Community
-If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
-ComputerCraft, do check out our [GitHub discussions page][GitHub discussions]! There's also a fairly populated,
-albeit quiet IRC channel on [EsperNet], if that's more your cup of tea. You can join `#computercraft` through your
-desktop client, or online using [KiwiIRC].
+If you get stuck, do [ask a question on GitHub][GitHub Discussions] or pop in to the ComputerCraft's [IRC channel][IRC].

 ## Get Involved
 CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please do [create an issue][bug].
@@ -64,5 +60,4 @@ CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please
 [computercraft]: https://github.com/dan200/ComputerCraft "ComputerCraft on GitHub"
 [lua]: https://www.lua.org/ "Lua's main website"
 [GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[EsperNet]: https://www.esper.net/
-[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#computercraft "#computercraft on EsperNet"
+[IRC]: http://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
--- a/doc/reference/feature_compat.md
+++ b/doc/reference/feature_compat.md
@@ -81,7 +81,7 @@ compatibility for these newer versions.
 | `string.dump` strip argument                                                          | ✔          |                           |
 | `string.pack`/`string.unpack`/`string.packsize`                                       | ✔          |                           |
 | `table.move`                                                                          | ✔          |                           |
-| `math.atan2` -> `math.atan`                                                           | 🔶         | `math.atan` supports its two argument form. |
+| `math.atan2` -> `math.atan`                                                           | ❌         |                           |
 | Removed `math.frexp`, `math.ldexp`, `math.pow`, `math.cosh`, `math.sinh`, `math.tanh` | ❌         |                           |
 | `math.maxinteger`/`math.mininteger`                                                   | ❌         |                           |
 | `math.tointeger`                                                                      | ❌         |                           |
--- a/gradle.properties
+++ b/gradle.properties
@@ -8,9 +8,11 @@ org.gradle.parallel=true
 kotlin.stdlib.default.dependency=false
 kotlin.jvm.target.validation.mode=error

+neogradle.subsystems.conventions.runs.enabled=false
+
 # Mod properties
-isUnstable=false
-modVersion=1.116.1
+isUnstable=true
+modVersion=1.111.1

 # Minecraft properties: We want to configure this here so we can read it in settings.gradle
-mcVersion=1.20.1
+mcVersion=1.21
--- a/gradle/gradle-daemon-jvm.properties
+++ b/gradle/gradle-daemon-jvm.properties
@@ -1,2 +0,0 @@
-#This file is generated by updateDaemonJvm
-toolchainVersion=17
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -6,75 +6,73 @@

 # Minecraft
 # MC version is specified in gradle.properties, as we need that in settings.gradle.
-# Remember to update corresponding versions in fabric.mod.json/mods.toml
-fabric-api = "0.86.1+1.20.1"
-fabric-loader = "0.14.21"
-forge = "47.1.0"
-forgeSpi = "7.0.1"
+# Remember to update corresponding versions in fabric.mod.json/neoforge.mods.toml
+fabric-api = "0.100.3+1.21"
+fabric-loader = "0.15.11"
+neoForge = "21.0.42-beta"
+neoForgeSpi = "8.0.1"
 mixin = "0.8.5"
-parchment = "2023.08.20"
-parchmentMc = "1.20.1"
-yarn = "1.20.1+build.10"
+parchment = "2024.06.16"
+parchmentMc = "1.20.6"
+yarn = "1.21+build.1"

 # Core dependencies (these versions are tied to the version Minecraft uses)
-fastutil = "8.5.9"
-guava = "31.1-jre"
-netty = "4.1.82.Final"
-slf4j = "2.0.1"
+fastutil = "8.5.12"
+guava = "32.1.2-jre"
+netty = "4.1.97.Final"
+slf4j = "2.0.9"

 # Core dependencies (independent of Minecraft)
 asm = "9.6"
 autoService = "1.1.1"
 checkerFramework = "3.42.0"
-cobalt = { strictly = "0.9.6" }
+cobalt = { strictly = "0.9.3" }
 commonsCli = "1.6.0"
 jetbrainsAnnotations = "24.1.0"
-jspecify = "1.0.0"
+jsr305 = "3.0.2"
 jzlib = "1.1.3"
-kotlin = "2.1.10"
-kotlin-coroutines = "1.10.1"
-nightConfig = "3.8.1"
+kotlin = "1.9.21"
+kotlin-coroutines = "1.7.3"
+nightConfig = "3.6.7"

 # Minecraft mods
-emi = "1.0.8+1.20.1"
-fabricPermissions = "0.3.20230723"
-iris = "1.6.4+1.20"
-jei = "15.2.0.22"
-modmenu = "7.1.0"
+emi = "1.1.7+1.21"
+fabricPermissions = "0.3.1"
+iris = "1.6.14+1.20.4"
+jei = "19.0.0.1"
+modmenu = "11.0.0-rc.4"
 moreRed = "4.0.0.4"
 oculus = "1.2.5"
-rei = "12.0.626"
+rei = "16.0.729"
 rubidium = "0.6.1"
 sodium = "mc1.20-0.4.10"
-create-forge = "6.0.0-9"
-create-fabric = "0.5.1-f-build.1467+mc1.20.1"
+mixinExtra = "0.3.5"

 # Testing
 hamcrest = "2.2"
 jqwik = "1.8.2"
-junit = "5.11.4"
-junitPlatform = "1.11.4"
+junit = "5.10.1"
 jmh = "1.37"

 # Build tools
-cctJavadoc = "1.8.4"
-checkstyle = "10.23.1"
-errorProne-core = "2.38.0"
-errorProne-plugin = "4.1.0"
-fabric-loom = "1.10.4"
+cctJavadoc = "1.8.2"
+checkstyle = "10.14.1"
+curseForgeGradle = "1.1.18"
+errorProne-core = "2.27.0"
+errorProne-plugin = "3.1.0"
+fabric-loom = "1.7.1"
 githubRelease = "2.5.2"
 gradleVersions = "0.50.0"
 ideaExt = "1.1.7"
-illuaminate = "0.1.0-83-g1131f68"
+illuaminate = "0.1.0-73-g43ee16c"
 lwjgl = "3.3.3"
 minotaur = "2.8.7"
-modDevGradle = "2.0.95"
-nullAway = "0.12.7"
-shadow = "8.3.1"
-spotless = "7.0.2"
+neoGradle = "7.0.152"
+nullAway = "0.10.25"
+spotless = "6.23.3"
 taskTree = "2.1.1"
-teavm = "0.13.0-SQUID.1"
-vanillaExtract = "0.2.1"
+teavm = "0.11.0-SQUID.1"
+vanillaExtract = "0.1.3"
 versionCatalogUpdate = "0.8.1"

 [libraries]
@@ -86,35 +84,33 @@ checkerFramework = { module = "org.checkerframework:checker-qual", version.ref =
 cobalt = { module = "cc.tweaked:cobalt", version.ref = "cobalt" }
 commonsCli = { module = "commons-cli:commons-cli", version.ref = "commonsCli" }
 fastutil = { module = "it.unimi.dsi:fastutil", version.ref = "fastutil" }
-forgeSpi = { module = "net.minecraftforge:forgespi", version.ref = "forgeSpi" }
+neoForgeSpi = { module = "net.neoforged:neoforgespi", version.ref = "neoForgeSpi" }
 guava = { module = "com.google.guava:guava", version.ref = "guava" }
 jetbrainsAnnotations = { module = "org.jetbrains:annotations", version.ref = "jetbrainsAnnotations" }
-jspecify = { module = "org.jspecify:jspecify", version.ref = "jspecify" }
+jsr305 = { module = "com.google.code.findbugs:jsr305", version.ref = "jsr305" }
 jzlib = { module = "com.jcraft:jzlib", version.ref = "jzlib" }
 kotlin-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
 kotlin-platform = { module = "org.jetbrains.kotlin:kotlin-bom", version.ref = "kotlin" }
 kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
-netty-codec = { module = "io.netty:netty-codec", version.ref = "netty" }
 netty-http = { module = "io.netty:netty-codec-http", version.ref = "netty" }
-netty-proxy = { module = "io.netty:netty-handler-proxy", version.ref = "netty" }
 netty-socks = { module = "io.netty:netty-codec-socks", version.ref = "netty" }
+netty-proxy = { module = "io.netty:netty-handler-proxy", version.ref = "netty" }
 nightConfig-core = { module = "com.electronwill.night-config:core", version.ref = "nightConfig" }
 nightConfig-toml = { module = "com.electronwill.night-config:toml", version.ref = "nightConfig" }
 slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

 # Minecraft mods
-create-fabric = { module = "com.simibubi.create:create-fabric-1.20.1", version.ref = "create-fabric" }
-create-forge = { module = "com.simibubi.create:create-1.20.1", version.ref = "create-forge" }
-emi = { module = "dev.emi:emi-xplat-mojmap", version.ref = "emi" }
 fabric-api = { module = "net.fabricmc.fabric-api:fabric-api", version.ref = "fabric-api" }
-fabric-junit = { module = "net.fabricmc:fabric-loader-junit", version.ref = "fabric-loader" }
 fabric-loader = { module = "net.fabricmc:fabric-loader", version.ref = "fabric-loader" }
+fabric-junit = { module = "net.fabricmc:fabric-loader-junit", version.ref = "fabric-loader" }
 fabricPermissions = { module = "me.lucko:fabric-permissions-api", version.ref = "fabricPermissions" }
+emi = { module = "dev.emi:emi-xplat-mojmap", version.ref = "emi" }
 iris = { module = "maven.modrinth:iris", version.ref = "iris" }
-jei-api = { module = "mezz.jei:jei-1.20.1-common-api", version.ref = "jei" }
-jei-fabric = { module = "mezz.jei:jei-1.20.1-fabric", version.ref = "jei" }
-jei-forge = { module = "mezz.jei:jei-1.20.1-forge", version.ref = "jei" }
+jei-api = { module = "mezz.jei:jei-1.21-common-api", version.ref = "jei" }
+jei-fabric = { module = "mezz.jei:jei-1.21-fabric", version.ref = "jei" }
+jei-forge = { module = "mezz.jei:jei-1.21-neoforge", version.ref = "jei" }
 mixin = { module = "org.spongepowered:mixin", version.ref = "mixin" }
+mixinExtra = { module = "io.github.llamalad7:mixinextras-common", version.ref = "mixinExtra" }
 modmenu = { module = "com.terraformersmc:modmenu", version.ref = "modmenu" }
 moreRed = { module = "commoble.morered:morered-1.20.1", version.ref = "moreRed" }
 oculus = { module = "maven.modrinth:oculus", version.ref = "oculus" }
@@ -131,7 +127,6 @@ jqwik-engine = { module = "net.jqwik:jqwik-engine", version.ref = "jqwik" }
 junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" }
 junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
 junit-jupiter-params = { module = "org.junit.jupiter:junit-jupiter-params", version.ref = "junit" }
-junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junitPlatform" }
 slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
 jmh = { module = "org.openjdk.jmh:jmh-core", version.ref = "jmh" }
 jmh-processor = { module = "org.openjdk.jmh:jmh-generator-annprocess", version.ref = "jmh" }
@@ -145,6 +140,7 @@ lwjgl-glfw = { module = "org.lwjgl:lwjgl-glfw" }
 # Build tools
 cctJavadoc = { module = "cc.tweaked:cct-javadoc", version.ref = "cctJavadoc" }
 checkstyle = { module = "com.puppycrawl.tools:checkstyle", version.ref = "checkstyle" }
+curseForgeGradle = { module = "net.darkhax.curseforgegradle:CurseForgeGradle", version.ref = "curseForgeGradle" }
 errorProne-annotations = { module = "com.google.errorprone:error_prone_annotations", version.ref = "errorProne-core" }
 errorProne-api = { module = "com.google.errorprone:error_prone_check_api", version.ref = "errorProne-core" }
 errorProne-core = { module = "com.google.errorprone:error_prone_core", version.ref = "errorProne-core" }
@@ -154,8 +150,8 @@ fabric-loom = { module = "net.fabricmc:fabric-loom", version.ref = "fabric-loom"
 ideaExt = { module = "gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext", version.ref = "ideaExt" }
 kotlin-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
 minotaur = { module = "com.modrinth.minotaur:Minotaur", version.ref = "minotaur" }
+neoGradle-userdev = { module = "net.neoforged.gradle:userdev", version.ref = "neoGradle" }
 nullAway = { module = "com.uber.nullaway:nullaway", version.ref = "nullAway" }
-modDevGradle = { module = "net.neoforged:moddev-gradle", version.ref = "modDevGradle" }
 spotless = { module = "com.diffplug.spotless:spotless-plugin-gradle", version.ref = "spotless" }
 teavm-classlib = { module = "org.teavm:teavm-classlib", version.ref = "teavm" }
 teavm-core = { module = "org.teavm:teavm-core", version.ref = "teavm" }
@@ -173,12 +169,11 @@ yarn = { module = "net.fabricmc:yarn", version.ref = "yarn" }
 githubRelease = { id = "com.github.breadmoirai.github-release", version.ref = "githubRelease" }
 gradleVersions = { id = "com.github.ben-manes.versions", version.ref = "gradleVersions" }
 kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
-shadow = { id = "com.gradleup.shadow", version.ref = "shadow" }
 taskTree = { id = "com.dorongold.task-tree", version.ref = "taskTree" }
 versionCatalogUpdate = { id = "nl.littlerobots.version-catalog-update", version.ref = "versionCatalogUpdate" }

 [bundles]
-annotations = ["checkerFramework", "jetbrainsAnnotations", "jspecify"]
+annotations = ["jsr305", "checkerFramework", "jetbrainsAnnotations"]
 kotlin = ["kotlin-stdlib", "kotlin-coroutines"]

 # Minecraft
@@ -190,7 +185,7 @@ externalMods-fabric-runtime = ["jei-fabric", "modmenu"]

 # Testing
 test = ["junit-jupiter-api", "junit-jupiter-params", "hamcrest", "jqwik-api"]
-testRuntime = ["junit-jupiter-engine", "junit-platform-launcher", "jqwik-engine"]
+testRuntime = ["junit-jupiter-engine", "jqwik-engine"]

 # Build tools
 teavm-api = ["teavm-jso", "teavm-jso-apis", "teavm-platform", "teavm-classlib", "teavm-metaprogramming-api"]
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- 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.12-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
--- a/4
+++ b/4
@@ -15,8 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# SPDX-License-Identifier: Apache-2.0
-#

 ##############################################################################
 #
@@ -86,7 +84,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit

 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,8 +13,6 @@
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
-@rem SPDX-License-Identifier: Apache-2.0
-@rem

@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -12,11 +12,11 @@
    "tslib": "^2.0.3"
  },
  "devDependencies": {
-    "@rollup/plugin-node-resolve": "^16.0.0",
-    "@rollup/plugin-typescript": "^12.0.0",
+    "@rollup/plugin-node-resolve": "^15.2.1",
+    "@rollup/plugin-typescript": "^11.0.0",
    "@rollup/plugin-url": "^8.0.1",
    "@swc/core": "^1.3.92",
-    "@types/node": "^24.0.0",
+    "@types/node": "^20.8.3",
    "lightningcss": "^1.22.0",
    "preact-render-to-string": "^6.2.1",
    "rehype": "^13.0.0",
--- a/projects/common-api/build.gradle.kts
+++ b/projects/common-api/build.gradle.kts
@@ -8,8 +8,6 @@ plugins {
    id("cc-tweaked.vanilla")
 }

-val mcVersion: String by extra
-
 java {
    withJavadocJar()
 }
@@ -18,42 +16,14 @@ dependencies {
    api(project(":core-api"))
 }

-val javadocOverview by tasks.registering(Copy::class) {
-    from("src/overview.html")
-    into(layout.buildDirectory.dir(name))
-
-    expand(
-        mapOf(
-            "mcVersion" to mcVersion,
-            "modVersion" to version,
-        ),
-    )
-}
-
 tasks.javadoc {
-    title = "CC: Tweaked $version for Minecraft $mcVersion"
    include("dan200/computercraft/api/**/*.java")

+    // Include the core-api in our javadoc export. This is wrong, but it means we can export a single javadoc dump.
+    source(project(":core-api").sourceSets.main.map { it.allJava })
+
    options {
-        (this as StandardJavadocDocletOptions)
-
-        inputs.files(javadocOverview)
-        overview(javadocOverview.get().destinationDir.resolve("overview.html").absolutePath)
-
-        groups = mapOf(
-            "Common" to listOf(
-                "dan200.computercraft.api",
-                "dan200.computercraft.api.lua",
-                "dan200.computercraft.api.peripheral",
-            ),
-            "Upgrades" to listOf(
-                "dan200.computercraft.api.client.turtle",
-                "dan200.computercraft.api.pocket",
-                "dan200.computercraft.api.turtle",
-                "dan200.computercraft.api.upgrades",
-            ),
-        )
-
+        this as StandardJavadocDocletOptions
        addBooleanOption("-allow-script-in-comments", true)
        bottom(
            """
@@ -62,17 +32,5 @@ tasks.javadoc {
            <link href=" https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism.min.css " rel="stylesheet">
            """.trimIndent(),
        )
-
-        taglets("cc.tweaked.javadoc.SnippetTaglet")
-        tagletPath(configurations.detachedConfiguration(dependencies.project(":lints")).toList())
-
-        val snippetSources = listOf(":common", ":fabric", ":forge").flatMap {
-            project(it).sourceSets["examples"].allSource.sourceDirectories
-        }
-        inputs.files(snippetSources)
-        jFlags("-Dcc.snippet-path=" + snippetSources.joinToString(File.pathSeparator) { it.absolutePath })
    }
-
-    // Include the core-api in our javadoc export. This is wrong, but it means we can export a single javadoc dump.
-    source(project(":core-api").sourceSets.main.map { it.allJava })
 }
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/ComputerCraftAPIClient.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/ComputerCraftAPIClient.java
@@ -1,43 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.client;
-
-import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
-import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import dan200.computercraft.impl.client.ComputerCraftAPIClientService;
-
-/**
- * The public API for client-only code.
- *
- * @see dan200.computercraft.api.ComputerCraftAPI The main API
- */
-public final class ComputerCraftAPIClient {
-    private ComputerCraftAPIClient() {
-    }
-
-    /**
-     * Register a {@link TurtleUpgradeModeller} for a class of turtle upgrades.
-     * <p>
-     * This may be called at any point after registry creation, though it is recommended to call it within your client
-     * setup step.
-     *
-     * @param serialiser The turtle upgrade serialiser.
-     * @param modeller   The upgrade modeller.
-     * @param <T>        The type of the turtle upgrade.
-     * @deprecated This method can lead to confusing load behaviour on Forge. Use
-     * {@code dan200.computercraft.api.client.FabricComputerCraftAPIClient#registerTurtleUpgradeModeller} on Fabric, or
-     * {@code dan200.computercraft.api.client.turtle.RegisterTurtleModellersEvent} on Forge.
-     */
-    @Deprecated(forRemoval = true)
-    public static <T extends ITurtleUpgrade> void registerTurtleUpgradeModeller(TurtleUpgradeSerialiser<T> serialiser, TurtleUpgradeModeller<T> modeller) {
-        // TODO(1.20.4): Remove this
-        getInstance().registerTurtleUpgradeModeller(serialiser, modeller);
-    }
-
-    private static ComputerCraftAPIClientService getInstance() {
-        return ComputerCraftAPIClientService.get();
-    }
-}
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/ModelLocation.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/ModelLocation.java
@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client;
+
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
+import dan200.computercraft.impl.client.ClientPlatformHelper;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.client.resources.model.ModelManager;
+import net.minecraft.client.resources.model.ModelResourceLocation;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.stream.Stream;
+
+/**
+ * The location of a model to load. This may either be:
+ *
+ * <ul>
+ *     <li>A {@link ModelResourceLocation}, referencing an already baked model (such as {@code minecraft:dirt#inventory}).</li>
+ *     <li>
+ *         A {@link ResourceLocation}, referencing a path to a model resource (such as {@code minecraft:item/dirt}.
+ *         These models will be baked and stored in the {@link ModelManager} in a loader-specific way.
+ *     </li>
+ * </ul>
+ */
+public final class ModelLocation {
+    /**
+     * The location of the model.
+     * <p>
+     * When {@link #resourceLocation} is null, this is the location of the model to load. When {@link #resourceLocation}
+     * is non-null, this is the "standalone" variant of the model resource — this is used by NeoForge's implementation
+     * of {@link ClientPlatformHelper#getModel(ModelManager, ModelResourceLocation, ResourceLocation)} to fetch the
+     * model from the model manger. It is not used on Fabric.
+     */
+    private final ModelResourceLocation modelLocation;
+    private final @Nullable ResourceLocation resourceLocation;
+
+    private ModelLocation(ModelResourceLocation modelLocation, @Nullable ResourceLocation resourceLocation) {
+        this.modelLocation = modelLocation;
+        this.resourceLocation = resourceLocation;
+    }
+
+    /**
+     * Create a {@link ModelLocation} from model in the model manager.
+     *
+     * @param location The name of the model to load.
+     * @return The new {@link ModelLocation} instance.
+     */
+    public static ModelLocation ofModel(ModelResourceLocation location) {
+        return new ModelLocation(location, null);
+    }
+
+    /**
+     * Create a {@link ModelLocation} from a resource.
+     *
+     * @param location The location of the model resource, such as {@code minecraft:item/dirt}.
+     * @return The new {@link ModelLocation} instance.
+     */
+    public static ModelLocation ofResource(ResourceLocation location) {
+        return new ModelLocation(new ModelResourceLocation(location, "standalone"), location);
+    }
+
+    /**
+     * Get this model from the provided model manager.
+     *
+     * @param manager The model manger.
+     * @return This model, or the missing model if it could not be found.
+     */
+    public BakedModel getModel(ModelManager manager) {
+        return ClientPlatformHelper.get().getModel(manager, modelLocation, resourceLocation);
+    }
+
+    /**
+     * Get the models this model location depends on.
+     *
+     * @return A list of models that this model location depends on.
+     * @see TurtleUpgradeModeller#getDependencies()
+     */
+    public Stream<ResourceLocation> getDependencies() {
+        return resourceLocation == null ? Stream.empty() : Stream.of(resourceLocation);
+    }
+}
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/TransformedModel.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/TransformedModel.java
@@ -13,30 +13,47 @@ import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;

-import java.util.Objects;
-
 /**
 * A model to render, combined with a transformation matrix to apply.
+ *
+ * @param model  The model.
+ * @param matrix The transformation matrix.
 */
-public final class TransformedModel {
-    private final BakedModel model;
-    private final Transformation matrix;
-
-    public TransformedModel(BakedModel model, Transformation matrix) {
-        this.model = Objects.requireNonNull(model);
-        this.matrix = Objects.requireNonNull(matrix);
-    }
-
+public record TransformedModel(BakedModel model, Transformation matrix) {
    public TransformedModel(BakedModel model) {
-        this.model = Objects.requireNonNull(model);
-        matrix = Transformation.identity();
+        this(model, Transformation.identity());
    }

+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     */
+    public static TransformedModel of(ModelLocation location) {
+        var modelManager = Minecraft.getInstance().getModelManager();
+        return new TransformedModel(location.getModel(modelManager));
+    }
+
+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     * @see ModelLocation#ofModel(ModelResourceLocation)
+     */
    public static TransformedModel of(ModelResourceLocation location) {
        var modelManager = Minecraft.getInstance().getModelManager();
        return new TransformedModel(modelManager.getModel(location));
    }

+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     * @see ModelLocation#ofResource(ResourceLocation)
+     */
    public static TransformedModel of(ResourceLocation location) {
        var modelManager = Minecraft.getInstance().getModelManager();
        return new TransformedModel(ClientPlatformHelper.get().getModel(modelManager, location));
@@ -46,12 +63,4 @@ public final class TransformedModel {
        var model = Minecraft.getInstance().getItemRenderer().getItemModelShaper().getItemModel(item);
        return new TransformedModel(model, transform);
    }
-
-    public BakedModel getModel() {
-        return model;
-    }
-
-    public Transformation getMatrix() {
-        return matrix;
-    }
 }
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/RegisterTurtleUpgradeModeller.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/RegisterTurtleUpgradeModeller.java
@@ -5,7 +5,7 @@
 package dan200.computercraft.api.client.turtle;

 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
+import dan200.computercraft.api.upgrades.UpgradeType;

 /**
 * A functional interface to register a {@link TurtleUpgradeModeller} for a class of turtle upgrades.
@@ -18,9 +18,9 @@ public interface RegisterTurtleUpgradeModeller {
    /**
     * Register a {@link TurtleUpgradeModeller}.
     *
-     * @param serialiser The turtle upgrade serialiser.
-     * @param modeller   The upgrade modeller.
-     * @param <T>        The type of the turtle upgrade.
+     * @param type     The turtle upgrade type.
+     * @param modeller The upgrade modeller.
+     * @param <T>      The type of the turtle upgrade.
     */
-    <T extends ITurtleUpgrade> void register(TurtleUpgradeSerialiser<T> serialiser, TurtleUpgradeModeller<T> modeller);
+    <T extends ITurtleUpgrade> void register(UpgradeType<T> type, TurtleUpgradeModeller<T> modeller);
 }
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModeller.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModeller.java
@@ -4,32 +4,24 @@

 package dan200.computercraft.api.client.turtle;

+import dan200.computercraft.api.client.ModelLocation;
 import dan200.computercraft.api.client.TransformedModel;
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
-import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.client.resources.model.UnbakedModel;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.resources.ResourceLocation;
-import org.jspecify.annotations.Nullable;

-import java.util.Collection;
-import java.util.List;
+import javax.annotation.Nullable;
+import java.util.stream.Stream;

 /**
 * Provides models for a {@link ITurtleUpgrade}.
 * <p>
 * Use {@code dan200.computercraft.api.client.FabricComputerCraftAPIClient#registerTurtleUpgradeModeller} to register a
 * modeller on Fabric and {@code dan200.computercraft.api.client.turtle.RegisterTurtleModellersEvent} to register one
- * on Forge.
- *
- * <h2>Example</h2>
- * <h3>Fabric</h3>
- * {@snippet class=com.example.examplemod.FabricExampleModClient region=turtle_modellers}
- *
- * <h3>Forge</h3>
- * {@snippet class=com.example.examplemod.FabricExampleModClient region=turtle_modellers}
+ * on Forge
 *
 * @param <T> The type of turtle upgrade this modeller applies to.
 * @see RegisterTurtleUpgradeModeller For multi-loader registration support.
@@ -38,47 +30,32 @@ public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
    /**
     * Obtain the model to be used when rendering a turtle peripheral.
     * <p>
-     * When the current turtle is {@literal null}, this function should be constant for a given upgrade and side.
+     * When the current turtle is {@literal null}, this function should be constant for a given upgrade, side and data.
     *
     * @param upgrade The upgrade that you're getting the model for.
-     * @param turtle  Access to the turtle that the upgrade resides on. This will be null when getting item models, unless
-     *                {@link #getModel(ITurtleUpgrade, CompoundTag, TurtleSide)} is overriden.
+     * @param turtle  Access to the turtle that the upgrade resides on. This will be null when getting item models.
     * @param side    Which side of the turtle (left or right) the upgrade resides on.
-     * @return The model that you wish to be used to render your upgrade.
-     */
-    TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side);
-
-    /**
-     * Obtain the model to be used when rendering a turtle peripheral.
-     * <p>
-     * This is used when rendering the turtle's item model, and so no {@link ITurtleAccess} is available.
-     *
-     * @param upgrade The upgrade that you're getting the model for.
     * @param data    Upgrade data instance for current turtle side.
-     * @param side    Which side of the turtle (left or right) the upgrade resides on.
     * @return The model that you wish to be used to render your upgrade.
     */
-    default TransformedModel getModel(T upgrade, CompoundTag data, TurtleSide side) {
-        return getModel(upgrade, (ITurtleAccess) null, side);
-    }
-
+    TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data);

    /**
-     * Get a list of models that this turtle modeller depends on.
+     * Get the models that this turtle modeller depends on.
     * <p>
-     * Models included in this list will be loaded and baked alongside item and block models, and so may be referenced
+     * Models included in this stream will be loaded and baked alongside item and block models, and so may be referenced
     * by {@link TransformedModel#of(ResourceLocation)}. You do not need to override this method if you will load models
     * by other means.
     *
     * @return A list of models that this modeller depends on.
     * @see UnbakedModel#getDependencies()
     */
-    default Collection<ResourceLocation> getDependencies() {
-        return List.of();
+    default Stream<ResourceLocation> getDependencies() {
+        return Stream.of();
    }

    /**
-     * A basic {@link TurtleUpgradeModeller} which renders using the upgrade's {@linkplain ITurtleUpgrade#getUpgradeItem(CompoundTag)}
+     * A basic {@link TurtleUpgradeModeller} which renders using the upgrade's {@linkplain ITurtleUpgrade#getUpgradeItem(DataComponentPatch)}
     * upgrade item}.
     * <p>
     * This uses appropriate transformations for "flat" items, namely those extending the {@literal minecraft:item/generated}
@@ -100,9 +77,8 @@ public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
     * @param <T>   The type of the turtle upgrade.
     * @return The constructed modeller.
     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ModelResourceLocation left, ModelResourceLocation right) {
-        // TODO(1.21.0): Remove this.
-        return sided((ResourceLocation) left, right);
+    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ResourceLocation left, ResourceLocation right) {
+        return sided(ModelLocation.ofResource(left), ModelLocation.ofResource(right));
    }

    /**
@@ -113,16 +89,16 @@ public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
     * @param <T>   The type of the turtle upgrade.
     * @return The constructed modeller.
     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ResourceLocation left, ResourceLocation right) {
+    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ModelLocation left, ModelLocation right) {
        return new TurtleUpgradeModeller<>() {
            @Override
-            public TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side) {
+            public TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data) {
                return TransformedModel.of(side == TurtleSide.LEFT ? left : right);
            }

            @Override
-            public Collection<ResourceLocation> getDependencies() {
-                return List.of(left, right);
+            public Stream<ResourceLocation> getDependencies() {
+                return Stream.of(left, right).flatMap(ModelLocation::getDependencies);
            }
        };
    }
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModellers.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModellers.java
@@ -11,10 +11,10 @@ import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
 import dan200.computercraft.impl.client.ClientPlatformHelper;
 import net.minecraft.client.Minecraft;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.world.item.ItemStack;
+import net.minecraft.core.component.DataComponentPatch;
 import org.joml.Matrix4f;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

 final class TurtleUpgradeModellers {
    private static final Transformation leftTransform = getMatrixFor(-0.4065f);
@@ -36,16 +36,8 @@ final class TurtleUpgradeModellers {

    private static final class UpgradeItemModeller implements TurtleUpgradeModeller<ITurtleUpgrade> {
        @Override
-        public TransformedModel getModel(ITurtleUpgrade upgrade, @Nullable ITurtleAccess turtle, TurtleSide side) {
-            return getModel(turtle == null ? upgrade.getCraftingItem() : upgrade.getUpgradeItem(turtle.getUpgradeNBTData(side)), side);
-        }
-
-        @Override
-        public TransformedModel getModel(ITurtleUpgrade upgrade, CompoundTag data, TurtleSide side) {
-            return getModel(upgrade.getUpgradeItem(data), side);
-        }
-
-        private TransformedModel getModel(ItemStack stack, TurtleSide side) {
+        public TransformedModel getModel(ITurtleUpgrade upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data) {
+            var stack = upgrade.getUpgradeItem(data);
            var model = Minecraft.getInstance().getItemRenderer().getItemModelShaper().getItemModel(stack);
            if (stack.hasFoil()) model = ClientPlatformHelper.get().createdFoiledModel(model);
            return new TransformedModel(model, side == TurtleSide.LEFT ? leftTransform : rightTransform);
--- a/projects/common-api/src/client/java/dan200/computercraft/impl/client/ClientPlatformHelper.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/impl/client/ClientPlatformHelper.java
@@ -4,6 +4,7 @@

 package dan200.computercraft.impl.client;

+import dan200.computercraft.api.client.ModelLocation;
 import dan200.computercraft.impl.Services;
 import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.resources.model.BakedModel;
@@ -11,18 +12,34 @@ import net.minecraft.client.resources.model.ModelManager;
 import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.resources.ResourceLocation;
 import org.jetbrains.annotations.ApiStatus;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

@ApiStatus.Internal
 public interface ClientPlatformHelper {
    /**
-     * Equivalent to {@link ModelManager#getModel(ModelResourceLocation)} but for arbitrary {@link ResourceLocation}s.
+     * Get a model from a resource.
     *
-     * @param manager  The model manager.
-     * @param location The model location.
+     * @param manager          The model manager.
+     * @param resourceLocation The model resourceLocation.
     * @return The baked model.
+     * @see ModelLocation
     */
-    BakedModel getModel(ModelManager manager, ResourceLocation location);
+    BakedModel getModel(ModelManager manager, ResourceLocation resourceLocation);
+
+    /**
+     * Set a model from a {@link ModelResourceLocation} or {@link ResourceLocation}.
+     * <p>
+     * This is largely equivalent to {@code resourceLocation == null ? manager.getModel(modelLocation) : getModel(manager, resourceLocation)},
+     * but allows pre-computing {@code modelLocation} (if needed).
+     *
+     * @param manager          The model manager.
+     * @param modelLocation    The location of the model to load.
+     * @param resourceLocation The location of the resource, if trying to load from a resource.
+     * @return The baked model.
+     * @see ModelLocation
+     */
+    BakedModel getModel(ModelManager manager, ModelResourceLocation modelLocation, @Nullable ResourceLocation resourceLocation);

    /**
     * Wrap this model in a version which renders a foil/enchantment glint.
--- a/projects/common-api/src/main/java/dan200/computercraft/api/ComputerCraftAPI.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/ComputerCraftAPI.java
@@ -4,11 +4,9 @@

 package dan200.computercraft.api;

-import dan200.computercraft.api.component.ComputerComponent;
 import dan200.computercraft.api.filesystem.Mount;
 import dan200.computercraft.api.filesystem.WritableMount;
 import dan200.computercraft.api.lua.GenericSource;
-import dan200.computercraft.api.lua.IComputerSystem;
 import dan200.computercraft.api.lua.ILuaAPI;
 import dan200.computercraft.api.lua.ILuaAPIFactory;
 import dan200.computercraft.api.media.IMedia;
@@ -26,7 +24,8 @@ import net.minecraft.core.Direction;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

 /**
 * The static entry point to the ComputerCraft API.
@@ -166,13 +165,7 @@ public final class ComputerCraftAPI {
     * Register a custom {@link ILuaAPI}, which may be added onto all computers without requiring a peripheral.
     * <p>
     * Before implementing this interface, consider alternative methods of providing methods. It is generally preferred
-     * to use peripherals to provide functionality to users. If an API is <em>required</em>, you may want to consider
-     * using {@link ILuaAPI#getModuleName()} to expose this library as a module instead of as a global.
-     * <p>
-     * This may be used with {@link IComputerSystem#getComponent(ComputerComponent)} to only attach APIs to specific
-     * computers. For example, one can add a new API just to turtles with the following code:
-     *
-     * {@snippet class=com.example.examplemod.ExampleAPI region=register}
+     * to use peripherals to provide functionality to users.
     *
     * @param factory The factory for your API subclass.
     * @see ILuaAPIFactory
--- a/projects/common-api/src/main/java/dan200/computercraft/api/ComputerCraftTags.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/ComputerCraftTags.java
@@ -6,10 +6,12 @@ package dan200.computercraft.api;

 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.InteractionHand;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.context.UseOnContext;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
@@ -26,20 +28,6 @@ public class ComputerCraftTags {
        public static final TagKey<Item> WIRED_MODEM = make("wired_modem");
        public static final TagKey<Item> MONITOR = make("monitor");

-        /**
-         * Floppy disks. Both the read/write version, and treasure disks.
-         *
-         * @since 1.116.0
-         */
-        public static final TagKey<Item> DISKS = make("disks");
-
-        /**
-         * All pocket computers.
-         *
-         * @since 1.116.0
-         */
-        public static final TagKey<Item> POCKET_COMPUTERS = make("pocket_computers");
-
        /**
         * Items which can be {@linkplain Item#use(Level, Player, InteractionHand) used} when calling
         * {@code turtle.place()}.
@@ -49,8 +37,16 @@ public class ComputerCraftTags {
         */
        public static final TagKey<Item> TURTLE_CAN_PLACE = make("turtle_can_place");

+        /**
+         * Items which can be dyed.
+         * <p>
+         * This is similar to {@link ItemTags#DYEABLE}, but allows cleaning the item with a sponge, rather than in a
+         * cauldron.
+         */
+        public static final TagKey<Item> DYEABLE = make("dyeable");
+
        private static TagKey<Item> make(String name) {
-            return TagKey.create(Registries.ITEM, new ResourceLocation(ComputerCraftAPI.MOD_ID, name));
+            return TagKey.create(Registries.ITEM, ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, name));
        }
    }

@@ -89,13 +85,13 @@ public class ComputerCraftTags {
        public static final TagKey<Block> TURTLE_HOE_BREAKABLE = make("turtle_hoe_harvestable");

        /**
-         * Block which can be {@linkplain BlockState#use(Level, Player, InteractionHand, BlockHitResult) used} when
-         * calling {@code turtle.place()}.
+         * Block which can be {@linkplain BlockState#useItemOn(ItemStack, Level, Player, InteractionHand, BlockHitResult) used}
+         * when calling {@code turtle.place()}.
         */
        public static final TagKey<Block> TURTLE_CAN_USE = make("turtle_can_use");

        private static TagKey<Block> make(String name) {
-            return TagKey.create(Registries.BLOCK, new ResourceLocation(ComputerCraftAPI.MOD_ID, name));
+            return TagKey.create(Registries.BLOCK, ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, name));
        }
    }
 }
--- a/projects/common-api/src/main/java/dan200/computercraft/api/component/AdminComputer.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/component/AdminComputer.java
@@ -1,24 +0,0 @@
-// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.component;
-
-import net.minecraft.commands.CommandSourceStack;
-import org.jetbrains.annotations.ApiStatus;
-
-/**
- * A computer which has permission to perform administrative/op commands, such as the command computer.
- */
-@ApiStatus.NonExtendable
-public interface AdminComputer {
-    /**
-     * The permission level that this computer can operate at.
-     *
-     * @return The permission level for this computer.
-     * @see CommandSourceStack#hasPermission(int)
-     */
-    default int permissionLevel() {
-        return 2;
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/component/ComputerComponent.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/component/ComputerComponent.java
@@ -1,48 +0,0 @@
-// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.component;
-
-import dan200.computercraft.api.lua.IComputerSystem;
-import dan200.computercraft.api.lua.ILuaAPIFactory;
-
-/**
- * A component attached to a computer.
- * <p>
- * Components provide a mechanism to attach additional data to a computer, that can then be queried with
- * {@link IComputerSystem#getComponent(ComputerComponent)}.
- * <p>
- * This is largely designed for {@linkplain ILuaAPIFactory custom APIs}, allowing APIs to read additional properties
- * of the computer, such as its position.
- *
- * @param <T> The type of this component.
- * @see ComputerComponents The built-in components.
- */
-@SuppressWarnings("UnusedTypeParameter")
-public final class ComputerComponent<T> {
-    private final String id;
-
-    private ComputerComponent(String id) {
-        this.id = id;
-    }
-
-    /**
-     * Create a new computer component.
-     * <p>
-     * Mods typically will not need to create their own components.
-     *
-     * @param namespace The namespace of this component. This should be the mod id.
-     * @param id        The unique id of this component.
-     * @param <T>       The component
-     * @return The newly created component.
-     */
-    public static <T> ComputerComponent<T> create(String namespace, String id) {
-        return new ComputerComponent<>(namespace + ":" + id);
-    }
-
-    @Override
-    public String toString() {
-        return "ComputerComponent(" + id + ")";
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/component/ComputerComponents.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/component/ComputerComponents.java
@@ -1,29 +0,0 @@
-// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.component;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.pocket.IPocketAccess;
-import dan200.computercraft.api.turtle.ITurtleAccess;
-
-/**
- * The {@link ComputerComponent}s provided by ComputerCraft.
- */
-public class ComputerComponents {
-    /**
-     * The {@link ITurtleAccess} associated with a turtle.
-     */
-    public static final ComputerComponent<ITurtleAccess> TURTLE = ComputerComponent.create(ComputerCraftAPI.MOD_ID, "turtle");
-
-    /**
-     * The {@link IPocketAccess} associated with a pocket computer.
-     */
-    public static final ComputerComponent<IPocketAccess> POCKET = ComputerComponent.create(ComputerCraftAPI.MOD_ID, "pocket");
-
-    /**
-     * This component is only present on "command computers", and other computers with admin capabilities.
-     */
-    public static final ComputerComponent<AdminComputer> ADMIN_COMPUTER = ComputerComponent.create(ComputerCraftAPI.MOD_ID, "admin_computer");
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/detail/BasicItemDetailProvider.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/detail/BasicItemDetailProvider.java
@@ -6,14 +6,14 @@ package dan200.computercraft.api.detail;

 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
-import org.jspecify.annotations.Nullable;

+import javax.annotation.Nullable;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;

 /**
- * An item detail provider for {@link ItemStack}s whose {@link Item} has a specific type.
+ * An item detail provider for {@link ItemStack}'s whose {@link Item} has a specific type.
 *
 * @param <T> The type the stack's item must have.
 */
@@ -22,7 +22,7 @@ public abstract class BasicItemDetailProvider<T> implements DetailProvider<ItemS
    private final @Nullable String namespace;

    /**
-     * Create a new item detail provider. Details will be inserted into a new sub-map named as per {@code namespace}.
+     * Create a new item detail provider. Meta will be inserted into a new sub-map named as per {@code namespace}.
     *
     * @param itemType  The type the stack's item must have.
     * @param namespace The namespace to use for this provider.
@@ -34,7 +34,7 @@ public abstract class BasicItemDetailProvider<T> implements DetailProvider<ItemS
    }

    /**
-     * Create a new item detail provider. Details will be inserted directly into the results.
+     * Create a new item detail provider. Meta will be inserted directly into the results.
     *
     * @param itemType The type the stack's item must have.
     */
@@ -53,18 +53,21 @@ public abstract class BasicItemDetailProvider<T> implements DetailProvider<ItemS
     * @param stack The item stack to provide details for.
     * @param item  The item to provide details for.
     */
-    public abstract void provideDetails(Map<? super String, Object> data, ItemStack stack, T item);
+    public abstract void provideDetails(
+        Map<? super String, Object> data, ItemStack stack, T item
+    );

    @Override
-    public final void provideDetails(Map<? super String, Object> data, ItemStack stack) {
+    public void provideDetails(Map<? super String, Object> data, ItemStack stack) {
        var item = stack.getItem();
        if (!itemType.isInstance(item)) return;

-        if (namespace == null) {
-            provideDetails(data, stack, itemType.cast(item));
-        } else {
-            Map<? super String, Object> child = new HashMap<>();
-            provideDetails(child, stack, itemType.cast(item));
+        // If `namespace` is specified, insert into a new data map instead of the existing one.
+        Map<? super String, Object> child = namespace == null ? data : new HashMap<>();
+
+        provideDetails(child, stack, itemType.cast(item));
+
+        if (namespace != null) {
            data.put(namespace, child);
        }
    }
--- a/projects/common-api/src/main/java/dan200/computercraft/api/detail/BlockReference.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/detail/BlockReference.java
@@ -8,7 +8,8 @@ import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.block.state.BlockState;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

 /**
 * A reference to a block in the world, used by block detail providers.
--- a/projects/common-api/src/main/java/dan200/computercraft/api/detail/DetailProvider.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/detail/DetailProvider.java
@@ -14,7 +14,6 @@ import java.util.Map;
 *
 * @param <T> The type of object that this provider can provide details for.
 * @see DetailRegistry
- * @see dan200.computercraft.api.detail An overview of the detail system.
 */
@FunctionalInterface
 public interface DetailProvider<T> {
--- a/projects/common-api/src/main/java/dan200/computercraft/api/detail/DetailRegistry.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/detail/DetailRegistry.java
@@ -17,7 +17,6 @@ import java.util.Map;
 * also in this package.
 *
 * @param <T> The type of object that this registry provides details for.
- * @see dan200.computercraft.api.detail An overview of the detail system.
 */
@ApiStatus.NonExtendable
 public interface DetailRegistry<T> {
@@ -27,7 +26,7 @@ public interface DetailRegistry<T> {
     * @param provider The detail provider to register.
     * @see DetailProvider
     */
-    void addProvider(DetailProvider<? super T> provider);
+    void addProvider(DetailProvider<T> provider);

    /**
     * Compute basic details about an object. This is cheaper than computing all details operation, and so is suitable
--- a/projects/common-api/src/main/java/dan200/computercraft/api/detail/VanillaDetailRegistries.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/detail/VanillaDetailRegistries.java
@@ -17,9 +17,6 @@ public class VanillaDetailRegistries {
     * <p>
     * This instance's {@link DetailRegistry#getBasicDetails(Object)} is thread safe (assuming the stack is immutable)
     * and may be called from the computer thread.
-     * <p>
-     * This does not have special handling for {@linkplain ItemStack#isEmpty() empty item stacks}, and so the returned
-     * details will be an empty stack of air. Callers should generally check for empty stacks before calling this.
     */
    public static final DetailRegistry<ItemStack> ITEM_STACK = ComputerCraftAPIService.get().getItemStackDetailRegistry();

--- a/projects/common-api/src/main/java/dan200/computercraft/api/detail/package-info.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/detail/package-info.java
@@ -1,48 +0,0 @@
-// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-/**
- * The detail system provides a standard way for mods to return descriptions of common game objects, such as blocks or
- * items, as well as registering additional detail to be included in those descriptions.
- * <p>
- * For instance, the built-in {@code turtle.getItemDetail()} method uses
- * {@linkplain dan200.computercraft.api.detail.VanillaDetailRegistries#ITEM_STACK in order to provide information about}
- * the selected item:
- *
- * <pre class="language language-lua">{@code
- * local item = turtle.getItemDetail(nil, true)
- * --[[
- * item = {
- *   name = "minecraft:wheat",
- *   displayName = "Wheat",
- *   count = 1,
- *   maxCount = 64,
- *   tags = {},
- * }
- * ]]
- * }</pre>
- *
- * <h2>Built-in detail providers</h2>
- * While you can define your own detail providers (perhaps for types from your own mod), CC comes with several built-in
- * detail registries for vanilla and mod-loader objects:
- *
- * <ul>
- *     <li>{@link dan200.computercraft.api.detail.VanillaDetailRegistries}, for vanilla objects</li>
- *     <li>{@code dan200.computercraft.api.detail.ForgeDetailRegistries} for Forge-specific objects</li>
- *     <li>{@code dan200.computercraft.api.detail.FabricDetailRegistries} for Fabric-specific objects</li>
- * </ul>
- *
- * <h2>Example: Returning details from methods</h2>
- * Here we define a {@code getHeldItem()} method for pocket computers which finds the currently held item of the player
- * and returns it to the user using {@link dan200.computercraft.api.detail.VanillaDetailRegistries#ITEM_STACK} and
- * {@link dan200.computercraft.api.detail.DetailRegistry#getDetails(java.lang.Object)}.
- *
- * {@snippet class=com.example.examplemod.ExamplePocketPeripheral region=details}
- *
- * <h2>Example: Registering custom detail registries</h2>
- * Here we define a new detail provider for items that includes the nutrition and saturation values in the returned object.
- *
- * {@snippet class=com.example.examplemod.ExampleMod region=details}
- */
-package dan200.computercraft.api.detail;
--- a/projects/common-api/src/main/java/dan200/computercraft/api/lua/IComputerSystem.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/lua/IComputerSystem.java
@@ -1,58 +0,0 @@
-// SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.lua;
-
-import dan200.computercraft.api.component.ComputerComponent;
-import dan200.computercraft.api.peripheral.IComputerAccess;
-import net.minecraft.core.BlockPos;
-import net.minecraft.server.level.ServerLevel;
-import org.jetbrains.annotations.ApiStatus;
-import org.jspecify.annotations.Nullable;
-
-/**
- * An interface passed to {@link ILuaAPIFactory} in order to provide additional information
- * about a computer.
- */
-@ApiStatus.NonExtendable
-public interface IComputerSystem extends IComputerAccess {
-    /**
-     * Get the level this computer is currently in.
-     * <p>
-     * This method is not guaranteed to remain the same (even for stationary computers).
-     *
-     * @return The computer's current level.
-     */
-    ServerLevel getLevel();
-
-    /**
-     * Get the position this computer is currently at.
-     * <p>
-     * This method is not guaranteed to remain the same (even for stationary computers).
-     *
-     * @return The computer's current position.
-     */
-    BlockPos getPosition();
-
-    /**
-     * Get the label for this computer.
-     *
-     * @return This computer's label, or {@code null} if it is not set.
-     */
-    @Nullable
-    String getLabel();
-
-    /**
-     * Get a component attached to this computer.
-     * <p>
-     * No component is guaranteed to be on a computer, and so this method should always be guarded with a null check.
-     * <p>
-     * This method will always return the same value for a given component, and so may be cached.
-     *
-     * @param component The component to query.
-     * @param <T>       The type of the component.
-     * @return The component, if present.
-     */
-    <T> @Nullable T getComponent(ComputerComponent<T> component);
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/media/IMedia.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/media/IMedia.java
@@ -7,12 +7,15 @@ package dan200.computercraft.api.media;
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.filesystem.Mount;
 import dan200.computercraft.api.filesystem.WritableMount;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
-import net.minecraft.sounds.SoundEvent;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
-import org.jspecify.annotations.Nullable;
+import net.minecraft.world.item.JukeboxSong;
+
+import javax.annotation.Nullable;

 /**
 * Represents an item that can be placed in a disk drive and used by a Computer.
@@ -24,11 +27,12 @@ public interface IMedia {
    /**
     * Get a string representing the label of this item. Will be called via {@code disk.getLabel()} in lua.
     *
-     * @param stack The {@link ItemStack} to inspect.
+     * @param registries The currently loaded registries.
+     * @param stack      The {@link ItemStack} to inspect.
     * @return The label. ie: "Dan's Programs".
     */
    @Nullable
-    String getLabel(ItemStack stack);
+    String getLabel(HolderLookup.Provider registries, ItemStack stack);

    /**
     * Set a string representing the label of this item. Will be called vi {@code disk.setLabel()} in lua.
@@ -42,26 +46,15 @@ public interface IMedia {
    }

    /**
-     * If this disk represents an item with audio (like a record), get the readable name of the audio track. ie:
-     * "Jonathan Coulton - Still Alive"
+     * If this disk represents an item with audio (like a record), get the corresponding {@link JukeboxSong}.
     *
-     * @param stack The {@link ItemStack} to modify.
-     * @return The name, or null if this item does not represent an item with audio.
+     * @param registries The currently loaded registries.
+     * @param stack      The {@link ItemStack} to query.
+     * @return The song, or null if this item does not represent an item with audio.
     */
    @Nullable
-    default String getAudioTitle(ItemStack stack) {
-        return null;
-    }
-
-    /**
-     * If this disk represents an item with audio (like a record), get the resource name of the audio track to play.
-     *
-     * @param stack The {@link ItemStack} to modify.
-     * @return The name, or null if this item does not represent an item with audio.
-     */
-    @Nullable
-    default SoundEvent getAudio(ItemStack stack) {
-        return null;
+    default Holder<JukeboxSong> getAudio(HolderLookup.Provider registries, ItemStack stack) {
+        return JukeboxSong.fromStack(registries, stack).orElse(null);
    }

    /**
--- a/projects/common-api/src/main/java/dan200/computercraft/api/media/MediaProvider.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/media/MediaProvider.java
@@ -5,7 +5,8 @@
 package dan200.computercraft.api.media;

 import net.minecraft.world.item.ItemStack;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

 /**
 * This interface is used to provide {@link IMedia} implementations for {@link ItemStack}.
--- a/projects/common-api/src/main/java/dan200/computercraft/api/media/PrintoutContents.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/media/PrintoutContents.java
@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.media;
-
-import dan200.computercraft.impl.ComputerCraftAPIService;
-import net.minecraft.world.item.ItemStack;
-import org.jspecify.annotations.Nullable;
-
-import java.util.stream.Stream;
-
-/**
- * The contents of a page (or book) created by a ComputerCraft printer.
- *
- * @since 1.115
- */
-@Nullable
-public interface PrintoutContents {
-    /**
-     * Get the (possibly empty) title for this printout.
-     *
-     * @return The title of this printout.
-     */
-    String getTitle();
-
-    /**
-     * Get the text contents of this printout, as a sequence of lines.
-     * <p>
-     * The lines in the printout may include blank lines at the end of the document, as well as trailing spaces on each
-     * line.
-     *
-     * @return The text contents of this printout.
-     */
-    Stream<String> getTextLines();
-
-    /**
-     * Get the printout contents for a particular stack.
-     *
-     * @param stack The stack to get the contents for.
-     * @return The printout contents, or {@code null} if this is not a printout item.
-     */
-    static @Nullable PrintoutContents get(ItemStack stack) {
-        return ComputerCraftAPIService.get().getPrintoutContents(stack);
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredElement.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredElement.java
@@ -14,13 +14,13 @@ import dan200.computercraft.api.ComputerCraftAPI;
 * as a proxy for all network objects. Whilst the node may change networks, an element's node should remain constant
 * for its lifespan.
 * <p>
- * Elements are generally tied to a block or block entity in world. In such as case, one should provide the
+ * Elements are generally tied to a block or tile entity in world. In such as case, one should provide the
 * {@link WiredElement} capability for the appropriate sides.
 */
 public interface WiredElement extends WiredSender {
    /**
-     * Called when peripherals on the network change. This may occur when network nodes are added or removed, or when
-     * peripherals are attached or detached from a modem.
+     * Called when objects on the network change. This may occur when network nodes are added or removed, or when
+     * peripherals change.
     *
     * @param change The change which occurred.
     * @see WiredNetworkChange
--- a/projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredNetwork.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredNetwork.java
@@ -1,92 +0,0 @@
-// SPDX-FileCopyrightText: 2018 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.network.wired;
-
-import dan200.computercraft.api.peripheral.IPeripheral;
-import org.jetbrains.annotations.ApiStatus;
-
-import java.util.Map;
-
-/**
- * A wired network is composed of one of more {@link WiredNode}s, a set of connections between them, and a series
- * of peripherals.
- * <p>
- * Networks from a connected graph. This means there is some path between all nodes on the network. Further more, if
- * there is some path between two nodes then they must be on the same network. {@link WiredNetwork} will automatically
- * handle the merging and splitting of networks (and thus changing of available nodes and peripherals) as connections
- * change.
- * <p>
- * This does mean one can not rely on the network remaining consistent between subsequent operations. Consequently,
- * it is generally preferred to use the methods provided by {@link WiredNode}.
- *
- * @see WiredNode#getNetwork()
- */
-@ApiStatus.NonExtendable
-public interface WiredNetwork {
-    /**
-     * Create a connection between two nodes.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @param left  The first node to connect
-     * @param right The second node to connect
-     * @return {@code true} if a connection was created or {@code false} if the connection already exists.
-     * @throws IllegalStateException    If neither node is on the network.
-     * @throws IllegalArgumentException If {@code left} and {@code right} are equal.
-     * @see WiredNode#connectTo(WiredNode)
-     * @see WiredNetwork#connect(WiredNode, WiredNode)
-     * @deprecated Use {@link WiredNode#connectTo(WiredNode)}
-     */
-    @Deprecated
-    boolean connect(WiredNode left, WiredNode right);
-
-    /**
-     * Destroy a connection between this node and another.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @param left  The first node in the connection.
-     * @param right The second node in the connection.
-     * @return {@code true} if a connection was destroyed or {@code false} if no connection exists.
-     * @throws IllegalArgumentException If either node is not on the network.
-     * @throws IllegalArgumentException If {@code left} and {@code right} are equal.
-     * @see WiredNode#disconnectFrom(WiredNode)
-     * @see WiredNetwork#connect(WiredNode, WiredNode)
-     * @deprecated Use {@link WiredNode#disconnectFrom(WiredNode)}
-     */
-    @Deprecated
-    boolean disconnect(WiredNode left, WiredNode right);
-
-    /**
-     * Sever all connections this node has, removing it from this network.
-     * <p>
-     * This should only be used on the server thread. You should only call this on nodes
-     * that your network element owns.
-     *
-     * @param node The node to remove
-     * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the
-     * only element.
-     * @throws IllegalArgumentException If the node is not in the network.
-     * @see WiredNode#remove()
-     * @deprecated Use {@link WiredNode#remove()}
-     */
-    @Deprecated
-    boolean remove(WiredNode node);
-
-    /**
-     * Update the peripherals a node provides.
-     * <p>
-     * This should only be used on the server thread. You should only call this on nodes
-     * that your network element owns.
-     *
-     * @param node        The node to attach peripherals for.
-     * @param peripherals The new peripherals for this node.
-     * @throws IllegalArgumentException If the node is not in the network.
-     * @see WiredNode#updatePeripherals(Map)
-     * @deprecated Use {@link WiredNode#updatePeripherals(Map)}
-     */
-    @Deprecated
-    void updatePeripherals(WiredNode node, Map<String, IPeripheral> peripherals);
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredNode.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredNode.java
@@ -11,7 +11,7 @@ import org.jetbrains.annotations.ApiStatus;
 import java.util.Map;

 /**
- * Wired nodes act as a layer between {@link WiredElement}s and {@link WiredNetwork}s.
+ * A single node on a wired network.
 * <p>
 * Firstly, a node acts as a packet network, capable of sending and receiving modem messages to connected nodes. These
 * methods may be safely used on any thread.
@@ -32,18 +32,6 @@ public interface WiredNode extends PacketNetwork {
     */
    WiredElement getElement();

-    /**
-     * The network this node is currently connected to. Note that this may change
-     * after any network operation, so it should not be cached.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @return This node's network.
-     * @deprecated Use the connect/disconnect/remove methods on {@link WiredNode}.
-     */
-    @Deprecated
-    WiredNetwork getNetwork();
-
    /**
     * Create a connection from this node to another.
     * <p>
--- a/projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredSender.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredSender.java
@@ -8,10 +8,12 @@ import dan200.computercraft.api.network.PacketSender;


 /**
- * An object on a {@link WiredNetwork} capable of sending packets.
+ * An object on a wired network capable of sending packets.
 * <p>
 * Unlike a regular {@link PacketSender}, this must be associated with the node you are attempting to
 * to send the packet from.
+ *
+ * @see WiredElement
 */
 public interface WiredSender extends PacketSender {
    /**
--- a/projects/common-api/src/main/java/dan200/computercraft/api/pocket/AbstractPocketUpgrade.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/pocket/AbstractPocketUpgrade.java
@@ -4,8 +4,7 @@

 package dan200.computercraft.api.pocket;

-import dan200.computercraft.api.upgrades.UpgradeBase;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;


@@ -15,27 +14,20 @@ import net.minecraft.world.item.ItemStack;
 * One does not have to use this, but it does provide a convenient template.
 */
 public abstract class AbstractPocketUpgrade implements IPocketUpgrade {
-    private final ResourceLocation id;
-    private final String adjective;
+    private final Component adjective;
    private final ItemStack stack;

-    protected AbstractPocketUpgrade(ResourceLocation id, String adjective, ItemStack stack) {
-        this.id = id;
+    protected AbstractPocketUpgrade(Component adjective, ItemStack stack) {
        this.adjective = adjective;
        this.stack = stack;
    }

-    protected AbstractPocketUpgrade(ResourceLocation id, ItemStack stack) {
-        this(id, UpgradeBase.getDefaultAdjective(id), stack);
+    protected AbstractPocketUpgrade(String adjective, ItemStack stack) {
+        this(Component.translatable(adjective), stack);
    }

    @Override
-    public final ResourceLocation getUpgradeID() {
-        return id;
-    }
-
-    @Override
-    public final String getUnlocalisedAdjective() {
+    public final Component getAdjective() {
        return adjective;
    }

--- a/projects/common-api/src/main/java/dan200/computercraft/api/pocket/IPocketAccess.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/pocket/IPocketAccess.java
@@ -4,39 +4,17 @@

 package dan200.computercraft.api.pocket;

-import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeData;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.level.ServerLevel;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.phys.Vec3;
-import org.jetbrains.annotations.ApiStatus;
-import org.jspecify.annotations.Nullable;

-import java.util.Map;
+import javax.annotation.Nullable;

 /**
 * Wrapper class for pocket computers.
 */
-@ApiStatus.NonExtendable
 public interface IPocketAccess {
-    /**
-     * Get the level in which the pocket computer exists.
-     *
-     * @return The pocket computer's level.
-     */
-    ServerLevel getLevel();
-
-    /**
-     * Get the position of the pocket computer.
-     *
-     * @return The pocket computer's position.
-     */
-    Vec3 getPosition();
-
    /**
     * Gets the entity holding this item.
     * <p>
@@ -83,45 +61,25 @@ public interface IPocketAccess {
     */
    void setLight(int colour);

-    /**
-     * Get the currently equipped upgrade.
-     *
-     * @return The currently equipped upgrade.
-     * @see #getUpgradeNBTData()
-     * @see #setUpgrade(UpgradeData)
-     */
-    @Nullable
-    UpgradeData<IPocketUpgrade> getUpgrade();
-
-    /**
-     * Set the upgrade for this pocket computer, also updating the item stack.
-     * <p>
-     * Note this method is not thread safe - it must be called from the server thread.
-     *
-     * @param upgrade The new upgrade to set it to, may be {@code null}.
-     * @see #getUpgrade()
-     */
-    void setUpgrade(@Nullable UpgradeData<IPocketUpgrade> upgrade);
-
    /**
     * Get the upgrade-specific NBT.
     * <p>
     * This is persisted between computer reboots and chunk loads.
     *
     * @return The upgrade's NBT.
-     * @see #updateUpgradeNBTData()
-     * @see UpgradeBase#getUpgradeItem(CompoundTag)
+     * @see #setUpgradeData(DataComponentPatch)
+     * @see UpgradeBase#getUpgradeItem(DataComponentPatch)
     * @see UpgradeBase#getUpgradeData(ItemStack)
-     * @see #getUpgrade()
     */
-    CompoundTag getUpgradeNBTData();
+    DataComponentPatch getUpgradeData();

    /**
-     * Mark the upgrade-specific NBT as dirty.
+     * Update the upgrade-specific data.
     *
-     * @see #getUpgradeNBTData()
+     * @param data The new upgrade data.
+     * @see #getUpgradeData()
     */
-    void updateUpgradeNBTData();
+    void setUpgradeData(DataComponentPatch data);

    /**
     * Remove the current peripheral and create a new one.
@@ -130,13 +88,4 @@ public interface IPocketAccess {
     * entity} changes.
     */
    void invalidatePeripheral();
-
-    /**
-     * Get a list of all upgrades for the pocket computer.
-     *
-     * @return A collection of all upgrade names.
-     * @deprecated This is a relic of a previous API, which no longer makes sense with newer versions of ComputerCraft.
-     */
-    @Deprecated(forRemoval = true)
-    Map<ResourceLocation, IPeripheral> getUpgrades();
 }
--- a/projects/common-api/src/main/java/dan200/computercraft/api/pocket/IPocketUpgrade.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/pocket/IPocketUpgrade.java
@@ -4,21 +4,69 @@

 package dan200.computercraft.api.pocket;

+import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import dan200.computercraft.impl.ComputerCraftAPIService;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.Level;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

 /**
 * A peripheral which can be equipped to the back side of a pocket computer.
 * <p>
- * Pocket upgrades are defined in two stages. First, on creates a {@link IPocketUpgrade} subclass and corresponding
- * {@link PocketUpgradeSerialiser} instance, which are then registered in a Minecraft registry.
+ * Pocket upgrades are defined in two stages. First, one creates a {@link IPocketUpgrade} subclass and corresponding
+ * {@link UpgradeType} instance, which are then registered in a registry.
 * <p>
 * You then write a JSON file in your mod's {@literal data/} folder. This is then parsed when the world is loaded, and
- * the upgrade registered internally.
+ * the upgrade automatically registered. It is recommended this is done via
+ * <a href="../upgrades/UpgradeType.html#datagen">data generators</a>.
+ *
+ * <h2>Example</h2>
+ * {@snippet lang="java" :
+ * // We use Forge's DeferredRegister to register our upgrade type. Fabric mods may register their type directly.
+ * static final DeferredRegister<UpgradeType<? extends IPocketUpgrade>> POCKET_UPGRADES = DeferredRegister.create(IPocketUpgrade.typeRegistry(), "my_mod");
+ *
+ * // Register a new upgrade upgrade type called "my_upgrade".
+ * public static final RegistryObject<UpgradeType<MyUpgrade>> MY_UPGRADE =
+ *     POCKET_UPGRADES.register("my_upgrade", () -> UpgradeType.simple(new MyUpgrade()));
+ *
+ * // Then in your constructor
+ * POCKET_UPGRADES.register(bus);
+ * }
+ * <p>
+ * We can then define a new upgrade using JSON by placing the following in
+ * {@code data/<my_mod>/computercraft/pocket_upgrade/<my_upgrade_id>.json}.
+ * {@snippet lang="json" :
+ * {
+ *     "type": "my_mod:my_upgrade"
+ * }
+ * }
 */
 public interface IPocketUpgrade extends UpgradeBase {
+    ResourceKey<Registry<IPocketUpgrade>> REGISTRY = ResourceKey.createRegistryKey(ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "pocket_upgrade"));
+
+    /**
+     * The registry key for pocket upgrade types.
+     *
+     * @return The registry key.
+     */
+    static ResourceKey<Registry<UpgradeType<? extends IPocketUpgrade>>> typeRegistry() {
+        return ComputerCraftAPIService.get().pocketUpgradeRegistryId();
+    }
+
+    /**
+     * Get the type of this upgrade.
+     *
+     * @return The type of this upgrade.
+     */
+    @Override
+    UpgradeType<? extends IPocketUpgrade> getType();
+
    /**
     * Creates a peripheral for the pocket computer.
     * <p>
--- a/projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketUpgradeDataProvider.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketUpgradeDataProvider.java
@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.pocket;
-
-import dan200.computercraft.api.upgrades.UpgradeDataProvider;
-import net.minecraft.data.DataGenerator;
-import net.minecraft.data.PackOutput;
-
-import java.util.function.Consumer;
-
-/**
- * A data provider to generate pocket computer upgrades.
- * <p>
- * This should be subclassed and registered to a {@link DataGenerator.PackGenerator}. Override the
- * {@link #addUpgrades(Consumer)} function, construct each upgrade, and pass them off to the provided consumer to
- * generate them.
- *
- * @see PocketUpgradeSerialiser
- */
-public abstract class PocketUpgradeDataProvider extends UpgradeDataProvider<IPocketUpgrade, PocketUpgradeSerialiser<?>> {
-    public PocketUpgradeDataProvider(PackOutput output) {
-        super(output, "Pocket Computer Upgrades", "computercraft/pocket_upgrades", PocketUpgradeSerialiser.registryId());
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketUpgradeSerialiser.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketUpgradeSerialiser.java
@@ -1,79 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.pocket;
-
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeSerialiser;
-import dan200.computercraft.impl.ComputerCraftAPIService;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.core.Registry;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.crafting.SimpleCraftingRecipeSerializer;
-
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-/**
- * Reads a {@link IPocketUpgrade} from disk and reads/writes it to a network packet.
- * <p>
- * This follows the same format as {@link dan200.computercraft.api.turtle.TurtleUpgradeSerialiser} - consult the
- * documentation there for more information.
- *
- * @param <T> The type of pocket computer upgrade this is responsible for serialising.
- * @see IPocketUpgrade
- * @see PocketUpgradeDataProvider
- */
-public interface PocketUpgradeSerialiser<T extends IPocketUpgrade> extends UpgradeSerialiser<T> {
-    /**
-     * The ID for the associated registry.
-     *
-     * @return The registry key.
-     */
-    static ResourceKey<Registry<PocketUpgradeSerialiser<?>>> registryId() {
-        return ComputerCraftAPIService.get().pocketUpgradeRegistryId();
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade. This is similar to a {@link SimpleCraftingRecipeSerializer},
-     * but for upgrades.
-     * <p>
-     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(BiFunction)} instead.
-     *
-     * @param factory Generate a new upgrade with a specific ID.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade
-     */
-    static <T extends IPocketUpgrade> PocketUpgradeSerialiser<T> simple(Function<ResourceLocation, T> factory) {
-        final class Impl extends SimpleSerialiser<T> implements PocketUpgradeSerialiser<T> {
-            private Impl(Function<ResourceLocation, T> constructor) {
-                super(constructor);
-            }
-        }
-
-        return new Impl(factory);
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade whose crafting item can be specified.
-     *
-     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
-     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade.
-     * @see #simple(Function)  For upgrades whose crafting stack should not vary.
-     */
-    static <T extends IPocketUpgrade> PocketUpgradeSerialiser<T> simpleWithCustomItem(BiFunction<ResourceLocation, ItemStack, T> factory) {
-        final class Impl extends SerialiserWithCraftingItem<T> implements PocketUpgradeSerialiser<T> {
-            private Impl(BiFunction<ResourceLocation, ItemStack, T> factory) {
-                super(factory);
-            }
-        }
-
-        return new Impl(factory);
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/AbstractTurtleUpgrade.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/AbstractTurtleUpgrade.java
@@ -4,8 +4,7 @@

 package dan200.computercraft.api.turtle;

-import dan200.computercraft.api.upgrades.UpgradeBase;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;


@@ -15,34 +14,27 @@ import net.minecraft.world.item.ItemStack;
 * One does not have to use this, but it does provide a convenient template.
 */
 public abstract class AbstractTurtleUpgrade implements ITurtleUpgrade {
-    private final ResourceLocation id;
    private final TurtleUpgradeType type;
-    private final String adjective;
+    private final Component adjective;
    private final ItemStack stack;

-    protected AbstractTurtleUpgrade(ResourceLocation id, TurtleUpgradeType type, String adjective, ItemStack stack) {
-        this.id = id;
+    protected AbstractTurtleUpgrade(TurtleUpgradeType type, Component adjective, ItemStack stack) {
        this.type = type;
        this.adjective = adjective;
        this.stack = stack;
    }

-    protected AbstractTurtleUpgrade(ResourceLocation id, TurtleUpgradeType type, ItemStack stack) {
-        this(id, type, UpgradeBase.getDefaultAdjective(id), stack);
+    protected AbstractTurtleUpgrade(TurtleUpgradeType type, String adjective, ItemStack stack) {
+        this(type, Component.translatable(adjective), stack);
    }

    @Override
-    public final ResourceLocation getUpgradeID() {
-        return id;
-    }
-
-    @Override
-    public final String getUnlocalisedAdjective() {
+    public final Component getAdjective() {
        return adjective;
    }

    @Override
-    public final TurtleUpgradeType getType() {
+    public final TurtleUpgradeType getUpgradeType() {
        return type;
    }

--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/ITurtleAccess.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/ITurtleAccess.java
@@ -12,12 +12,13 @@ import dan200.computercraft.api.upgrades.UpgradeBase;
 import dan200.computercraft.api.upgrades.UpgradeData;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.world.Container;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.ApiStatus;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

 /**
 * The interface passed to turtle by turtles, providing methods that they can call.
@@ -228,37 +229,22 @@ public interface ITurtleAccess {
     * @param side The side to get the upgrade from.
     * @return The upgrade on the specified side of the turtle, if there is one.
     * @see #getUpgradeWithData(TurtleSide)
-     * @see #setUpgradeWithData(TurtleSide, UpgradeData)
+     * @see #setUpgrade(TurtleSide, UpgradeData)
     */
    @Nullable
    ITurtleUpgrade getUpgrade(TurtleSide side);

    /**
-     * Returns the upgrade on the specified side of the turtle, along with its {@linkplain #getUpgradeNBTData(TurtleSide)
+     * Returns the upgrade on the specified side of the turtle, along with its {@linkplain #getUpgradeData(TurtleSide)
     * update data}.
     *
     * @param side The side to get the upgrade from.
     * @return The upgrade on the specified side of the turtle, along with its upgrade data, if there is one.
     * @see #getUpgradeWithData(TurtleSide)
-     * @see #setUpgradeWithData(TurtleSide, UpgradeData)
+     * @see #setUpgrade(TurtleSide, UpgradeData)
     */
-    default @Nullable UpgradeData<ITurtleUpgrade> getUpgradeWithData(TurtleSide side) {
-        var upgrade = getUpgrade(side);
-        return upgrade == null ? null : UpgradeData.of(upgrade, getUpgradeNBTData(side));
-    }
-
-    /**
-     * Set the upgrade for a given side, resetting peripherals and clearing upgrade specific data.
-     *
-     * @param side    The side to set the upgrade on.
-     * @param upgrade The upgrade to set, may be {@code null} to clear.
-     * @see #getUpgrade(TurtleSide)
-     * @deprecated Use {@link #setUpgradeWithData(TurtleSide, UpgradeData)}
-     */
-    @Deprecated
-    default void setUpgrade(TurtleSide side, @Nullable ITurtleUpgrade upgrade) {
-        setUpgradeWithData(side, upgrade == null ? null : UpgradeData.ofDefault(upgrade));
-    }
+    @Nullable
+    UpgradeData<ITurtleUpgrade> getUpgradeWithData(TurtleSide side);

    /**
     * Set the upgrade for a given side and its upgrade data.
@@ -267,7 +253,7 @@ public interface ITurtleAccess {
     * @param upgrade The upgrade to set, may be {@code null} to clear.
     * @see #getUpgradeWithData(TurtleSide)
     */
-    void setUpgradeWithData(TurtleSide side, @Nullable UpgradeData<ITurtleUpgrade> upgrade);
+    void setUpgrade(TurtleSide side, @Nullable UpgradeData<ITurtleUpgrade> upgrade);

    /**
     * Returns the peripheral created by the upgrade on the specified side of the turtle, if there is one.
@@ -281,23 +267,23 @@ public interface ITurtleAccess {
    /**
     * Get an upgrade-specific NBT compound, which can be used to store arbitrary data.
     * <p>
-     * This will be persisted across turtle restarts and chunk loads, as well as being synced to the client. You must
-     * call {@link #updateUpgradeNBTData(TurtleSide)} after modifying it.
+     * This will be persisted across turtle restarts and chunk loads, as well as being synced to the client. You can
+     * call {@link #setUpgrade(TurtleSide, UpgradeData)} to modify it.
     *
     * @param side The side to get the upgrade data for.
     * @return The upgrade-specific data.
-     * @see #updateUpgradeNBTData(TurtleSide)
-     * @see UpgradeBase#getUpgradeItem(CompoundTag)
+     * @see #setUpgradeData(TurtleSide, DataComponentPatch)
+     * @see UpgradeBase#getUpgradeItem(DataComponentPatch)
     * @see UpgradeBase#getUpgradeData(ItemStack)
     */
-    CompoundTag getUpgradeNBTData(TurtleSide side);
+    DataComponentPatch getUpgradeData(TurtleSide side);

    /**
-     * Mark the upgrade-specific data as dirty on a specific side. This is required for the data to be synced to the
-     * client and persisted.
+     * Update the upgrade-specific data.
     *
-     * @param side The side to mark dirty.
-     * @see #updateUpgradeNBTData(TurtleSide)
+     * @param side The side to set the upgrade data for.
+     * @param data The new upgrade data.
+     * @see #getUpgradeData(TurtleSide)
     */
-    void updateUpgradeNBTData(TurtleSide side);
+    void setUpgradeData(TurtleSide side, DataComponentPatch data);
 }
--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/ITurtleUpgrade.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/ITurtleUpgrade.java
@@ -4,82 +4,97 @@

 package dan200.computercraft.api.turtle;

+import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import dan200.computercraft.impl.ComputerCraftAPIService;
 import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.world.item.Items;
-import org.jspecify.annotations.Nullable;
+import net.minecraft.core.Registry;
+import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;

-import java.util.function.BiFunction;
+import javax.annotation.Nullable;

 /**
 * The primary interface for defining an update for Turtles. A turtle update can either be a new tool, or a new
 * peripheral.
 * <p>
 * Turtle upgrades are defined in two stages. First, one creates a {@link ITurtleUpgrade} subclass and corresponding
- * {@link TurtleUpgradeSerialiser} instance, which are then registered in a Minecraft registry.
+ * {@link UpgradeType} instance, which are then registered in a registry.
 * <p>
 * You then write a JSON file in your mod's {@literal data/} folder. This is then parsed when the world is loaded, and
- * the upgrade automatically registered.
+ * the upgrade automatically registered. It is recommended this is done via
+ * <a href="../upgrades/UpgradeType.html#datagen">data generators</a>.
 *
 * <h2>Example</h2>
- * <h3>Registering the upgrade serialiser</h3>
- * First, let's create a new class that implements {@link ITurtleUpgrade}. It is recommended to subclass
- * {@link AbstractTurtleUpgrade}, as that provides a default implementation of most methods.
+ * {@snippet lang="java" :
+ * // We use Forge's DeferredRegister to register our upgrade type. Fabric mods may register their type directly.
+ * static final DeferredRegister<UpgradeType<? extends ITurtleUpgrade>> TURTLE_UPGRADES = DeferredRegister.create(ITurtleUpgrade.typeRegistry(), "my_mod");
+ *
+ * // Register a new upgrade type called "my_upgrade".
+ * public static final RegistryObject<UpgradeType<MyUpgrade>> MY_UPGRADE =
+ *     TURTLE_UPGRADES.register("my_upgrade", () -> UpgradeType.simple(MyUpgrade::new));
+ *
+ * // Then in your constructor
+ * TURTLE_UPGRADES.register(bus);
+ * }
 * <p>
- * {@snippet class=com.example.examplemod.ExampleTurtleUpgrade region=body}
+ * We can then define a new upgrade using JSON by placing the following in
+ * {@code data/<my_mod>/computercraft/turtle_upgrade/<my_upgrade_id>.json}.
 * <p>
- * Now we must construct a new upgrade serialiser. In most cases, you can use one of the helper methods
- * (e.g. {@link TurtleUpgradeSerialiser#simpleWithCustomItem(BiFunction)}), rather than defining your own implementation.
- *
- * {@snippet class=com.example.examplemod.ExampleMod region=turtle_upgrades}
- *
- * We now must register this upgrade serialiser. This is done the same way as you'd register blocks, items, or other
- * Minecraft objects. The approach to do this will depend on mod-loader.
- *
- * <h4>Fabric</h4>
- * {@snippet class=com.example.examplemod.FabricExampleMod region=turtle_upgrades}
- *
- * <h4>Forge</h4>
- * {@snippet class=com.example.examplemod.ForgeExampleMod region=turtle_upgrades}
- *
- * <h3>Rendering the upgrade</h3>
- * Next, we need to register a model for our upgrade. This is done by registering a
- * {@link dan200.computercraft.api.client.turtle.TurtleUpgradeModeller} for your upgrade serialiser.
- *
- * <h4>Fabric</h4>
- * {@snippet class=com.example.examplemod.FabricExampleModClient region=turtle_modellers}
- *
- *
- * <h4>Forge</h4>
- * {@snippet class=com.example.examplemod.FabricExampleModClient region=turtle_modellers}
- *
- * <h3>Registering the upgrade itself</h3>
- * Upgrades themselves are loaded from datapacks when a level is loaded. In order to register our new upgrade, we must
- * create a new JSON file at {@code data/<my_mod>/computercraft/turtle_upgrades/<my_upgrade_id>.json}.
- *
- * {@snippet file = data/examplemod/computercraft/turtle_upgrades/example_turtle_upgrade.json}
- *
- * The {@code "type"} field points to the ID of the upgrade serialiser we've just registered, while the other fields
- * are read by the serialiser itself. As our upgrade was defined with {@link TurtleUpgradeSerialiser#simpleWithCustomItem(BiFunction)}, the
- * {@code "item"} field will construct our upgrade with {@link Items#COMPASS}.
+ * {@snippet lang="json" :
+ * {
+ *     "type": "my_mod:my_upgrade"
+ * }
+ * }
 * <p>
- * Rather than manually creating the file, it is recommended to data-generators to generate this file. This can be done
- * with {@link TurtleUpgradeDataProvider}.
- *
- * {@snippet class=com.example.examplemod.data.TurtleDataProvider region=body}
- *
- * @see TurtleUpgradeSerialiser Registering a turtle upgrade.
+ * Finally, we need to register a model for our upgrade, see
+ * {@link dan200.computercraft.api.client.turtle.TurtleUpgradeModeller} for more information.
 */
 public interface ITurtleUpgrade extends UpgradeBase {
+    /**
+     * The registry in which turtle upgrades are stored.
+     */
+    ResourceKey<Registry<ITurtleUpgrade>> REGISTRY = ResourceKey.createRegistryKey(ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "turtle_upgrade"));
+
+    /**
+     * Create a {@link ResourceKey} for a turtle upgrade given a {@link ResourceLocation}.
+     * <p>
+     * This should only be called from within data generation code. Do not hard code references to your upgrades!
+     *
+     * @param id The id of the turtle upgrade.
+     * @return The upgrade registry key.
+     */
+    static ResourceKey<ITurtleUpgrade> createKey(ResourceLocation id) {
+        return ResourceKey.create(REGISTRY, id);
+    }
+
+    /**
+     * The registry key for turtle upgrade types.
+     *
+     * @return The registry key.
+     */
+    static ResourceKey<Registry<UpgradeType<? extends ITurtleUpgrade>>> typeRegistry() {
+        return ComputerCraftAPIService.get().turtleUpgradeRegistryId();
+    }
+
+    /**
+     * Get the type of this upgrade.
+     *
+     * @return The type of this upgrade.
+     */
+    @Override
+    UpgradeType<? extends ITurtleUpgrade> getType();
+
    /**
     * Return whether this turtle adds a tool or a peripheral to the turtle.
     *
     * @return The type of upgrade this is.
     * @see TurtleUpgradeType for the differences between them.
     */
-    TurtleUpgradeType getType();
+    TurtleUpgradeType getUpgradeType();

    /**
     * Will only be called for peripheral upgrades. Creates a peripheral for a turtle being placed using this upgrade.
@@ -138,7 +153,7 @@ public interface ITurtleUpgrade extends UpgradeBase {
     * @param upgradeData Data that currently stored for this upgrade
     * @return Filtered version of this data.
     */
-    default CompoundTag getPersistedData(CompoundTag upgradeData) {
+    default DataComponentPatch getPersistedData(DataComponentPatch upgradeData) {
        return upgradeData;
    }
 }
--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleCommandResult.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleCommandResult.java
@@ -5,7 +5,8 @@
 package dan200.computercraft.api.turtle;

 import net.minecraft.core.Direction;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

 /**
 * Used to indicate the result of executing a turtle command.
@@ -59,9 +60,9 @@ public final class TurtleCommandResult {

    private final boolean success;
    private final @Nullable String errorMessage;
-    private final @Nullable Object @Nullable [] results;
+    private final @Nullable Object[] results;

-    private TurtleCommandResult(boolean success, @Nullable String errorMessage, @Nullable Object @Nullable [] results) {
+    private TurtleCommandResult(boolean success, @Nullable String errorMessage, @Nullable Object[] results) {
        this.success = success;
        this.errorMessage = errorMessage;
        this.results = results;
@@ -91,7 +92,8 @@ public final class TurtleCommandResult {
     *
     * @return The command's result, or {@code null} if it was a failure.
     */
-    public @Nullable Object @Nullable [] getResults() {
+    @Nullable
+    public Object[] getResults() {
        return results;
    }
 }
--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleSide.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleSide.java
@@ -5,7 +5,7 @@
 package dan200.computercraft.api.turtle;

 /**
- * An enum representing the two sides of the turtle that a turtle upgrade might reside.
+ * An enum representing the two sides of the turtle that a turtle turtle might reside.
 */
 public enum TurtleSide {
    /**
--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleToolBuilder.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleToolBuilder.java
@@ -0,0 +1,157 @@
+// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.turtle;
+
+import dan200.computercraft.api.ComputerCraftTags;
+import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.impl.ComputerCraftAPIService;
+import dan200.computercraft.impl.upgrades.TurtleToolSpec;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.data.worldgen.BootstrapContext;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Block;
+
+import javax.annotation.Nullable;
+import java.util.Optional;
+
+/**
+ * A builder for custom turtle tool upgrades.
+ * <p>
+ * This can be used from your <a href="../upgrades/UpgradeType.html#datagen">data generator</a> code in order to
+ * register turtle tools for your mod's tools.
+ *
+ * <h2>Example:</h2>
+ * {@snippet lang = "java":
+ * import net.minecraft.data.worldgen.BootstrapContext;
+ * import net.minecraft.resources.ResourceLocation;
+ * import net.minecraft.world.item.Items;
+ *
+ * public void registerTool(BootstrapContext<ITurtleUpgrade> upgrades) {
+ *   TurtleToolBuilder.tool(ResourceLocation.fromNamespaceAndPath("my_mod", "wooden_pickaxe"), Items.WOODEN_PICKAXE).register(upgrades);
+ * }
+ *}
+ */
+public final class TurtleToolBuilder {
+    private final ResourceKey<ITurtleUpgrade> id;
+    private final Item item;
+    private Component adjective;
+    private float damageMultiplier = TurtleToolSpec.DEFAULT_DAMAGE_MULTIPLIER;
+    private @Nullable TagKey<Block> breakable;
+    private boolean allowEnchantments = false;
+    private TurtleToolDurability consumeDurability = TurtleToolDurability.NEVER;
+
+    private TurtleToolBuilder(ResourceKey<ITurtleUpgrade> id, Item item) {
+        this.id = id;
+        adjective = Component.translatable(UpgradeBase.getDefaultAdjective(id.location()));
+        this.item = item;
+    }
+
+    public static TurtleToolBuilder tool(ResourceLocation id, Item item) {
+        return new TurtleToolBuilder(ITurtleUpgrade.createKey(id), item);
+    }
+
+    public static TurtleToolBuilder tool(ResourceKey<ITurtleUpgrade> id, Item item) {
+        return new TurtleToolBuilder(id, item);
+    }
+
+    /**
+     * Get the id for this turtle tool.
+     *
+     * @return The upgrade id.
+     */
+    public ResourceKey<ITurtleUpgrade> id() {
+        return id;
+    }
+
+    /**
+     * Specify a custom adjective for this tool. By default this takes its adjective from the upgrade id.
+     *
+     * @param adjective The new adjective to use.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder adjective(Component adjective) {
+        this.adjective = adjective;
+        return this;
+    }
+
+    /**
+     * The amount of damage a swing of this tool will do. This is multiplied by {@link Attributes#ATTACK_DAMAGE} to
+     * get the final damage.
+     *
+     * @param damageMultiplier The damage multiplier.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder damageMultiplier(float damageMultiplier) {
+        this.damageMultiplier = damageMultiplier;
+        return this;
+    }
+
+    /**
+     * Indicate that this upgrade allows items which have been {@linkplain ItemStack#isEnchanted() enchanted} or have
+     * {@linkplain DataComponents#ATTRIBUTE_MODIFIERS custom attribute modifiers}.
+     *
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder allowEnchantments() {
+        allowEnchantments = true;
+        return this;
+    }
+
+    /**
+     * Set when the tool will consume durability.
+     *
+     * @param durability The durability predicate.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder consumeDurability(TurtleToolDurability durability) {
+        consumeDurability = durability;
+        return this;
+    }
+
+    /**
+     * Provide a list of breakable blocks. If not given, the tool can break all blocks. If given, only blocks
+     * in this tag, those in {@link ComputerCraftTags.Blocks#TURTLE_ALWAYS_BREAKABLE} and "insta-mine" ones can
+     * be broken.
+     *
+     * @param breakable The tag containing all blocks breakable by this item.
+     * @return The tool builder, for further use.
+     * @see ComputerCraftTags.Blocks
+     */
+    public TurtleToolBuilder breakable(TagKey<Block> breakable) {
+        this.breakable = breakable;
+        return this;
+    }
+
+    /**
+     * Build the turtle tool upgrade.
+     *
+     * @return The constructed upgrade.
+     */
+    public ITurtleUpgrade build() {
+        return ComputerCraftAPIService.get().createTurtleTool(new TurtleToolSpec(
+            adjective,
+            item,
+            damageMultiplier,
+            allowEnchantments,
+            consumeDurability,
+            Optional.ofNullable(breakable)
+        ));
+    }
+
+    /**
+     * Build this upgrade and register it for datagen.
+     *
+     * @param upgrades The registry this upgrade should be added to.
+     */
+    public void register(BootstrapContext<ITurtleUpgrade> upgrades) {
+        upgrades.register(id(), build());
+    }
+}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleToolDurability.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleToolDurability.java
@@ -4,14 +4,14 @@

 package dan200.computercraft.api.turtle;

+import net.minecraft.core.component.DataComponents;
 import net.minecraft.util.StringRepresentable;
-import net.minecraft.world.entity.EquipmentSlot;
 import net.minecraft.world.item.ItemStack;

 /**
 * Indicates if an equipped turtle item will consume durability.
 *
- * @see TurtleUpgradeDataProvider.ToolBuilder#consumeDurability(TurtleToolDurability)
+ * @see TurtleToolBuilder#consumeDurability(TurtleToolDurability)
 */
 public enum TurtleToolDurability implements StringRepresentable {
    /**
@@ -21,7 +21,7 @@ public enum TurtleToolDurability implements StringRepresentable {

    /**
     * The equipped tool consumes durability if it is {@linkplain ItemStack#isEnchanted() enchanted} or has
-     * {@linkplain ItemStack#getAttributeModifiers(EquipmentSlot) custom attribute modifiers}.
+     * {@linkplain DataComponents#ATTRIBUTE_MODIFIERS custom attribute modifiers}.
     */
    WHEN_ENCHANTED("when_enchanted"),

--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeDataProvider.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeDataProvider.java
@@ -1,171 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.turtle;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.ComputerCraftTags;
-import dan200.computercraft.api.upgrades.UpgradeDataProvider;
-import dan200.computercraft.impl.PlatformHelper;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.data.DataGenerator;
-import net.minecraft.data.PackOutput;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.tags.TagKey;
-import net.minecraft.world.entity.EquipmentSlot;
-import net.minecraft.world.entity.ai.attributes.Attributes;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.Block;
-import org.jspecify.annotations.Nullable;
-
-import java.util.function.Consumer;
-
-/**
- * A data provider to generate turtle upgrades.
- * <p>
- * This should be subclassed and registered to a {@link DataGenerator.PackGenerator}. Override the
- * {@link #addUpgrades(Consumer)} function, construct each upgrade, and pass them off to the provided consumer to
- * generate them.
- *
- * <h2>Example</h2>
- * {@snippet class=com.example.examplemod.data.TurtleDataProvider region=body}
- *
- * @see TurtleUpgradeSerialiser
- */
-public abstract class TurtleUpgradeDataProvider extends UpgradeDataProvider<ITurtleUpgrade, TurtleUpgradeSerialiser<?>> {
-    private static final ResourceLocation TOOL_ID = new ResourceLocation(ComputerCraftAPI.MOD_ID, "tool");
-
-    public TurtleUpgradeDataProvider(PackOutput output) {
-        super(output, "Turtle Upgrades", "computercraft/turtle_upgrades", TurtleUpgradeSerialiser.registryId());
-    }
-
-    /**
-     * Create a new turtle tool upgrade, such as a pickaxe or shovel.
-     *
-     * @param id   The ID of this tool.
-     * @param item The item used for tool actions. Note, this doesn't inherit all properties of the tool, you may need
-     *             to specify {@link ToolBuilder#damageMultiplier(float)} and {@link ToolBuilder#breakable(TagKey)}.
-     * @return A tool builder,
-     */
-    public final ToolBuilder tool(ResourceLocation id, Item item) {
-        return new ToolBuilder(id, existingSerialiser(TOOL_ID), item);
-    }
-
-    /**
-     * A builder for custom turtle tool upgrades.
-     *
-     * @see #tool(ResourceLocation, Item)
-     */
-    public static class ToolBuilder {
-        private final ResourceLocation id;
-        private final TurtleUpgradeSerialiser<?> serialiser;
-        private final Item toolItem;
-        private @Nullable String adjective;
-        private @Nullable Item craftingItem;
-        private @Nullable Float damageMultiplier = null;
-        private @Nullable TagKey<Block> breakable;
-        private boolean allowEnchantments = false;
-        private TurtleToolDurability consumeDurability = TurtleToolDurability.NEVER;
-
-        ToolBuilder(ResourceLocation id, TurtleUpgradeSerialiser<?> serialiser, Item toolItem) {
-            this.id = id;
-            this.serialiser = serialiser;
-            this.toolItem = toolItem;
-            craftingItem = null;
-        }
-
-        /**
-         * Specify a custom adjective for this tool. By default this takes its adjective from the tool item.
-         *
-         * @param adjective The new adjective to use.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder adjective(String adjective) {
-            this.adjective = adjective;
-            return this;
-        }
-
-        /**
-         * Specify a custom item which is used to craft this upgrade. By default this is the same as the provided tool
-         * item, but you may wish to override it.
-         *
-         * @param craftingItem The item used to craft this upgrade.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder craftingItem(Item craftingItem) {
-            this.craftingItem = craftingItem;
-            return this;
-        }
-
-        /**
-         * The amount of damage a swing of this tool will do. This is multiplied by {@link Attributes#ATTACK_DAMAGE} to
-         * get the final damage.
-         *
-         * @param damageMultiplier The damage multiplier.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder damageMultiplier(float damageMultiplier) {
-            this.damageMultiplier = damageMultiplier;
-            return this;
-        }
-
-        /**
-         * Indicate that this upgrade allows items which have been {@linkplain ItemStack#isEnchanted() enchanted} or have
-         * {@linkplain ItemStack#getAttributeModifiers(EquipmentSlot) custom attribute modifiers}.
-         *
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder allowEnchantments() {
-            allowEnchantments = true;
-            return this;
-        }
-
-        /**
-         * Set when the tool will consume durability.
-         *
-         * @param durability The durability predicate.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder consumeDurability(TurtleToolDurability durability) {
-            consumeDurability = durability;
-            return this;
-        }
-
-        /**
-         * Provide a list of breakable blocks. If not given, the tool can break all blocks. If given, only blocks
-         * in this tag, those in {@link ComputerCraftTags.Blocks#TURTLE_ALWAYS_BREAKABLE} and "insta-mine" ones can
-         * be broken.
-         *
-         * @param breakable The tag containing all blocks breakable by this item.
-         * @return The tool builder, for further use.
-         * @see ComputerCraftTags.Blocks
-         */
-        public ToolBuilder breakable(TagKey<Block> breakable) {
-            this.breakable = breakable;
-            return this;
-        }
-
-        /**
-         * Register this as an upgrade.
-         *
-         * @param add The callback given to {@link #addUpgrades(Consumer)}.
-         */
-        public void add(Consumer<Upgrade<TurtleUpgradeSerialiser<?>>> add) {
-            add.accept(new Upgrade<>(id, serialiser, s -> {
-                s.addProperty("item", PlatformHelper.get().getRegistryKey(Registries.ITEM, toolItem).toString());
-                if (adjective != null) s.addProperty("adjective", adjective);
-                if (craftingItem != null) {
-                    s.addProperty("craftItem", PlatformHelper.get().getRegistryKey(Registries.ITEM, craftingItem).toString());
-                }
-                if (damageMultiplier != null) s.addProperty("damageMultiplier", damageMultiplier);
-                if (breakable != null) s.addProperty("breakable", breakable.location().toString());
-                if (allowEnchantments) s.addProperty("allowEnchantments", true);
-                if (consumeDurability != TurtleToolDurability.NEVER) {
-                    s.addProperty("consumeDurability", consumeDurability.getSerializedName());
-                }
-            }));
-        }
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeSerialiser.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeSerialiser.java
@@ -1,83 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.turtle;
-
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeSerialiser;
-import dan200.computercraft.impl.ComputerCraftAPIService;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.core.Registry;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraft.world.item.crafting.SimpleCraftingRecipeSerializer;
-
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-/**
- * Reads a {@link ITurtleUpgrade} from disk and reads/writes it to a network packet.
- * <p>
- * These should be registered in a {@link Registry} while the game is loading, much like {@link RecipeSerializer}s.
- * <p>
- * If your turtle upgrade doesn't have any associated configurable parameters (like most upgrades), you can use
- * {@link #simple(Function)} or {@link #simpleWithCustomItem(BiFunction)} to create a basic upgrade serialiser.
- *
- * @param <T> The type of turtle upgrade this is responsible for serialising.
- * @see ITurtleUpgrade
- * @see TurtleUpgradeDataProvider
- * @see dan200.computercraft.api.client.turtle.TurtleUpgradeModeller
- */
-public interface TurtleUpgradeSerialiser<T extends ITurtleUpgrade> extends UpgradeSerialiser<T> {
-    /**
-     * The ID for the associated registry.
-     *
-     * @return The registry key.
-     */
-    static ResourceKey<Registry<TurtleUpgradeSerialiser<?>>> registryId() {
-        return ComputerCraftAPIService.get().turtleUpgradeRegistryId();
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade. This is similar to a {@link SimpleCraftingRecipeSerializer},
-     * but for upgrades.
-     * <p>
-     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(BiFunction)} instead.
-     *
-     * @param factory Generate a new upgrade with a specific ID.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade
-     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeSerialiser<T> simple(Function<ResourceLocation, T> factory) {
-        final class Impl extends SimpleSerialiser<T> implements TurtleUpgradeSerialiser<T> {
-            private Impl(Function<ResourceLocation, T> constructor) {
-                super(constructor);
-            }
-        }
-
-        return new Impl(factory);
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade whose crafting item can be specified.
-     *
-     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
-     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade.
-     * @see #simple(Function)  For upgrades whose crafting stack should not vary.
-     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeSerialiser<T> simpleWithCustomItem(BiFunction<ResourceLocation, ItemStack, T> factory) {
-        final class Impl extends SerialiserWithCraftingItem<T> implements TurtleUpgradeSerialiser<T> {
-            private Impl(BiFunction<ResourceLocation, ItemStack, T> factory) {
-                super(factory);
-            }
-        }
-
-        return new Impl(factory);
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeBase.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeBase.java
@@ -9,37 +9,34 @@ import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
-import dan200.computercraft.impl.PlatformHelper;
 import net.minecraft.Util;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;

-import java.util.Objects;
-
 /**
 * Common functionality between {@link ITurtleUpgrade} and {@link IPocketUpgrade}.
 */
 public interface UpgradeBase {
    /**
-     * Gets a unique identifier representing this type of turtle upgrade. eg: "computercraft:wireless_modem"
-     * or "my_mod:my_upgrade".
-     * <p>
-     * You should use a unique resource domain to ensure this upgrade is uniquely identified.
-     * The upgrade will fail registration if an already used ID is specified.
+     * Get the type of this upgrade.
     *
-     * @return The unique ID for this upgrade.
+     * @return The type of this upgrade.
     */
-    ResourceLocation getUpgradeID();
+    UpgradeType<?> getType();

    /**
-     * Return an unlocalised string to describe this type of computer in item names.
+     * A description of this upgrade for use in item names.
+     * <p>
+     * This should typically be a {@linkplain Component#translatable(String) translation key}, rather than a hard coded
+     * string.
     * <p>
     * Examples of built-in adjectives are "Wireless", "Mining" and "Crafty".
     *
-     * @return The localisation key for this upgrade's adjective.
+     * @return The text component for this upgrade's adjective.
     */
-    String getUnlocalisedAdjective();
+    Component getAdjective();

    /**
     * Return an item stack representing the type of item that a computer must be crafted
@@ -57,8 +54,8 @@ public interface UpgradeBase {
    /**
     * Returns the item stack representing a currently equipped turtle upgrade.
     * <p>
-     * While upgrades can store upgrade data ({@link ITurtleAccess#getUpgradeNBTData(TurtleSide)} and
-     * {@link IPocketAccess#getUpgradeNBTData()}}, by default this data is discarded when an upgrade is unequipped,
+     * While upgrades can store upgrade data ({@link ITurtleAccess#getUpgradeData(TurtleSide)} and
+     * {@link IPocketAccess#getUpgradeData()}}, by default this data is discarded when an upgrade is unequipped,
     * and the original item stack is returned.
     * <p>
     * By overriding this method, you can create a new {@link ItemStack} which contains enough data to
@@ -70,24 +67,24 @@ public interface UpgradeBase {
     * @param upgradeData The current upgrade data. This should <strong>NOT</strong> be mutated.
     * @return The item stack returned when unequipping.
     */
-    default ItemStack getUpgradeItem(CompoundTag upgradeData) {
+    default ItemStack getUpgradeItem(DataComponentPatch upgradeData) {
        return getCraftingItem();
    }

    /**
     * Extract upgrade data from an {@link ItemStack}.
     * <p>
-     * This upgrade data will be available with {@link ITurtleAccess#getUpgradeNBTData(TurtleSide)} or
-     * {@link IPocketAccess#getUpgradeNBTData()}.
+     * This upgrade data will be available with {@link ITurtleAccess#getUpgradeData(TurtleSide)} or
+     * {@link IPocketAccess#getUpgradeData()}.
     * <p>
-     * This should be an inverse to {@link #getUpgradeItem(CompoundTag)}.
+     * This should be an inverse to {@link #getUpgradeItem(DataComponentPatch)}.
     *
     * @param stack The stack that was equipped by the turtle or pocket computer. This will have the same item as
     *              {@link #getCraftingItem()}.
     * @return The upgrade data that should be set on the turtle or pocket computer.
     */
-    default CompoundTag getUpgradeData(ItemStack stack) {
-        return new CompoundTag();
+    default DataComponentPatch getUpgradeData(ItemStack stack) {
+        return DataComponentPatch.EMPTY;
    }

    /**
@@ -97,26 +94,15 @@ public interface UpgradeBase {
     * the original stack. In order to prevent people losing items with enchantments (or
     * repairing items with non-0 damage), we impose additional checks on the item.
     * <p>
-     * The default check requires that any non-capability NBT is exactly the same as the
-     * crafting item, but this may be relaxed for your upgrade.
-     * <p>
-     * This is based on {@code net.minecraftforge.common.crafting.StrictNBTIngredient}'s check.
+     * The default check requires that any NBT is exactly the same as the crafting item,
+     * but this may be relaxed for your upgrade.
     *
     * @param stack The stack to check. This is guaranteed to be non-empty and have the same item as
     *              {@link #getCraftingItem()}.
     * @return If this stack may be used to equip this upgrade.
     */
    default boolean isItemSuitable(ItemStack stack) {
-        var crafting = getCraftingItem();
-
-        // A more expanded form of ItemStack.areShareTagsEqual, but allowing an empty tag to be equal to a
-        // null one.
-        var shareTag = PlatformHelper.get().getShareTag(stack);
-        var craftingShareTag = PlatformHelper.get().getShareTag(crafting);
-        if (shareTag == craftingShareTag) return true;
-        if (shareTag == null) return Objects.requireNonNull(craftingShareTag).isEmpty();
-        if (craftingShareTag == null) return shareTag.isEmpty();
-        return shareTag.equals(craftingShareTag);
+        return ItemStack.isSameItemSameComponents(getCraftingItem(), stack);
    }

    /**
@@ -125,7 +111,7 @@ public interface UpgradeBase {
     *
     * @param id The upgrade ID.
     * @return The  generated adjective.
-     * @see #getUnlocalisedAdjective()
+     * @see #getAdjective()
     */
    static String getDefaultAdjective(ResourceLocation id) {
        return Util.makeDescriptionId("upgrade", id) + ".adjective";
--- a/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeData.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeData.java
@@ -6,59 +6,57 @@ package dan200.computercraft.api.upgrades;

 import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.Holder;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.world.item.ItemStack;
-import org.jetbrains.annotations.Contract;
-import org.jspecify.annotations.Nullable;

 /**
 * An upgrade (i.e. a {@link ITurtleUpgrade}) and its current upgrade data.
- * <p>
- * <strong>IMPORTANT:</strong> The {@link #data()} in an upgrade data is often a reference to the original upgrade data.
- * Be careful to take a {@linkplain #copy() defensive copy} if you plan to use the data in this upgrade.
 *
- * @param upgrade The current upgrade.
- * @param data    The upgrade's data.
- * @param <T>     The type of upgrade, either {@link ITurtleUpgrade} or {@link IPocketUpgrade}.
+ * @param holder The current upgrade holder.
+ * @param data   The upgrade's data.
+ * @param <T>    The type of upgrade, either {@link ITurtleUpgrade} or {@link IPocketUpgrade}.
 */
-public record UpgradeData<T extends UpgradeBase>(T upgrade, CompoundTag data) {
+public record UpgradeData<T extends UpgradeBase>(Holder.Reference<T> holder, DataComponentPatch data) {
    /**
     * A utility method to construct a new {@link UpgradeData} instance.
     *
-     * @param upgrade An upgrade.
-     * @param data    The upgrade's data.
-     * @param <T>     The type of upgrade.
+     * @param holder An upgrade.
+     * @param data   The upgrade's data.
+     * @param <T>    The type of upgrade.
     * @return The new {@link UpgradeData} instance.
     */
-    public static <T extends UpgradeBase> UpgradeData<T> of(T upgrade, CompoundTag data) {
-        return new UpgradeData<>(upgrade, data);
+    public static <T extends UpgradeBase> UpgradeData<T> of(Holder.Reference<T> holder, DataComponentPatch data) {
+        return new UpgradeData<>(holder, data);
    }

    /**
     * Create an {@link UpgradeData} containing the default {@linkplain #data() data} for an upgrade.
     *
-     * @param upgrade The upgrade instance.
-     * @param <T>     The type of upgrade.
+     * @param holder The upgrade instance.
+     * @param <T>    The type of upgrade.
     * @return The default upgrade data.
     */
-    public static <T extends UpgradeBase> UpgradeData<T> ofDefault(T upgrade) {
-        return of(upgrade, upgrade.getUpgradeData(upgrade.getCraftingItem()));
+    public static <T extends UpgradeBase> UpgradeData<T> ofDefault(Holder.Reference<T> holder) {
+        var upgrade = holder.value();
+        return of(holder, upgrade.getUpgradeData(upgrade.getCraftingItem()));
+    }
+
+    public UpgradeData {
+        if (!holder.isBound()) throw new IllegalArgumentException("Holder is not bound");
    }

    /**
-     * Take a copy of a (possibly {@code null}) {@link UpgradeData} instance.
+     * Get the current upgrade.
     *
-     * @param upgrade The copied upgrade data.
-     * @param <T>     The type of upgrade.
-     * @return The newly created upgrade data.
+     * @return The current upgrade.
     */
-    @Contract("!null -> !null; null -> null")
-    public static <T extends UpgradeBase> @Nullable UpgradeData<T> copyOf(@Nullable UpgradeData<T> upgrade) {
-        return upgrade == null ? null : upgrade.copy();
+    public T upgrade() {
+        return holder().value();
    }

    /**
-     * Get the {@linkplain UpgradeBase#getUpgradeItem(CompoundTag) upgrade item} for this upgrade.
+     * Get the {@linkplain UpgradeBase#getUpgradeItem(DataComponentPatch) upgrade item} for this upgrade.
     * <p>
     * This returns a defensive copy of the item, to prevent accidental mutation of the upgrade data or original
     * {@linkplain UpgradeBase#getCraftingItem() upgrade stack}.
@@ -66,16 +64,6 @@ public record UpgradeData<T extends UpgradeBase>(T upgrade, CompoundTag data) {
     * @return This upgrade's item.
     */
    public ItemStack getUpgradeItem() {
-        return upgrade.getUpgradeItem(data).copy();
-    }
-
-    /**
-     * Take a copy of this {@link UpgradeData}. This returns a new instance with the same upgrade and a fresh copy of
-     * the upgrade data.
-     *
-     * @return A copy of the current instance.
-     */
-    public UpgradeData<T> copy() {
-        return new UpgradeData<>(upgrade(), data().copy());
+        return upgrade().getUpgradeItem(data).copy();
    }
 }
--- a/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeDataProvider.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeDataProvider.java
@@ -1,177 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.upgrades;
-
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParseException;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import dan200.computercraft.impl.PlatformHelper;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.Util;
-import net.minecraft.core.Registry;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.data.CachedOutput;
-import net.minecraft.data.DataProvider;
-import net.minecraft.data.PackOutput;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Item;
-import org.jspecify.annotations.Nullable;
-
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-/**
- * A data generator/provider for turtle and pocket computer upgrades. This should not be extended directly, instead see
- * the other subclasses.
- *
- * @param <T> The base class of upgrades.
- * @param <R> The upgrade serialiser to register for.
- * @see dan200.computercraft.api.turtle.TurtleUpgradeDataProvider
- * @see dan200.computercraft.api.pocket.PocketUpgradeDataProvider
- */
-public abstract class UpgradeDataProvider<T extends UpgradeBase, R extends UpgradeSerialiser<? extends T>> implements DataProvider {
-    private final PackOutput output;
-    private final String name;
-    private final String folder;
-    private final ResourceKey<Registry<R>> registry;
-
-    private @Nullable List<T> upgrades;
-
-    protected UpgradeDataProvider(PackOutput output, String name, String folder, ResourceKey<Registry<R>> registry) {
-        this.output = output;
-        this.name = name;
-        this.folder = folder;
-        this.registry = registry;
-    }
-
-    /**
-     * Register an upgrade using a "simple" serialiser (e.g. {@link TurtleUpgradeSerialiser#simple(Function)}).
-     *
-     * @param id         The ID of the upgrade to create.
-     * @param serialiser The simple serialiser.
-     * @return The constructed upgrade, ready to be passed off to {@link #addUpgrades(Consumer)}'s consumer.
-     */
-    public final Upgrade<R> simple(ResourceLocation id, R serialiser) {
-        if (!(serialiser instanceof SimpleSerialiser)) {
-            throw new IllegalStateException(serialiser + " must be a simple() seriaiser.");
-        }
-
-        return new Upgrade<>(id, serialiser, s -> {
-        });
-    }
-
-    /**
-     * Register an upgrade using a "simple" serialiser (e.g. {@link TurtleUpgradeSerialiser#simple(Function)}).
-     *
-     * @param id         The ID of the upgrade to create.
-     * @param serialiser The simple serialiser.
-     * @param item       The crafting upgrade for this item.
-     * @return The constructed upgrade, ready to be passed off to {@link #addUpgrades(Consumer)}'s consumer.
-     */
-    public final Upgrade<R> simpleWithCustomItem(ResourceLocation id, R serialiser, Item item) {
-        if (!(serialiser instanceof SerialiserWithCraftingItem)) {
-            throw new IllegalStateException(serialiser + " must be a simpleWithCustomItem() serialiser.");
-        }
-
-        return new Upgrade<>(id, serialiser, s ->
-            s.addProperty("item", PlatformHelper.get().getRegistryKey(Registries.ITEM, item).toString())
-        );
-    }
-
-    /**
-     * Add all turtle or pocket computer upgrades.
-     *
-     * <h4>Example</h4>
-     * {@snippet class=com.example.examplemod.data.TurtleDataProvider region=body}
-     *
-     * @param addUpgrade A callback used to register an upgrade.
-     */
-    protected abstract void addUpgrades(Consumer<Upgrade<R>> addUpgrade);
-
-    @Override
-    public CompletableFuture<?> run(CachedOutput cache) {
-        var base = output.getOutputFolder().resolve("data");
-
-        Set<ResourceLocation> seen = new HashSet<>();
-        List<T> upgrades = new ArrayList<>();
-        List<CompletableFuture<?>> futures = new ArrayList<>();
-        addUpgrades(upgrade -> {
-            if (!seen.add(upgrade.id())) throw new IllegalStateException("Duplicate upgrade " + upgrade.id());
-
-            var json = new JsonObject();
-            json.addProperty("type", PlatformHelper.get().getRegistryKey(registry, upgrade.serialiser()).toString());
-            upgrade.serialise().accept(json);
-
-            futures.add(DataProvider.saveStable(cache, json, base.resolve(upgrade.id().getNamespace() + "/" + folder + "/" + upgrade.id().getPath() + ".json")));
-
-            try {
-                var result = upgrade.serialiser().fromJson(upgrade.id(), json);
-                upgrades.add(result);
-            } catch (IllegalArgumentException | JsonParseException e) {
-                LOGGER.error("Failed to parse {} {}", name, upgrade.id(), e);
-            }
-        });
-
-        this.upgrades = Collections.unmodifiableList(upgrades);
-        return Util.sequenceFailFast(futures);
-    }
-
-    @Override
-    public final String getName() {
-        return name;
-    }
-
-    public final R existingSerialiser(ResourceLocation id) {
-        var result = PlatformHelper.get().getRegistryObject(registry, id);
-        if (result == null) throw new IllegalArgumentException("No such serialiser " + registry);
-        return result;
-    }
-
-    public List<T> getGeneratedUpgrades() {
-        if (upgrades == null) throw new IllegalStateException("Upgrades have not been generated yet");
-        return upgrades;
-    }
-
-    /**
-     * A constructed upgrade instance, produced {@link #addUpgrades(Consumer)}.
-     *
-     * @param id         The ID for this upgrade.
-     * @param serialiser The serialiser which reads and writes this upgrade.
-     * @param serialise  Augment the generated JSON with additional fields.
-     * @param <R>        The type of upgrade serialiser.
-     */
-    public record Upgrade<R extends UpgradeSerialiser<?>>(
-        ResourceLocation id, R serialiser, Consumer<JsonObject> serialise
-    ) {
-        /**
-         * Convenience method for registering an upgrade.
-         *
-         * @param add The callback given to {@link #addUpgrades(Consumer)}
-         */
-        public void add(Consumer<Upgrade<R>> add) {
-            add.accept(this);
-        }
-
-        /**
-         * Return a new {@link Upgrade} which requires the given mod to be present.
-         * <p>
-         * This uses mod-loader-specific hooks (Forge's crafting conditions and Fabric's resource conditions). If using
-         * this in a multi-loader setup, you must generate resources separately for the two loaders.
-         *
-         * @param modId The id of the mod.
-         * @return A new upgrade instance.
-         */
-        public Upgrade<R> requireMod(String modId) {
-            return new Upgrade<>(id, serialiser, json -> {
-                PlatformHelper.get().addRequiredModCondition(json, modId);
-                serialise.accept(json);
-            });
-        }
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeSerialiser.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeSerialiser.java
@@ -1,52 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.upgrades;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.pocket.PocketUpgradeSerialiser;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.resources.ResourceLocation;
-
-
-/**
- * Base interface for upgrade serialisers. This should generally not be implemented directly, instead implementing one
- * of {@link TurtleUpgradeSerialiser} or {@link PocketUpgradeSerialiser}.
- * <p>
- * However, it may sometimes be useful to implement this if you have some shared logic between upgrade types.
- *
- * @param <T> The upgrade that this class can serialise and deserialise.
- * @see TurtleUpgradeSerialiser
- * @see PocketUpgradeSerialiser
- */
-public interface UpgradeSerialiser<T extends UpgradeBase> {
-    /**
-     * Read this upgrade from a JSON file in a datapack.
-     *
-     * @param id     The ID of this upgrade.
-     * @param object The JSON object to load this upgrade from.
-     * @return The constructed upgrade, with a {@link UpgradeBase#getUpgradeID()} equal to {@code id}.
-     * @see net.minecraft.util.GsonHelper For additional JSON helper methods.
-     */
-    T fromJson(ResourceLocation id, JsonObject object);
-
-    /**
-     * Read this upgrade from a network packet, sent from the server.
-     *
-     * @param id     The ID of this upgrade.
-     * @param buffer The buffer object to read this upgrade from.
-     * @return The constructed upgrade, with a {@link UpgradeBase#getUpgradeID()} equal to {@code id}.
-     */
-    T fromNetwork(ResourceLocation id, FriendlyByteBuf buffer);
-
-    /**
-     * Write this upgrade to a network packet, to be sent to the client.
-     *
-     * @param buffer  The buffer object to write this upgrade to
-     * @param upgrade The upgrade to write.
-     */
-    void toNetwork(FriendlyByteBuf buffer, T upgrade);
-
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeType.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeType.java
@@ -0,0 +1,115 @@
+// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.upgrades;
+
+import com.mojang.serialization.MapCodec;
+import dan200.computercraft.api.pocket.IPocketUpgrade;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.impl.upgrades.UpgradeTypeImpl;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.data.registries.RegistryPatchGenerator;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Recipe;
+import net.minecraft.world.level.storage.loot.functions.LootItemFunction;
+
+import java.util.function.Function;
+
+/**
+ * The type of a {@linkplain ITurtleUpgrade turtle} or {@linkplain IPocketUpgrade pocket} upgrade.
+ * <p>
+ * Turtle and pocket computer upgrades are registered using Minecraft's dynamic registry system. As a result, they
+ * follow a similar design to other dynamic content, such as {@linkplain Recipe recipes} or {@link LootItemFunction
+ * loot functions}.
+ * <p>
+ * First, one adds a new class implementing {@link ITurtleUpgrade} or {@link IPocketUpgrade}). This is responsible for
+ * handling all the logic of your upgrade.
+ * <p>
+ * However, the upgrades are not registered directly. Instead, each upgrade class should have a corresponding
+ * {@link UpgradeType}, which is responsible for loading the upgrade from a datapack. The upgrade type should then be
+ * registered in its appropriate registry ({@link ITurtleUpgrade#typeRegistry()},
+ * {@link IPocketUpgrade#typeRegistry()}).
+ * <p>
+ * In order to register the actual upgrade, a JSON file referencing your upgrade type should be added to a datapack. It
+ * is recommended to do this via the data generators.
+ *
+ * <h2 id="datagen">Data Generation</h2>
+ * As turtle and pocket upgrades are just loaded using vanilla's dynamic loaders, one may use the same data generation
+ * tools as you would for any other dynamic registry.
+ * <p>
+ * This can typically be done by extending vanilla's built-in registries using {@link RegistryPatchGenerator}, and then
+ * writing out the new registries using {@code net.fabricmc.fabric.api.datagen.v1.provider.FabricDynamicRegistryProvider}
+ * on Fabric or {@code net.neoforged.neoforge.common.data.DatapackBuiltinEntriesProvider} on Forge.
+ * <p>
+ * {@snippet lang="java" :
+ * import dan200.computercraft.api.turtle.ITurtleUpgrade;
+ * import net.minecraft.Util;
+ * import net.minecraft.core.HolderLookup;
+ * import net.minecraft.core.RegistrySetBuilder;
+ * import net.minecraft.data.DataGenerator;
+ * import net.neoforged.neoforge.common.data.DatapackBuiltinEntriesProvider;
+ *
+ * import java.util.concurrent.CompletableFuture;
+ *
+ * public void generate(DataGenerator.PackGenerator output, CompletableFuture<HolderLookup.Provider> registries) {
+ *     var newRegistries = RegistryPatchGenerator.createLookup(registries, Util.make(new RegistrySetBuilder(), builder -> {
+ *         builder.add(ITurtleUpgrade.REGISTRY, upgrades -> {
+ *             upgrades.register(ITurtleUpgrade.createKey(ResourceLocation.fromNamespaceAndPath("my_mod", "my_upgrade")), new MyUpgrade());
+ *         });
+ *     }));
+ *     output.addProvider(o -> new DatapackBuiltinEntriesProvider(o, newRegistries, Set.of("my_mod")));
+ * }
+ * }
+ *
+ * @param <T> The upgrade subclass that this upgrade type represents.
+ * @see ITurtleUpgrade
+ * @see IPocketUpgrade
+ */
+public interface UpgradeType<T extends UpgradeBase> {
+    /**
+     * The codec to read and write this upgrade from a datapack.
+     *
+     * @return The codec for this upgrade.
+     */
+    MapCodec<T> codec();
+
+    /**
+     * Create a new upgrade type.
+     *
+     * @param codec The codec
+     * @param <T>   The type of the generated upgrade.
+     * @return The newly created upgrade type.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> create(MapCodec<T> codec) {
+        return new UpgradeTypeImpl<>(codec);
+    }
+
+    /**
+     * Create an upgrade type for an upgrade that takes no arguments.
+     * <p>
+     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(Function)} instead.
+     *
+     * @param instance Generate a new upgrade with a specific ID.
+     * @param <T>      The type of the generated upgrade.
+     * @return A new upgrade type.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> simple(T instance) {
+        return create(MapCodec.unit(instance));
+    }
+
+    /**
+     * Create an upgrade type for a simple upgrade whose crafting item can be specified.
+     *
+     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
+     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
+     * @param <T>     The type of the generated upgrade.
+     * @return A new upgrade type.
+     * @see #simple(UpgradeBase)  For upgrades whose crafting stack should not vary.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> simpleWithCustomItem(Function<ItemStack, T> factory) {
+        return create(BuiltInRegistries.ITEM.byNameCodec()
+            .xmap(x -> factory.apply(new ItemStack(x)), x -> x.getCraftingItem().getItem())
+            .fieldOf("item"));
+    }
+}
--- a/projects/common-api/src/main/java/dan200/computercraft/impl/ComputerCraftAPIService.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/impl/ComputerCraftAPIService.java
@@ -4,6 +4,7 @@

 package dan200.computercraft.impl;

+import com.mojang.serialization.Codec;
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.detail.BlockReference;
 import dan200.computercraft.api.detail.DetailRegistry;
@@ -12,14 +13,15 @@ import dan200.computercraft.api.filesystem.WritableMount;
 import dan200.computercraft.api.lua.GenericSource;
 import dan200.computercraft.api.lua.ILuaAPIFactory;
 import dan200.computercraft.api.media.MediaProvider;
-import dan200.computercraft.api.media.PrintoutContents;
 import dan200.computercraft.api.network.PacketNetwork;
 import dan200.computercraft.api.network.wired.WiredElement;
 import dan200.computercraft.api.network.wired.WiredNode;
-import dan200.computercraft.api.pocket.PocketUpgradeSerialiser;
+import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.redstone.BundledRedstoneProvider;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleRefuelHandler;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import dan200.computercraft.impl.upgrades.TurtleToolSpec;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.core.Registry;
@@ -28,7 +30,8 @@ import net.minecraft.server.MinecraftServer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.ApiStatus;
-import org.jspecify.annotations.Nullable;
+
+import javax.annotation.Nullable;

 /**
 * Backing interface for {@link ComputerCraftAPI}
@@ -67,17 +70,20 @@ public interface ComputerCraftAPIService {

    void registerRefuelHandler(TurtleRefuelHandler handler);

-    ResourceKey<Registry<TurtleUpgradeSerialiser<?>>> turtleUpgradeRegistryId();
+    ResourceKey<Registry<UpgradeType<? extends ITurtleUpgrade>>> turtleUpgradeRegistryId();

-    ResourceKey<Registry<PocketUpgradeSerialiser<?>>> pocketUpgradeRegistryId();
+    Codec<ITurtleUpgrade> turtleUpgradeCodec();
+
+    ResourceKey<Registry<UpgradeType<? extends IPocketUpgrade>>> pocketUpgradeRegistryId();
+
+    ITurtleUpgrade createTurtleTool(TurtleToolSpec spec);
+
+    Codec<IPocketUpgrade> pocketUpgradeCodec();

    DetailRegistry<ItemStack> getItemStackDetailRegistry();

    DetailRegistry<BlockReference> getBlockInWorldDetailRegistry();

-    @Nullable
-    PrintoutContents getPrintoutContents(ItemStack stack);
-
    final class Instance {
        static final @Nullable ComputerCraftAPIService INSTANCE;
        static final @Nullable Throwable ERROR;
--- a/projects/common-api/src/main/java/dan200/computercraft/impl/PlatformHelper.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/impl/PlatformHelper.java
@@ -1,91 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.impl;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.upgrades.UpgradeDataProvider;
-import net.minecraft.core.Registry;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import org.jetbrains.annotations.ApiStatus;
-import org.jspecify.annotations.Nullable;
-
-/**
- * Abstraction layer for Forge and Fabric. See implementations for more details.
- * <p>
- * Do <strong>NOT</strong> directly reference this class. It exists for internal use by the API.
- */
-@ApiStatus.Internal
-public interface PlatformHelper {
-    /**
-     * Get the current {@link PlatformHelper} instance.
-     *
-     * @return The current instance.
-     */
-    static PlatformHelper get() {
-        var instance = Instance.INSTANCE;
-        return instance == null ? Services.raise(PlatformHelper.class, Instance.ERROR) : instance;
-    }
-
-    /**
-     * Get the unique ID for a registered object.
-     *
-     * @param registry The registry to look up this object in.
-     * @param object   The object to look up.
-     * @param <T>      The type of object the registry stores.
-     * @return The registered object's ID.
-     * @throws IllegalArgumentException If the registry or object are not registered.
-     */
-    <T> ResourceLocation getRegistryKey(ResourceKey<Registry<T>> registry, T object);
-
-    /**
-     * Look up an ID in a registry, returning the registered object.
-     *
-     * @param registry The registry to look up this object in.
-     * @param id       The ID to look up.
-     * @param <T>      The type of object the registry stores.
-     * @return The resolved registry object.
-     * @throws IllegalArgumentException If the registry or object are not registered.
-     */
-    <T> T getRegistryObject(ResourceKey<Registry<T>> registry, ResourceLocation id);
-
-    /**
-     * Get the subset of an {@link ItemStack}'s {@linkplain ItemStack#getTag() tag} which is synced to the client.
-     *
-     * @param item The stack.
-     * @return The item's tag.
-     */
-    @Nullable
-    default CompoundTag getShareTag(ItemStack item) {
-        return item.getTag();
-    }
-
-    /**
-     * Add a resource condition which requires a mod to be loaded. This should be used by data providers such as
-     * {@link UpgradeDataProvider}.
-     *
-     * @param object The JSON object we're generating.
-     * @param modId  The mod ID that we require.
-     */
-    void addRequiredModCondition(JsonObject object, String modId);
-
-    final class Instance {
-        static final @Nullable PlatformHelper INSTANCE;
-        static final @Nullable Throwable ERROR;
-
-        static {
-            // We don't want class initialisation to fail here (as that results in confusing errors). Instead, capture
-            // the error and rethrow it when accessing. This should be JITted away in the common case.
-            var helper = Services.tryLoad(PlatformHelper.class);
-            INSTANCE = helper.instance();
-            ERROR = helper.error();
-        }
-
-        private Instance() {
-        }
-    }
-}
--- a/projects/common-api/src/main/java/dan200/computercraft/impl/ServiceException.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/impl/ServiceException.java
@@ -5,8 +5,8 @@
 package dan200.computercraft.impl;

 import org.jetbrains.annotations.ApiStatus;
-import org.jspecify.annotations.Nullable;

+import javax.annotation.Nullable;
 import java.io.Serial;

 /**
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jonathan Coates	2c740bb904	Bump CC:T to 1.111.1	2024-07-04 19:08:06 +01:00
Jonathan Coates	0e4710a956	Update NF and NG - Rename ToolActions to ItemAbilities. Closes #1881. - Remove our source set helper, as NG has built-in support for this now. - Remove our code to generate new JavaExec tasks from runs, as NG now generates JavaExec tasks normally.	2024-06-29 12:58:03 +01:00
Jonathan Coates	aca1d43550	Merge branch 'mc-1.20.x' into mc-1.21.x	2024-06-29 10:50:44 +01:00
Jonathan Coates	f10e401aea	Load turtle overlays from a registry - Add a new computercraft:turtle_overlay dynamic registry, which stores turtle overlays. Turtle overlays are just a model id and an (optional) boolean flag, which specifies whether this overlay is compatible with the elf/christmas model. - Change the computercraft:overlay component to accept a Holder<TurtleOverlay> (instead of just a model ID). This accepts both an overlay ID or an inline overlay object (e.g. you can do cc:turtle_normal[computercraft:overlay={model:"foo"}]. - Update turtle model and BE rendering code to render both the overlay and elf (if compatible). Fixes #1663. - Ideally we'd automatically load all models listed in the overlay registry. However, resource loading happens separately to datapacks, so we can't link the two. Instead, we add a new assets/computercraft/extra_models.json file that lists any additional models that should be loaded and baked. This file includes all built-in overlay models, but external resource packs and/or mods can easily extend it.	2024-06-27 20:57:43 +01:00
Jonathan Coates	1a1623075f	Fix turtle labels not rendering The X scale factor should now be flipped. I'm not quite sure what in MC has meant this should be changed, possibly the cameraOrientation matrix? Fixes #1872	2024-06-26 18:06:48 +01:00
Jonathan Coates	54a95e07a4	Fix monitors not updating on NeoForge	2024-06-23 09:21:15 +01:00
Jonathan Coates	efd9a0f315	Fix JEI integration for MC 1.21 - Use the client side registry access (possible now that we've moved JEI to the client). - Generate unique ids for JEI recipes.	2024-06-22 22:48:37 +01:00
Jonathan Coates	28f75a0687	Merge branch 'mc-1.20.x' into mc-1.21.x	2024-06-22 22:33:18 +01:00
Jonathan Coates	4b102f16b3	Update to Minecraft 1.21 API Changes: - Minecraft had updated ModelResourceLocation to no longer inherit from ResourceLocation. To allow referencing both already baked models (ModelResourceLocation) and loading new models (via ResourceLocation) in turtle model loadders, we add a new "ModelLocation" class, that acts as a union between the two. I'm not entirely convinced by the design here, so might end up changing again before a stable release.o - Merge IMedia.getAudioTitle and IMedia.getAudio into a single IMedia.getAudio method, which now returns a JukeboxSong rather than a SoundEvent. Other update notes: - Minecraft had rewritten how buffers are managed again. This is a fairly minor change for us (vertex -> addVertex, normal -> setNormal, etc...), with the exception that you can no longer use MultiBufferSource.immediate with the tesselator. I've replaced this with GuiGraphics.bufferSource, which appears to be fine, but worth keeping an eye on in case there's any odd render state issues. - Crafting now uses a CraftingInput (a list of items) rather than a CraftingContainer, which allows us to simplify turtle crafting code.	2024-06-22 16:19:59 +01:00
Jonathan Coates	bb933d0100	Merge branch 'mc-1.20.x' into mc-1.20.y	2024-06-21 08:36:18 +01:00
Jonathan Coates	de078e3037	Merge branch 'mc-1.20.x' into mc-1.20.y	2024-05-28 18:46:19 +01:00
Jonathan Coates	eb584aa94d	Translate remaining item tags These shouldn't appear in recipes, but just to stop Fabric complaining :).	2024-05-09 18:47:28 +01:00
Jonathan Coates	ad70e2ad90	Make printout recipes a little more flexible Rather than having one single hard-coded recipe, we now have separate recipes for printed pages and printed books. These recipes are defined in terms of - A list of ingredients (like shapeless recipes). - A result item. - An ingredient defining the acceptable page items (so printed page(s), but not books). This cannot overlap with any of the main ingredients. - The minimum number of printouts required. We then override the shapeless recipe crafting logic to allow for multiple printouts to appear. It feels like it'd be nice to generalise this to a way of defining shapeless recipes with variable-count ingredients (for instance, the disk recipe could also be defined this way), but I don't think it's worth it right now. This solves some of the issues in #1755. Disk recipes have not been changed yet.	2024-05-09 18:47:22 +01:00
Jonathan Coates	2c0d8263d3	Update to MC 1.20.6 - Update EMI and REI integration, and fix some issues with the upgrade crafting hooks. - Just use smooth stone for recipes, not #c:stone. We're mirroring redstone's crafting recipes here. - Some cleanup to printouts. - Remote upgrade data generators - these can be replaced with the standard registry data generators. - Remove the API's PlatformHelper - we no longer have any platform-specific code in the API.	2024-05-07 22:59:53 +01:00
Jonathan Coates	94c864759d	Ignore enchantments/attributes on the original item Turtle tools were not equippable, as we considered the stack enchanted due to the item's base attribute modifiers. We now only check the component patch for enchantments/attribute modifiers. This also removes the craftItem property of tools - this hasn't worked since we added support for enchanted tools! Fixes #1810	2024-04-29 21:07:04 +01:00
Jonathan Coates	2226df7224	Small cleanup after testing - Use TinyRemapper to remap mixins on Fabric. Mixins in the common project weren't being remapped correctly. - Update to latest NeoForge - Switch to the new tick events. - Call refreshDimensions() in the fake player constructor.	2024-04-28 22:02:12 +01:00
Jonathan Coates	959bdaeb61	Use a single upgrade type for modems Replace turtle_modem_{normal,advanced} with a single turtle_modem upgrade (and likewise for pocket upgrades). This is slightly more complex (we now need a custom codec), but I think is more idiomatic.	2024-04-28 20:38:30 +01:00
Jonathan Coates	06ac373e83	Use components for upgrade adjectives This makes quick-and-dirty datapacks a little easier, as you can now use a hard-coded string rather than adding a language key.	2024-04-28 20:07:15 +01:00
Jonathan Coates	0aca6a4dc9	Remove several unused test files	2024-04-28 19:54:39 +01:00
Jonathan Coates	bf203bb1f3	Rewrite upgrades to use dynamic registries Ever since 1.17, turtle and pocket upgrades have been loaded from datpacks, rather than being hard-coded in Java. However, upgrades have always been stored in our own registry-like structure, rather than using vanilla's registries. This has become a bit of a problem with the introduction of components. The upgrade components now hold the upgrade object (rather than just its id), which means we need the upgrades to be available much earlier (e.g. when reading recipes). The easiest fix here is to store upgrades in proper registries instead. This means that upgrades can no longer be reloaded (it requires a world restart), but otherwise is much nicer: - UpgradeData now stores a Holder<T> rather than a T. - UpgradeSerialiser has been renamed to UpgradeType. This now just provides a Codec<T>, rather than JSON and network reading/writing functions. - Upgrade classes no longer implement getUpgradeID(), but instead have a getType() function, which returns the associated UpgradeType. - Upgrades are now stored in turtle_upgrade (or pocket_upgrade) rather than turtle_upgrades (or pocket_upgrades). This will break existing datapacks, sorry!	2024-04-28 19:47:19 +01:00
Jonathan Coates	cd9840d1c1	Add workaround for inventory method test failure	2024-04-26 22:06:29 +01:00
Jonathan Coates	b9a002586c	Update turtle reach limits to 1.20.5 We can replace our mixins with vanilla's built-in attributes.	2024-04-26 21:44:19 +01:00
Jonathan Coates	a3b07909b0	Replace some recipes with a more dynamic system This adds a new "recipe function" system, that allows transforming the result of a recipe according to some datapack-defined function. Currently, we only provide one function: computercraft:copy_components, which copies components from one of the ingredients to the result. This allows us to replace several of our existing recipes: - Turtle overlay recipes are now defined as a normal shapeless recipe that copies all (non-overlay) components from the input turtle. - Computer conversion recipes (e.g. computer -> turtle, normal -> advanced) copy all components from the input computer to the result. This is more complex (and thus more code), but also a little more flexible, which hopefully is useful for someone :).	2024-04-26 21:44:18 +01:00
Jonathan Coates	d7786ee4b9	Merge branch 'mc-1.20.x' into mc-1.20.y	2024-04-26 18:38:15 +01:00
Jonathan Coates	188806e8b0	Actually update NeoForge to 1.20.5 NF now loads mods from neoforge.mods.toml rather than mods.toml, so CC wasn't actually being loaded. Tests all passed, because they didn't get run in the first place!	2024-04-26 17:57:20 +01:00
Jonathan Coates	01407544c9	Update to 1.20.5 (#1793 ) - Switch most network code to use StreamCodec - Turtle/pocket computer upgrades now use DataComponentPatch instead of raw NBT.	2024-04-25 20:32:48 +00:00
Jonathan Coates	bd2fd9d4c8	Merge branch 'mc-1.20.x' into mc-1.20.y	2024-04-25 18:23:04 +01:00
Jonathan Coates	5c457950d8	Merge branch 'mc-1.20.x' into mc-1.20.y	2024-04-24 20:30:59 +01:00
Jonathan Coates	75f3ecce18	Render printout pages further forward in the UI Rather than rendering the background further back. This was causing some of the pages to not be rendered. I'm not quite sure why this is -- there shouldn't be any z-fighting -- but this does work as a fix! Fixes #1777	2024-04-08 12:07:53 +01:00
Jonathan Coates	688fdc40a6	Don't render background in the off-hand pocket UI Fixes #1778	2024-04-08 12:02:25 +01:00
Jonathan Coates	22bd5309ba	Merge branch 'mc-1.20.x' into mc-1.20.y	2024-04-07 22:06:49 +01:00
Jonathan Coates	c50d56d9fa	Remove canClickRunClientCommand This was added in `4675583e1c` to handle Forge on longer supporting RUN_COMMAND for client-side commands. However, the mixins are still present on NF/1.20.4, so we don't need this!	2024-03-23 15:38:18 +00:00
Jonathan Coates	7b9a156abc	Register our block entities with DFU This ensures that data fixers will be applied to items in these inventories.	2024-03-22 21:47:11 +00:00
Jonathan Coates	0a9e5c78f3	Remove some deprecated code Some of this is technically an API break, but 1.20.4 is pretty unstable. - Remove WiredNetwork from the public API - Remove legacy computer selectors	2024-03-22 21:36:52 +00:00
Jonathan Coates	da5885ef35	Merge branch 'mc-1.20.x' into mc-1.20.y	2024-03-22 21:23:49 +00:00
Jonathan Coates	240528cce5	Update NF and NG Trying to rebuild after this OOM killed all my windows. I hate NeoGradle so much.	2024-02-18 19:02:23 +00:00
Jonathan Coates	83f1f86888	Merge branch 'mc-1.20.x' into mc-1.20.y	2024-02-18 18:45:20 +00:00
Jonathan Coates	9c202bd1c2	Fix incorrect cast for JEI	2024-02-05 18:52:20 +00:00
Jonathan Coates	fc834cd97f	Update to 1.20.4	2024-01-31 20:55:14 +00:00