Remove QuadEmitter

And remove EMI support. I'm not sure it survived the 1.21.4 recipe changes :(.
Finish lectern rendering
2025-10-15 14:07:38 +00:00 · 2025-10-14 22:10:00 +01:00 · 2025-10-14 20:04:31 +01:00 · 2025-10-14 08:51:35 +01:00 · 2025-10-13 21:15:54 +01:00 · 2025-07-18 17:04:28 +01:00
1096 changed files with 23487 additions and 22089 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -18,11 +18,6 @@ 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

@@ -31,3 +26,27 @@ 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,15 +1,18 @@
 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?
+    description: |
+        What version of Minecraft are you using? If your version is not listed, please try to reproduce on one of the supported versions.
    options:
      - 1.20.1
-      - 1.21.x
+      - 1.21.1
+      - 1.21.7
  validations:
    required: true
 - type: input
@@ -26,8 +29,7 @@ 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. 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.
+      - 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)
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -2,6 +2,7 @@
 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
@@ -30,27 +30,6 @@ 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.
@@ -63,8 +42,29 @@ jobs:
        name: CC-Tweaked
        path: ./jars

-    - name: 📤 Upload coverage
-      uses: codecov/codecov-action@v4
+    - 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() }}

  build-core:
    strategy:
--- a/.gitignore
+++ b/.gitignore
@@ -27,6 +27,7 @@
 *.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: v4.4.0
+  rev: v5.0.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: v2.1.0
+  rev: v5.0.2
  hooks:
  - id: reuse

@@ -58,6 +58,7 @@ 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
@@ -1,100 +0,0 @@
-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,16 +22,15 @@ 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 [Weblate], an online interface for managing language strings. This is synced
-automatically with GitHub, so please don't submit PRs adding/changing translations!
+Translations are managed through [CrowdIn], an online interface for managing language strings.

 ## 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 (JDK). This can be downloaded from [Adoptium].
+   - Java Development Kit 21 (JDK). This can be downloaded from [Adoptium].
   - [Git](https://git-scm.com/).
-   - [NodeJS][node].
+   - [NodeJS 20 or later][node].

 - Download CC: Tweaked's source code:
   ```
@@ -49,9 +48,12 @@ 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 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]!
+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]!

 ### Testing
 When making larger changes, it may be useful to write a test to make sure your code works as expected.
@@ -86,8 +88,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 docWebsite -t`, which will rebuild documentation every time you change a
-file.
+documentation, you can instead run `./gradlew :web:assemble -x :web:compileTeaVM -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
@@ -101,10 +103,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,14 +11,13 @@ 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 [CurseForge] or [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
+CC: Tweaked can be installed from [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
@@ -26,8 +25,9 @@ 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 [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.
+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].

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

@@ -60,19 +60,6 @@ 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!
@@ -81,10 +68,9 @@ 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
-[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
+[EsperNet]: https://www.esper.net/
+[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#computercraft "#computercraft on EsperNet"
--- a/REUSE.toml
+++ b/REUSE.toml
@@ -0,0 +1,100 @@
+# 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_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/**",
+    # 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,21 +24,19 @@ val mcVersion: String by extra

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

-    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)
+    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
 }

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

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

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

@@ -29,6 +25,7 @@ repositories {
        name = "Fabric"
        content {
            includeGroup("net.fabricmc")
+            includeGroup("net.fabricmc.unpick")
        }
    }

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

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

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

 versionCatalogUpdate {
-    sortByKey.set(false)
-    keep { keepUnusedLibraries.set(true) }
-    catalogFile.set(file("../gradle/libs.versions.toml"))
+    sortByKey = false
+    keep { keepUnusedLibraries = true }
+    catalogFile = 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
@@ -4,10 +4,7 @@

 /** Default configuration for Fabric projects. */

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

 plugins {
    `java-library`
@@ -30,7 +27,7 @@ repositories {

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

 MinecraftConfigurations.setup(project)
@@ -67,3 +64,9 @@ dependencies {
 tasks.ideaSyncTask {
    doLast { IdeaRunConfigurations(project).patch() }
 }
+
+tasks.named("checkDependencyConsistency", DependencyCheck::class.java) {
+    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
+    // Minecraft depends on asm, but Fabric forces it to a more recent version
+    override(libs.findLibrary("asm").get(), "9.9")
+}
--- a/buildSrc/src/main/kotlin/cc-tweaked.forge.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.forge.gradle.kts
@@ -6,25 +6,22 @@

 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.gradle.userdev")
+    id("net.neoforged.moddev")
 }

 plugins.apply(CCTweakedPlugin::class.java)

 val mcVersion: String by extra

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

-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.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.set(CCTweakedPlugin.JAVA_VERSION)
+        languageVersion = CCTweakedPlugin.JAVA_VERSION
    }

    withSourcesJar()
@@ -47,9 +47,9 @@ repositories {
        filter {
            includeGroup("cc.tweaked")
            // Things we mirror
-            includeGroup("commoble.morered")
+            includeGroup("com.simibubi.create")
+            includeGroup("net.commoble.morered")
            includeGroup("dev.architectury")
-            includeGroup("dev.emi")
            includeGroup("maven.modrinth")
            includeGroup("me.shedaniel.cloth")
            includeGroup("me.shedaniel")
@@ -90,14 +90,15 @@ sourceSets.all {

        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(
@@ -120,7 +121,6 @@ tasks.compileTestJava {
    }
 }

-
 tasks.withType(JavaCompile::class.java).configureEach {
    options.encoding = "UTF-8"
 }
@@ -168,8 +168,8 @@ tasks.test {
 }

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

 project.plugins.withType(CCTweakedPlugin::class.java) {
@@ -193,30 +193,23 @@ spotless {
    fun FormatExtension.defaults() {
        endWithNewline()
        trimTrailingWhitespace()
-        indentWithSpaces(4)
+        leadingTabsToSpaces(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().editorConfigOverride(ktlintConfig)
+        ktlint()
    }

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

@@ -225,6 +218,5 @@ 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
@@ -1,25 +0,0 @@
-// 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,11 +2,9 @@
 //
 // 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")
 }
@@ -25,34 +23,17 @@ 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.set(findProperty("modrinthApiKey") as String? ?: "")
-    projectId.set("gu7yAYhd")
-    versionNumber.set(modVersion)
-    versionName.set(modVersion)
-    versionType.set(if (isUnstable) "alpha" else "release")
+    token = findProperty("modrinthApiKey") as String? ?: ""
+    projectId = "gu7yAYhd"
+    versionNumber = modVersion
+    versionName = modVersion
+    versionType = if (isUnstable) "alpha" else "release"
    uploadFile.setProvider(modPublishing.output)
    gameVersions.add(mcVersion)
-    changelog.set("Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion).")
+    changelog = "Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion)."

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

 tasks.publish { dependsOn(tasks.modrinth) }
--- a/buildSrc/src/main/kotlin/cc-tweaked.gametest.gradle.kts
+++ b/buildSrc/src/main/kotlin/cc-tweaked.gametest.gradle.kts
@@ -2,44 +2,34 @@
 //
 // 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 {
-    id("cc-tweaked.kotlin-convention")
+    kotlin("jvm")
    id("cc-tweaked.java-convention")
 }

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

-// 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
-}
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.DATAGEN)
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.EXAMPLES)
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.TEST_MOD)

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

-    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)
-}
+// Make sure our examples compile.
+tasks.check { dependsOn(tasks.named("compileExamplesJava")) }

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

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

            pom {
-                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")
+                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"

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

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

                licenses {
                    license {
-                        name.set("ComputerCraft Public License, Version 1.0")
-                        url.set("https://github.com/cc-tweaked/CC-Tweaked/blob/HEAD/LICENSE")
+                        name = "ComputerCraft Public License, Version 1.0"
+                        url = "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,23 +10,16 @@ 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
@@ -37,54 +30,40 @@ import java.io.IOException
 import java.net.URI
 import java.util.regex.Pattern

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

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

    /** Get a list of all contributors to the project. */
-    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)
-    }
+    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)
+        }

    /**
     * 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() }
    }

@@ -110,14 +89,13 @@ abstract class CCTweakedExtension(
        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)
-        if (testMod != null) extendSourceSet(otherProject, testMod)
-        if (testFixtures != null) extendSourceSet(otherProject, testFixtures)
+        for (sourceSet in listOf(MinecraftConfigurations.DATAGEN, MinecraftConfigurations.EXAMPLES, MinecraftConfigurations.TEST_MOD, "testFixtures")) {
+            otherJava.sourceSets.findByName(sourceSet)?.let { extendSourceSet(otherProject, it) }
+        }

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

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

        val jacoco = project.extensions.getByType(JacocoPluginExtension::class.java)
        task.configure {
            finalizedBy(reportTaskName)
-
-            doFirst("Clean class dump directory") { fs.delete { delete(classDump) } }
-
            jacoco.applyTo(this)
+
            extensions.configure(JacocoTaskExtension::class.java) {
                includes = listOf("dan200.computercraft.*")
-                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
+                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.
+                )
            }
        }

@@ -205,15 +179,11 @@ abstract class CCTweakedExtension(
            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 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)
+            // 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)
            }
        }
    }
@@ -253,40 +223,31 @@ abstract class CCTweakedExtension(
        ).resolve().single()
    }

-    /**
-     * Exclude a dependency from being published in Maven.
-     */
-    fun exclude(dep: Dependency) {
-        excludedDeps.add(dep)
-    }
+    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
+        }

-    /**
-     * Configure a [MavenDependencySpec].
-     */
-    fun configureExcludes(spec: MavenDependencySpec) {
-        for (dep in excludedDeps.get()) spec.exclude(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)
+        }
    }

    companion object {
        private val COMMIT_COUNTS = Pattern.compile("""^\s*[0-9]+\s+(.*)$""")
        private val IGNORED_USERS = setOf(
-            "GitHub", "Daniel Ratcliffe", "Weblate",
+            "GitHub", "Daniel Ratcliffe", "NotSquidDev", "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/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
-    abstract val configuration: ListProperty<Configuration>
+    protected abstract val dependencies: ListProperty<DependencyResult>

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

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

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

@@ -45,13 +45,19 @@ 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 configuration.get()) {
-            configuration.incoming.resolutionResult.allDependencies {
-                if (!check(this@allDependencies)) ok = false
-            }
+        for (configuration in dependencies.get()) {
+            if (!check(configuration)) 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,10 +5,8 @@
 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
@@ -159,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 {
-        version.substring(lastIndex + 1).toInt()
+        mainVersion.substring(lastIndex + 1).toInt()
    } catch (e: NumberFormatException) {
        throw IllegalArgumentException("Cannot parse version format \"$version\"", e)
    }
@@ -171,3 +171,15 @@ 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,7 +25,6 @@ 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
@@ -35,22 +34,6 @@ 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")
@@ -58,10 +41,9 @@ 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 -> {}
                }
            }
@@ -72,65 +54,6 @@ 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) {
@@ -159,16 +82,5 @@ 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
@@ -1,73 +0,0 @@
-// 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,7 +24,6 @@ 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]
@@ -37,13 +36,7 @@ class MinecraftConfigurations private constructor(private val project: Project)
        val client = sourceSets.maybeCreate("client")

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

        // Set up an API configuration for clients (to ensure it's consistent with the main source set).
        val clientApi = configurations.maybeCreate(client.apiConfigurationName).apply {
@@ -85,6 +78,16 @@ 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"]

@@ -96,13 +99,30 @@ 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.add(configurations.named(main.runtimeClasspathConfigurationName))
-                configuration.add(configurations.named(client.runtimeClasspathConfigurationName))
+                configuration(configurations.named(main.runtimeClasspathConfigurationName))
+                configuration(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()
        }
@@ -110,6 +130,10 @@ 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,6 +4,7 @@

 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
@@ -18,6 +19,7 @@ import java.nio.file.Files
 import java.util.concurrent.TimeUnit
 import java.util.function.Supplier
 import javax.inject.Inject
+import kotlin.collections.set
 import kotlin.random.Random

 /**
@@ -64,6 +66,22 @@ 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.
     */
@@ -108,6 +126,23 @@ abstract class ClientJavaExec : JavaExec() {
        }
    }

+    /**
+     * Configure Iris to use Complementary Shaders.
+     */
+    fun withComplementaryShaders() {
+        val cct = project.extensions.getByType(CCTweakedExtension::class.java)
+
+        withFileFrom(workingDir.resolve("shaderpacks/ComplementaryShaders_v4.6.zip")) {
+            cct.downloadFile("Complementary Shaders", "https://edge.forgecdn.net/files/3951/170/ComplementaryShaders_v4.6.zip")
+        }
+        withFileContents(workingDir.resolve("config/iris.properties")) {
+            """
+            enableShaders=true
+            shaderPack=ComplementaryShaders_v4.6.zip
+            """.trimIndent()
+        }
+    }
+
    @TaskAction
    override fun exec() {
        Files.createDirectories(workingDir.toPath())
--- a/buildSrc/src/main/kotlin/cc/tweaked/gradle/Node.kt
+++ b/buildSrc/src/main/kotlin/cc/tweaked/gradle/Node.kt
@@ -11,7 +11,9 @@ 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) {
@@ -43,9 +45,12 @@ abstract class NpmInstall : DefaultTask() {
    @get:OutputDirectory
    val nodeModules: Provider<Directory> = projectRoot.dir("node_modules")

+    @get:Inject
+    protected abstract val execOperations: ExecOperations
+
    @TaskAction
    fun install() {
-        project.exec {
+        execOperations.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,45 +4,10 @@

 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
@@ -1,16 +0,0 @@
-// 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
@@ -21,6 +21,15 @@ SPDX-License-Identifier: MPL-2.0
        <property name="file" value="${config_loc}/suppressions.xml" />
    </module>

+    <!--
+        Checkstyle doesn't support @snippet (https://github.com/checkstyle/checkstyle/issues/11455),
+        so suppress warnings nearby
+    -->
+    <module name="SuppressWithNearbyTextFilter">
+        <property name="nearbyTextPattern" value="@snippet" />
+        <property name="lineRange" value="20" />
+    </module>
+
    <module name="BeforeExecutionExclusionFileFilter">
        <property name="fileNamePattern" value="render_old"/>
    </module>
@@ -92,7 +101,10 @@ SPDX-License-Identifier: MPL-2.0
        <module name="InvalidJavadocPosition" />
        <module name="JavadocBlockTagLocation" />
        <module name="JavadocMethod"/>
-        <module name="JavadocType"/>
+        <module name="JavadocType">
+            <!-- Seems to complain about @hidden!? -->
+            <property name="allowUnknownTags" value="true" />
+        </module>
        <module name="JavadocStyle">
            <property name="checkHtml" value="false" />
        </module>
@@ -117,14 +129,14 @@ SPDX-License-Identifier: MPL-2.0
        <module name="LocalFinalVariableName" />
        <module name="LocalVariableName" />
        <module name="MemberName">
-            <property name="format" value="^\$?[a-z][a-zA-Z0-9]*$" />
+            <property name="format" value="^(computercraft\$|\$)?[a-z][a-zA-Z0-9]*$" />
        </module>
        <module name="MethodName">
            <property name="format" value="^(computercraft\$)?[a-z][a-zA-Z0-9]*$" />
        </module>
        <module name="MethodTypeParameterName" />
        <module name="PackageName">
-            <property name="format" value="^(dan200\.computercraft|cc\.tweaked)(\.[a-z][a-z0-9]*)*" />
+            <property name="format" value="^(dan200\.computercraft|cc\.tweaked|com\.example\.examplemod)(\.[a-z][a-z0-9]*)*" />
        </module>
        <module name="ParameterName" />
        <module name="StaticVariableName">
@@ -143,7 +155,10 @@ 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" />
+        <module name="NoWhitespaceBefore">
+            <!-- Allow whitespace before "..." for @Nullable annotations -->
+            <property name="tokens" value="COMMA,SEMI,POST_INC,POST_DEC,LABELED_STAT" />
+        </module>
        <!-- TODO: Decide on an OperatorWrap style. -->
        <module name="ParenPad" />
        <module name="SeparatorWrap">
--- a/crowdin.yml
+++ b/crowdin.yml
@@ -0,0 +1,29 @@
+# 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 size is changed.
+The [`monitor_resize`] event is fired when an adjacent or networked [monitor's][`monitor`] 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 is right-clicked.
+The [`monitor_touch`] event is fired when an adjacent or networked [Advanced Monitor][`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 change.
+The [`event!redstone`] event is fired whenever any redstone inputs on the computer or [relay][`redstone_relay`] change.

 ## Return values
 1. [`string`]: The event name.
@@ -21,3 +21,7 @@ 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 on [GitHub Discussions] or [IRC] either!
+> cover. That said, don't be afraid to ask [the community for help][community].

 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,5 +205,4 @@ 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"
-[GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
+[Community]: /#community
--- 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 [CurseForge] or [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
+CC: Tweaked can be installed from [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,7 +50,11 @@ 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.

-If you get stuck, do [ask a question on GitHub][GitHub Discussions] or pop in to the ComputerCraft's [IRC channel][IRC].
+<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].

 ## Get Involved
 CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please do [create an issue][bug].
@@ -58,11 +62,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
-[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
+[EsperNet]: https://www.esper.net/
+[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#computercraft "#computercraft on EsperNet"
--- a/doc/mod-page.md
+++ b/doc/mod-page.md
@@ -50,7 +50,11 @@ 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.

-If you get stuck, do [ask a question on GitHub][GitHub Discussions] or pop in to the ComputerCraft's [IRC channel][IRC].
+## 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].

 ## Get Involved
 CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please do [create an issue][bug].
@@ -60,4 +64,5 @@ 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
-[IRC]: http://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
+[EsperNet]: https://www.esper.net/
+[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#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.atan2` -> `math.atan`                                                           | 🔶         | `math.atan` supports its two argument form. |
 | 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
@@ -12,7 +12,7 @@ neogradle.subsystems.conventions.runs.enabled=false

 # Mod properties
 isUnstable=true
-modVersion=1.111.1
+modVersion=1.116.1

 # Minecraft properties: We want to configure this here so we can read it in settings.gradle
-mcVersion=1.21
+mcVersion=1.21.10
--- a/gradle/gradle-daemon-jvm.properties
+++ b/gradle/gradle-daemon-jvm.properties
@@ -0,0 +1,2 @@
+#This file is generated by updateDaemonJvm
+toolchainVersion=21
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -7,72 +7,74 @@
 # Minecraft
 # MC version is specified in gradle.properties, as we need that in settings.gradle.
 # 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"
+fabric-api = "0.135.0+1.21.10"
+fabric-loader = "0.17.3"
+neoForge = "21.10.6-beta"
+neoMergeTool = "2.0.0"
 mixin = "0.8.5"
-parchment = "2024.06.16"
-parchmentMc = "1.20.6"
-yarn = "1.21+build.1"
+parchment = "2025.10.12"
+parchmentMc = "1.21.10"
+yarn = "1.21.10+build.2"

 # Core dependencies (these versions are tied to the version Minecraft uses)
-fastutil = "8.5.12"
-guava = "32.1.2-jre"
-netty = "4.1.97.Final"
-slf4j = "2.0.9"
+fastutil = "8.5.15"
+guava = "33.3.1-jre"
+netty = "4.1.118.Final"
+slf4j = "2.0.16"

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

 # Minecraft mods
-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 = "16.0.729"
-rubidium = "0.6.1"
-sodium = "mc1.20-0.4.10"
+fabricPermissions = "0.3.3"
+iris-fabric = "1.9.1+1.21.7-fabric"
+iris-forge = "1.9.1+1.21.7-neoforge"
+jei = "26.0.0.1"
+modmenu = "16.0.0-rc.1"
+moreRed = "6.0.0.3"
+rei = "18.0.800"
+sodium-fabric = "mc1.21.6-0.6.13-fabric"
+sodium-forge = "mc1.21.6-0.6.13-neoforge"
 mixinExtra = "0.3.5"
+create-forge = "6.0.0-6"
+create-fabric = "0.5.1-f-build.1467+mc1.20.1"

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

 # Build tools
-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"
+cctJavadoc = "1.8.5"
+checkstyle = "10.23.1"
+errorProne-core = "2.38.0"
+errorProne-plugin = "4.1.0"
+fabric-loom = "1.11.8"
 githubRelease = "2.5.2"
 gradleVersions = "0.50.0"
 ideaExt = "1.1.7"
-illuaminate = "0.1.0-73-g43ee16c"
+illuaminate = "0.1.0-83-g1131f68"
 lwjgl = "3.3.3"
 minotaur = "2.8.7"
-neoGradle = "7.0.152"
-nullAway = "0.10.25"
-spotless = "6.23.3"
+modDevGradle = "2.0.113"
+nullAway = "0.12.7"
+shadow = "8.3.1"
+spotless = "7.0.2"
 taskTree = "2.1.1"
-teavm = "0.11.0-SQUID.1"
-vanillaExtract = "0.1.3"
+teavm = "0.13.0-SQUID.1"
+vanillaExtract = "0.3.0"
 versionCatalogUpdate = "0.8.1"

 [libraries]
@@ -84,41 +86,43 @@ 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" }
-neoForgeSpi = { module = "net.neoforged:neoforgespi", version.ref = "neoForgeSpi" }
+neoMergeTool = { module = "net.neoforged:mergetool", version.ref = "neoMergeTool" }
 guava = { module = "com.google.guava:guava", version.ref = "guava" }
 jetbrainsAnnotations = { module = "org.jetbrains:annotations", version.ref = "jetbrainsAnnotations" }
-jsr305 = { module = "com.google.code.findbugs:jsr305", version.ref = "jsr305" }
+jspecify = { module = "org.jspecify:jspecify", version.ref = "jspecify" }
 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-socks = { module = "io.netty:netty-codec-socks", 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" }
 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.21.1", version.ref = "create-forge" }
 fabric-api = { module = "net.fabricmc.fabric-api:fabric-api", version.ref = "fabric-api" }
-fabric-loader = { module = "net.fabricmc:fabric-loader", version.ref = "fabric-loader" }
 fabric-junit = { module = "net.fabricmc:fabric-loader-junit", version.ref = "fabric-loader" }
+fabric-loader = { module = "net.fabricmc:fabric-loader", 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.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" }
+iris-fabric = { module = "maven.modrinth:iris", version.ref = "iris-fabric" }
+iris-forge = { module = "maven.modrinth:iris", version.ref = "iris-forge" }
+jei-api = { module = "mezz.jei:jei-1.21.10-common-api", version.ref = "jei" }
+jei-fabric = { module = "mezz.jei:jei-1.21.10-fabric", version.ref = "jei" }
+jei-forge = { module = "mezz.jei:jei-1.21.10-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" }
+moreRed = { module = "net.commoble.morered:morered-1.21.1", version.ref = "moreRed" }
 rei-api = { module = "me.shedaniel:RoughlyEnoughItems-api", version.ref = "rei" }
 rei-builtin = { module = "me.shedaniel:RoughlyEnoughItems-default-plugin", version.ref = "rei" }
 rei-fabric = { module = "me.shedaniel:RoughlyEnoughItems-fabric", version.ref = "rei" }
-rubidium = { module = "maven.modrinth:rubidium", version.ref = "rubidium" }
-sodium = { module = "maven.modrinth:sodium", version.ref = "sodium" }
+sodium-fabric = { module = "maven.modrinth:sodium", version.ref = "sodium.fabric" }
+sodium-forge = { module = "maven.modrinth:sodium", version.ref = "sodium.forge" }

 # Testing
 hamcrest = { module = "org.hamcrest:hamcrest", version.ref = "hamcrest" }
@@ -127,6 +131,7 @@ 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" }
@@ -140,7 +145,6 @@ 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" }
@@ -150,8 +154,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" }
@@ -169,23 +173,24 @@ 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 = ["jsr305", "checkerFramework", "jetbrainsAnnotations"]
+annotations = ["checkerFramework", "jetbrainsAnnotations", "jspecify"]
 kotlin = ["kotlin-stdlib", "kotlin-coroutines"]

 # Minecraft
-externalMods-common = ["jei-api", "nightConfig-core", "nightConfig-toml"]
-externalMods-forge-compile = ["moreRed", "oculus", "jei-api"]
+externalMods-common = ["iris-forge", "jei-api", "nightConfig-core", "nightConfig-toml"]
+externalMods-forge-compile = ["moreRed", "iris-forge", "jei-api"]
 externalMods-forge-runtime = ["jei-forge"]
-externalMods-fabric-compile = ["fabricPermissions", "iris", "jei-api", "rei-api", "rei-builtin"]
-externalMods-fabric-runtime = ["jei-fabric", "modmenu"]
+externalMods-fabric-compile = ["fabricPermissions", "iris-fabric", "jei-api", "rei-api", "rei-builtin"]
+externalMods-fabric-runtime = []

 # Testing
 test = ["junit-jupiter-api", "junit-jupiter-params", "hamcrest", "jqwik-api"]
-testRuntime = ["junit-jupiter-engine", "jqwik-engine"]
+testRuntime = ["junit-jupiter-engine", "junit-platform-launcher", "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.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
--- a/10
+++ b/10
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#

 ##############################################################################
 #
@@ -84,7 +86,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 "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit

 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -112,7 +114,7 @@ case "$( uname )" in                #(
  NONSTOP* )        nonstop=true ;;
 esac

-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+CLASSPATH="\\\"\\\""


 # Determine the Java command to use to start the JVM.
@@ -203,7 +205,7 @@ fi
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'

 # Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
 #     and any embedded shellness will be escaped.
 #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
 #     treated as '${Hostname}' itself on the command line.
@@ -211,7 +213,7 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 set -- \
        "-Dorg.gradle.appname=$APP_BASE_NAME" \
        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
        "$@"

 # Stop when "xargs" is not available.
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,6 +13,8 @@
@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 ##########################################################################
@@ -68,11 +70,11 @@ goto fail
 :execute
@rem Setup the command line

-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+set CLASSPATH=


@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*

 :end
@rem End local scope for the variables with windows NT shell
--- 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": "^15.2.1",
-    "@rollup/plugin-typescript": "^11.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-typescript": "^12.0.0",
    "@rollup/plugin-url": "^8.0.1",
    "@swc/core": "^1.3.92",
-    "@types/node": "^20.8.3",
+    "@types/node": "^24.0.0",
    "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,6 +8,8 @@ plugins {
    id("cc-tweaked.vanilla")
 }

+val mcVersion: String by extra
+
 java {
    withJavadocJar()
 }
@@ -16,9 +18,58 @@ 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")

+    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",
+            ),
+        )
+
+        addBooleanOption("-allow-script-in-comments", true)
+        bottom(
+            """
+            <script src="https://cdn.jsdelivr.net/npm/prismjs@v1.29.0/components/prism-core.min.js"></script>
+            <script src="https://cdn.jsdelivr.net/npm/prismjs@v1.29.0/plugins/autoloader/prism-autoloader.min.js"></script>
+            <link href=" https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism.min.css " rel="stylesheet">
+            """.trimIndent(),
+        )
+
+        val snippetSources = listOf(":common", ":fabric", ":forge").flatMap {
+            project(it).sourceSets["examples"].allSource.sourceDirectories
+        }
+        inputs.files(snippetSources)
+        addPathOption("-snippet-path").value = snippetSources
+    }
+
    // 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/ModelLocation.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/ModelLocation.java
@@ -1,84 +0,0 @@
-// 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/StandaloneModel.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/StandaloneModel.java
@@ -0,0 +1,181 @@
+// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client;
+
+import com.google.common.base.Suppliers;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.SheetedDecalTextureGenerator;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModel;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.Sheets;
+import net.minecraft.client.renderer.SubmitNodeCollector;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.renderer.feature.ModelFeatureRenderer;
+import net.minecraft.client.renderer.item.BlockModelWrapper;
+import net.minecraft.client.renderer.item.ItemModel;
+import net.minecraft.client.renderer.item.ItemModelResolver;
+import net.minecraft.client.renderer.item.ItemStackRenderState;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.resources.model.BlockModelRotation;
+import net.minecraft.client.resources.model.ModelBaker;
+import net.minecraft.client.resources.model.ModelBakery;
+import net.minecraft.client.resources.model.ResolvedModel;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.ARGB;
+import net.minecraft.world.entity.ItemOwner;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+import org.joml.Vector3f;
+import org.jspecify.annotations.Nullable;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * A standalone model.
+ * <p>
+ * This is very similar to vanilla's {@link BlockModelWrapper}, but suitable for use in both {@link ItemModel}s and
+ * block models. This is primarily intended for use with {@link TurtleUpgradeModel}s.
+ */
+public final class StandaloneModel {
+    private final List<BakedQuad> quads;
+    private final boolean useBlockLight;
+    private final TextureAtlasSprite particleIcon;
+    private final RenderType renderType;
+    private final Supplier<Vector3f[]> extents;
+
+    /**
+     * Construct a new {@link StandaloneModel}.
+     *
+     * @param quads          The list of quads which form this model.
+     * @param usesBlockLight Whether this uses block lighting. See {@link ItemStackRenderState.LayerRenderState#setUsesBlockLight(boolean)}.
+     * @param particleIcon   The sprite for the model's particles. See {@link ItemStackRenderState.LayerRenderState#setParticleIcon(TextureAtlasSprite)}.
+     * @param renderType     The render type for this model.
+     */
+    public StandaloneModel(List<BakedQuad> quads, boolean usesBlockLight, TextureAtlasSprite particleIcon, RenderType renderType) {
+        this.quads = quads;
+        this.useBlockLight = usesBlockLight;
+        this.particleIcon = particleIcon;
+        this.renderType = renderType;
+        this.extents = Suppliers.memoize(() -> BlockModelWrapper.computeExtents(quads));
+    }
+
+    /**
+     * Load a model from a {@link ModelBaker} and bake it.
+     *
+     * @param model The model id to load.
+     * @param baker The model baker.
+     * @return The baked {@link StandaloneModel}.
+     */
+    public static StandaloneModel of(ResourceLocation model, ModelBaker baker) {
+        return of(baker.getModel(model), baker);
+    }
+
+    /**
+     * Bake a {@link ResolvedModel} into a {@link StandaloneModel}.
+     *
+     * @param model The resolved model.
+     * @param baker The model baker.
+     * @return The baked {@link StandaloneModel}.
+     */
+    public static StandaloneModel of(ResolvedModel model, ModelBaker baker) {
+        return baker.compute(new CacheKey(model));
+    }
+
+    private record CacheKey(ResolvedModel model) implements ModelBaker.SharedOperationKey<StandaloneModel> {
+        @Override
+        public StandaloneModel compute(ModelBaker baker) {
+            return ofUncached(model(), baker);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            return other instanceof CacheKey(var otherModel) && model() == otherModel;
+        }
+
+        @Override
+        public int hashCode() {
+            return System.identityHashCode(model());
+        }
+    }
+
+    private static StandaloneModel ofUncached(ResolvedModel model, ModelBaker baker) {
+        var slots = model.getTopTextureSlots();
+        return new StandaloneModel(
+            model.bakeTopGeometry(slots, baker, BlockModelRotation.X0_Y0).getAll(),
+            model.getTopGuiLight().lightLikeBlock(),
+            model.resolveParticleSprite(slots, baker),
+            Sheets.translucentItemSheet()
+        );
+    }
+
+    /**
+     * Set up an {@link ItemStackRenderState.LayerRenderState} to render this model.
+     *
+     * @param layer The layer to set up.
+     * @see ItemModel#update(ItemStackRenderState, ItemStack, ItemModelResolver, ItemDisplayContext, ClientLevel, ItemOwner, int)
+     */
+    public void setupItemLayer(ItemStackRenderState.LayerRenderState layer) {
+        layer.setExtents(extents);
+        layer.setRenderType(renderType);
+        layer.setUsesBlockLight(useBlockLight);
+        layer.setParticleIcon(particleIcon);
+        layer.prepareQuadList().addAll(quads);
+    }
+
+    /**
+     * Render the model directly.
+     *
+     * @param transform The current pose stack transformations.
+     * @param collector The node collector to render to.
+     * @param light     The current light texture coordinate.
+     * @param overlay   The current overlay texture coordinate.
+     */
+    public void submit(PoseStack transform, SubmitNodeCollector collector, int light, int overlay) {
+        submit(transform, collector, light, overlay, null, null);
+    }
+
+    /**
+     * Render the model directly.
+     *
+     * @param transform        The current pose stack transformations.
+     * @param collector        The node collector to render to.
+     * @param light            The current light texture coordinate.
+     * @param overlay          The current overlay texture coordinate.
+     * @param tints            The tints for this model.
+     * @param crumblingOverlay The current breaking progress.
+     */
+    public void submit(PoseStack transform, SubmitNodeCollector collector, int light, int overlay, int @Nullable [] tints, ModelFeatureRenderer.@Nullable CrumblingOverlay crumblingOverlay) {
+        collector.submitCustomGeometry(transform, renderType, (pose, buffer) -> render(pose, buffer, tints, light, overlay));
+
+        if (crumblingOverlay != null && renderType.affectsCrumbling()) {
+            // FIXME: We need a custom hook here, which renders to crumblingBufferSource. Currently the DESTROY_TYPES
+            //  buffer gets flushed before the main model gets rendered.
+            collector.submitCustomGeometry(transform, ModelBakery.DESTROY_TYPES.get(crumblingOverlay.progress()), (pose, buffer) ->
+                render(pose, new SheetedDecalTextureGenerator(buffer, crumblingOverlay.cameraPose(), 1.0f), null, light, overlay)
+            );
+        }
+    }
+
+    private void render(PoseStack.Pose pose, VertexConsumer buffer, int @Nullable [] tints, int light, int overlay) {
+        for (var quad : quads) {
+            float r, g, b, a;
+            var idx = quad.tintIndex();
+            if (tints != null && idx >= 0 && idx < tints.length) {
+                var tint = tints[idx];
+                r = ARGB.red(tint) / 255.0f;
+                g = ARGB.green(tint) / 255.0f;
+                b = ARGB.blue(tint) / 255.0f;
+                a = ARGB.alpha(tint) / 255.0f;
+            } else {
+                r = g = b = a = 1.0f;
+            }
+
+            buffer.putBulkData(pose, quad, r, g, b, a, light, overlay);
+        }
+    }
+}
--- 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
@@ -1,66 +0,0 @@
-// SPDX-FileCopyrightText: 2020 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-
-package dan200.computercraft.api.client;
-
-import com.mojang.math.Transformation;
-import dan200.computercraft.impl.client.ClientPlatformHelper;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.resources.model.BakedModel;
-import net.minecraft.client.resources.model.ModelResourceLocation;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-
-/**
- * A model to render, combined with a transformation matrix to apply.
- *
- * @param model  The model.
- * @param matrix The transformation matrix.
- */
-public record TransformedModel(BakedModel model, Transformation matrix) {
-    public TransformedModel(BakedModel model) {
-        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));
-    }
-
-    public static TransformedModel of(ItemStack item, Transformation transform) {
-        var model = Minecraft.getInstance().getItemRenderer().getItemModelShaper().getItemModel(item);
-        return new TransformedModel(model, transform);
-    }
-}
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/BasicUpgradeModel.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/BasicUpgradeModel.java
@@ -0,0 +1,87 @@
+// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client.turtle;
+
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import dan200.computercraft.api.ComputerCraftAPI;
+import dan200.computercraft.api.client.StandaloneModel;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.api.upgrades.UpgradeData;
+import net.minecraft.client.renderer.block.model.ItemTransform;
+import net.minecraft.client.renderer.item.BlockModelWrapper;
+import net.minecraft.client.renderer.item.ItemModelResolver;
+import net.minecraft.client.renderer.item.ItemStackRenderState;
+import net.minecraft.client.resources.model.ModelBaker;
+import net.minecraft.resources.ResourceLocation;
+
+/**
+ * A {@link TurtleUpgradeModel} that renders a basic model.
+ * <p>
+ * This is the {@link TurtleUpgradeModel} equivalent of {@link BlockModelWrapper}.
+ */
+public final class BasicUpgradeModel implements TurtleUpgradeModel {
+    public static final ResourceLocation ID = ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "sided");
+    public static final MapCodec<? extends TurtleUpgradeModel.Unbaked> CODEC = RecordCodecBuilder.<Unbaked>mapCodec(instance -> instance.group(
+        ResourceLocation.CODEC.fieldOf("left").forGetter(Unbaked::left),
+        ResourceLocation.CODEC.fieldOf("right").forGetter(Unbaked::right)
+    ).apply(instance, Unbaked::new));
+
+    private final StandaloneModel left;
+    private final StandaloneModel right;
+
+    private BasicUpgradeModel(StandaloneModel left, StandaloneModel right) {
+        this.left = left;
+        this.right = right;
+    }
+
+    /**
+     * Create an unbaked {@link BasicUpgradeModel}.
+     *
+     * @param left  The model when equipped on the left.
+     * @param right The model when equipped on the right.
+     * @return The unbaked turtle upgrade model.
+     */
+    public static TurtleUpgradeModel.Unbaked unbaked(ResourceLocation left, ResourceLocation right) {
+        return new Unbaked(left, right);
+    }
+
+    private StandaloneModel getModel(TurtleSide side) {
+        return switch (side) {
+            case LEFT -> left;
+            case RIGHT -> right;
+        };
+    }
+
+    @Override
+    public void renderForItem(UpgradeData<ITurtleUpgrade> upgrade, TurtleSide side, ItemStackRenderState renderer, ItemModelResolver resolver, ItemTransform transform, int seed) {
+        renderer.appendModelIdentityElement(this);
+        renderer.appendModelIdentityElement(side);
+        renderer.appendModelIdentityElement(transform);
+
+        var layer = renderer.newLayer();
+        layer.setTransform(transform);
+        getModel(side).setupItemLayer(layer);
+    }
+
+    private record Unbaked(ResourceLocation left, ResourceLocation right) implements TurtleUpgradeModel.Unbaked {
+        @Override
+        public MapCodec<? extends TurtleUpgradeModel.Unbaked> type() {
+            return CODEC;
+        }
+
+        @Override
+        public TurtleUpgradeModel bake(ModelBaker baker) {
+            return new BasicUpgradeModel(StandaloneModel.of(left(), baker), StandaloneModel.of(right(), baker));
+        }
+
+        @Override
+        public void resolveDependencies(Resolver resolver) {
+            resolver.markDependency(left());
+            resolver.markDependency(right());
+        }
+    }
+}
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/ItemUpgradeModel.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/ItemUpgradeModel.java
@@ -0,0 +1,131 @@
+// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client.turtle;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.math.Axis;
+import com.mojang.math.Transformation;
+import com.mojang.serialization.MapCodec;
+import dan200.computercraft.api.ComputerCraftAPI;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.api.upgrades.UpgradeData;
+import net.minecraft.client.renderer.SubmitNodeCollector;
+import net.minecraft.client.renderer.block.model.ItemTransform;
+import net.minecraft.client.renderer.item.ItemModelResolver;
+import net.minecraft.client.renderer.item.ItemStackRenderState;
+import net.minecraft.client.renderer.item.TrackingItemStackRenderState;
+import net.minecraft.client.renderer.special.SpecialModelRenderer;
+import net.minecraft.client.resources.model.ModelBaker;
+import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+import org.jspecify.annotations.Nullable;
+
+import java.util.Set;
+
+/**
+ * A sic {@link TurtleUpgradeModel} that renders 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}
+ * model type. It will not appear correct for 3D models with additional depth, such as blocks.
+ */
+public final class ItemUpgradeModel implements TurtleUpgradeModel {
+    private static final TurtleUpgradeModel.Unbaked UNBAKED = new Unbaked();
+    private static final TurtleUpgradeModel INSTANCE = new ItemUpgradeModel();
+
+    public static final ResourceLocation ID = ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "item");
+    public static final MapCodec<TurtleUpgradeModel.Unbaked> CODEC = MapCodec.unit(UNBAKED);
+
+    private static final TransformedRenderer LEFT = computeRenderer(TurtleSide.LEFT);
+    private static final TransformedRenderer RIGHT = computeRenderer(TurtleSide.RIGHT);
+
+    private ItemUpgradeModel() {
+    }
+
+    /**
+     * Get the unbaked {@link ItemUpgradeModel}.
+     *
+     * @return The unbaked item upgrade model.
+     */
+    public static TurtleUpgradeModel.Unbaked unbaked() {
+        return UNBAKED;
+    }
+
+    @Override
+    public void renderForItem(UpgradeData<ITurtleUpgrade> upgrade, TurtleSide side, ItemStackRenderState renderer, ItemModelResolver resolver, ItemTransform transform, int seed) {
+        renderer.appendModelIdentityElement(this);
+
+        var childState = new TrackingItemStackRenderState();
+        resolver.updateForTopItem(childState, upgrade.getUpgradeItem(), ItemDisplayContext.NONE, null, null, seed);
+        if (!childState.isEmpty()) {
+            renderer.appendModelIdentityElement(childState.getModelIdentity());
+            renderer.appendModelIdentityElement(transform);
+
+            var layer = renderer.newLayer();
+            layer.setTransform(transform);
+            layer.setupSpecialModel(getRenderer(side), childState);
+        }
+    }
+
+    private static final class Unbaked implements TurtleUpgradeModel.Unbaked {
+        @Override
+        public MapCodec<? extends TurtleUpgradeModel.Unbaked> type() {
+            return CODEC;
+        }
+
+        @Override
+        public TurtleUpgradeModel bake(ModelBaker baker) {
+            return INSTANCE;
+        }
+
+        @Override
+        public void resolveDependencies(Resolver resolver) {
+        }
+    }
+
+    private static TransformedRenderer computeRenderer(TurtleSide side) {
+        var pose = new Matrix4f();
+        pose.translate(0.5f, 0.5f, 0.5f);
+        pose.rotate(Axis.YN.rotationDegrees(90f));
+        pose.rotate(Axis.ZP.rotationDegrees(90f));
+        pose.translate(0.0f, 0.0f, side == TurtleSide.RIGHT ? -0.4065f : 0.4065f);
+        return new TransformedRenderer(new Transformation(pose));
+    }
+
+    private static TransformedRenderer getRenderer(TurtleSide side) {
+        return switch (side) {
+            case LEFT -> LEFT;
+            case RIGHT -> RIGHT;
+        };
+    }
+
+    private record TransformedRenderer(Transformation transform) implements SpecialModelRenderer<ItemStackRenderState> {
+        @Override
+        public void submit(
+            @Nullable ItemStackRenderState state, ItemDisplayContext context, PoseStack poseStack, SubmitNodeCollector sink,
+            int light, int overlay, boolean foil, int outlineColour
+        ) {
+            if (state == null) return;
+            poseStack.pushPose();
+            poseStack.mulPose(transform.getMatrix());
+            state.submit(poseStack, sink, light, overlay, outlineColour);
+            poseStack.popPose();
+        }
+
+        @Override
+        public void getExtents(Set<Vector3f> set) {
+        }
+
+        @Override
+        public @Nullable ItemStackRenderState extractArgument(ItemStack itemStack) {
+            return null;
+        }
+    }
+}
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/RegisterTurtleUpgradeModel.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/RegisterTurtleUpgradeModel.java
@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client.turtle;
+
+import com.mojang.serialization.MapCodec;
+import net.minecraft.resources.ResourceLocation;
+
+/**
+ * A functional interface to register a {@link TurtleUpgradeModel}.
+ * <p>
+ * This interface is largely intended to be used from multi-loader code, to allow sharing registration code between
+ * multiple loaders.
+ */
+@FunctionalInterface
+public interface RegisterTurtleUpgradeModel {
+    /**
+     * Register a {@link TurtleUpgradeModel}.
+     *
+     * @param id    The id used for this type of upgrade model.
+     * @param model The codec used to read/decode an upgrade model.
+     */
+    void register(ResourceLocation id, MapCodec<? extends TurtleUpgradeModel.Unbaked> model);
+}
--- 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
@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.client.turtle;
-
-import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.api.upgrades.UpgradeType;
-
-/**
- * A functional interface to register a {@link TurtleUpgradeModeller} for a class of turtle upgrades.
- * <p>
- * This interface is largely intended to be used from multi-loader code, to allow sharing registration code between
- * multiple loaders.
- */
-@FunctionalInterface
-public interface RegisterTurtleUpgradeModeller {
-    /**
-     * Register a {@link TurtleUpgradeModeller}.
-     *
-     * @param type     The turtle upgrade type.
-     * @param modeller The upgrade modeller.
-     * @param <T>      The type of the turtle upgrade.
-     */
-    <T extends ITurtleUpgrade> void register(UpgradeType<T> type, TurtleUpgradeModeller<T> modeller);
-}
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/SelectUpgradeModel.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/SelectUpgradeModel.java
@@ -0,0 +1,201 @@
+// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client.turtle;
+
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Multiset;
+import com.mojang.datafixers.util.Pair;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import dan200.computercraft.api.ComputerCraftAPI;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.api.upgrades.UpgradeData;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import net.minecraft.Util;
+import net.minecraft.client.renderer.block.model.ItemTransform;
+import net.minecraft.client.renderer.item.ItemModelResolver;
+import net.minecraft.client.renderer.item.ItemStackRenderState;
+import net.minecraft.client.renderer.item.SelectItemModel;
+import net.minecraft.client.resources.model.MissingBlockModel;
+import net.minecraft.client.resources.model.ModelBaker;
+import net.minecraft.core.component.DataComponentType;
+import net.minecraft.resources.ResourceLocation;
+import org.jspecify.annotations.Nullable;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * A {@link TurtleUpgradeModel} which selects between different models based on the value of a component in
+ * {@linkplain UpgradeData#data() the upgrade's data}.
+ * <p>
+ * This is the {@link TurtleUpgradeModel} equivalent of {@link SelectItemModel}.
+ *
+ * @param <T> The type of value to switch on.
+ */
+public final class SelectUpgradeModel<T> implements TurtleUpgradeModel {
+    public static final ResourceLocation ID = ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "select");
+    public static final MapCodec<? extends TurtleUpgradeModel.Unbaked> CODEC = RecordCodecBuilder.<Unbaked<?>>mapCodec(instance -> instance.group(
+        Cases.CODEC.forGetter(Unbaked::cases),
+        TurtleUpgradeModel.CODEC.optionalFieldOf("fallback").forGetter(Unbaked::fallback)
+    ).apply(instance, Unbaked::new));
+
+    private final DataComponentType<T> component;
+    private final Map<T, TurtleUpgradeModel> cases;
+    private final TurtleUpgradeModel fallback;
+
+    private SelectUpgradeModel(DataComponentType<T> component, Map<T, TurtleUpgradeModel> cases, TurtleUpgradeModel fallback) {
+        this.component = component;
+        this.cases = cases;
+        this.fallback = fallback;
+    }
+
+    private TurtleUpgradeModel getModel(UpgradeData<ITurtleUpgrade> upgrade) {
+        var value = upgrade.get(component);
+        if (value == null) return fallback;
+
+        var model = cases.get(value);
+        return model != null ? model : fallback;
+    }
+
+    @Override
+    public void renderForItem(UpgradeData<ITurtleUpgrade> upgrade, TurtleSide side, ItemStackRenderState renderer, ItemModelResolver resolver, ItemTransform transform, int seed) {
+        getModel(upgrade).renderForItem(upgrade, side, renderer, resolver, transform, seed);
+    }
+
+    private record Unbaked<T>(
+        Cases<T> cases,
+        Optional<TurtleUpgradeModel.Unbaked> fallback
+    ) implements TurtleUpgradeModel.Unbaked {
+        private static final TurtleUpgradeModel.Unbaked MISSING = BasicUpgradeModel.unbaked(MissingBlockModel.LOCATION, MissingBlockModel.LOCATION);
+
+        @Override
+        public MapCodec<? extends TurtleUpgradeModel.Unbaked> type() {
+            return CODEC;
+        }
+
+        @Override
+        public TurtleUpgradeModel bake(ModelBaker baker) {
+            Map<T, TurtleUpgradeModel> cases = new Object2ObjectOpenHashMap<>();
+            for (var condition : cases().cases()) {
+                var model = condition.getSecond().bake(baker);
+                for (var when : condition.getFirst()) cases.put(when, model);
+            }
+
+            return new SelectUpgradeModel<>(cases().component(), cases, fallback().orElse(MISSING).bake(baker));
+        }
+
+        @Override
+        public void resolveDependencies(Resolver resolver) {
+            cases().cases().forEach(x -> x.getSecond().resolveDependencies(resolver));
+            fallback().orElse(MISSING).resolveDependencies(resolver);
+        }
+    }
+
+    private record Cases<T>(DataComponentType<T> component, List<Pair<List<T>, TurtleUpgradeModel.Unbaked>> cases) {
+        private static final MapCodec<Cases<?>> CODEC = DataComponentType.CODEC.dispatchMap("property", Cases::component, Util.memoize(Cases::codec));
+
+        private static <T> MapCodec<Cases<T>> codec(DataComponentType<T> component) {
+            return RecordCodecBuilder.mapCodec(instance -> instance.group(
+                MapCodec.unit(component).forGetter(Cases::component),
+                caseCodec(component.codecOrThrow()).listOf().fieldOf("cases").validate(Cases::validate).forGetter(Cases::cases)
+            ).apply(instance, Cases<T>::new));
+        }
+
+        private static <T> Codec<Pair<List<T>, TurtleUpgradeModel.Unbaked>> caseCodec(Codec<T> codec) {
+            return RecordCodecBuilder.create(instance -> instance.group(
+                codec.listOf().fieldOf("when").forGetter(Pair::getFirst),
+                TurtleUpgradeModel.CODEC.fieldOf("model").forGetter(Pair::getSecond)
+            ).apply(instance, Pair::new));
+        }
+
+        private static <T> DataResult<List<Pair<List<T>, TurtleUpgradeModel.Unbaked>>> validate(List<Pair<List<T>, TurtleUpgradeModel.Unbaked>> cases) {
+            Multiset<T> multiset = HashMultiset.create();
+            for (var condition : cases) multiset.addAll(condition.getFirst());
+
+            if (multiset.isEmpty()) return DataResult.error(() -> "Empty cases");
+            if (multiset.size() != multiset.entrySet().size()) {
+                return DataResult.error(() -> "Duplicate case conditions: " + multiset.entrySet().stream()
+                    .filter(x -> x.getCount() > 1)
+                    .map(x -> Objects.toString(x.getElement()))
+                    .collect(Collectors.joining(", ")));
+            }
+
+            return DataResult.success(cases);
+        }
+    }
+
+    /**
+     * Create a {@link SelectUpgradeModel} that selects a model based on a component.
+     *
+     * @param component The component to select.
+     * @param <T>       The type the component stores.
+     * @return A {@link Builder}.
+     */
+    public static <T> Builder<T> onComponent(DataComponentType<T> component) {
+        return new Builder<>(component);
+    }
+
+    /**
+     * A builder for constructing {@link SelectUpgradeModel}s.
+     *
+     * @param <T> The type of value to switch on.
+     */
+    public static final class Builder<T> {
+        private final DataComponentType<T> component;
+        private final List<Pair<List<T>, TurtleUpgradeModel.Unbaked>> cases = new ArrayList<>();
+        private TurtleUpgradeModel.@Nullable Unbaked fallback;
+
+        private Builder(DataComponentType<T> component) {
+            this.component = component;
+        }
+
+        /**
+         * Add a case to our model.
+         *
+         * @param value The value for this case.
+         * @param model The model to use.
+         * @return {@code this}, for chaining.
+         */
+        public Builder<T> when(T value, TurtleUpgradeModel.Unbaked model) {
+            return when(List.of(value), model);
+        }
+
+        /**
+         * Add a case to our model.
+         *
+         * @param values The value(s) for this case.
+         * @param model  The model to use.
+         * @return {@code this}, for chaining.
+         */
+        public Builder<T> when(List<T> values, TurtleUpgradeModel.Unbaked model) {
+            cases.add(Pair.of(values, model));
+            return this;
+        }
+
+        /**
+         * Add a fallback value, when no previous value matches or the component is not present.
+         *
+         * @param model The fallback model.
+         * @return {@code this}, for chaining.
+         */
+        public Builder<T> fallback(TurtleUpgradeModel.Unbaked model) {
+            this.fallback = model;
+            return this;
+        }
+
+        /**
+         * Convert this builder into an unbaked model.
+         *
+         * @return The unbaked {@link SelectUpgradeModel}.
+         */
+        public TurtleUpgradeModel.Unbaked create() {
+            return new Unbaked<>(new Cases<>(component, cases), Optional.ofNullable(fallback));
+        }
+    }
+}
--- a/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModel.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModel.java
@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client.turtle;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import dan200.computercraft.api.ComputerCraftAPI;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.api.upgrades.UpgradeData;
+import dan200.computercraft.impl.client.ComputerCraftAPIClientService;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.block.model.ItemTransform;
+import net.minecraft.client.renderer.item.ItemModel;
+import net.minecraft.client.renderer.item.ItemModelResolver;
+import net.minecraft.client.renderer.item.ItemStackRenderState;
+import net.minecraft.client.resources.model.ModelBaker;
+import net.minecraft.client.resources.model.ResolvableModel;
+import net.minecraft.world.entity.ItemOwner;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+
+/**
+ * The model for a {@link ITurtleUpgrade}.
+ * <p>
+ * Turtle upgrade models are very similar to vanilla's {@link ItemModel}. Each upgrade's model is defined in JSON, and
+ * loaded from resource packs with other assets.
+ * <p>
+ * In most cases, upgrades can use one of the existing implementations of {@link TurtleUpgradeModel} (e.g.
+ * {@link BasicUpgradeModel} or {@link ItemUpgradeModel}), and do not need to subclass it. However, in the cases where
+ * a custom model is required, one should use
+ * {@code dan200.computercraft.api.client.FabricComputerCraftAPIClient#registerTurtleUpgradeModel} to register a
+ * model on Fabric and {@code dan200.computercraft.api.client.turtle.RegisterTurtleModelEvent} to register one
+ * on Forge.
+ * <p>
+ * See {@link ITurtleUpgrade} for a full example of registering turtle upgrades and their models.
+ *
+ * @see RegisterTurtleUpgradeModel For multi-loader registration support.
+ * @see ItemUpgradeModel A {@code TurtleUpgradeModel} which uses the upgrade's item.
+ * @see BasicUpgradeModel A {@code TurtleUpgradeModel} which renders a simple model.
+ */
+public interface TurtleUpgradeModel {
+    /**
+     * The directory from which turtle upgrade models are loaded. This may be used by data generators.
+     */
+    String SOURCE = ComputerCraftAPI.MOD_ID + "/turtle_upgrade";
+
+    /**
+     * The codec used to read/write {@linkplain TurtleUpgradeModel.Unbaked unbaked upgrade models}.
+     */
+    Codec<TurtleUpgradeModel.Unbaked> CODEC = Codec.lazyInitialized(() -> ComputerCraftAPIClientService.get().getTurtleUpgradeModelCodec());
+
+    /**
+     * Render this upgrade to an {@link ItemStackRenderState}. This is used for rendering the item form of the upgrade.
+     * <p>
+     * Like with {@link ItemModel}, implementations must be careful to call {@link ItemStackRenderState#appendModelIdentityElement}
+     * where appropriate.
+     *
+     * @param upgrade   The upgrade being rendered.
+     * @param side      Which side of the turtle (left or right) the upgrade is equipped on.
+     * @param renderer  The render state to draw to.
+     * @param resolver  The model resolver.
+     * @param transform The root model's transformation.
+     * @param seed      The current model seed.
+     * @see ItemModel#update(ItemStackRenderState, ItemStack, ItemModelResolver, ItemDisplayContext, ClientLevel, ItemOwner, int)
+     */
+    void renderForItem(UpgradeData<ITurtleUpgrade> upgrade, TurtleSide side, ItemStackRenderState renderer, ItemModelResolver resolver, ItemTransform transform, int seed);
+
+    /**
+     * An unbaked turtle model. Much like other unbaked models (e.g. {@link ItemModel.Unbaked}), this should resolve
+     * any dependencies and returned the fully-resolved model.
+     */
+    interface Unbaked extends ResolvableModel {
+        /**
+         * The {@link MapCodec} used to read/write this unbaked model.
+         *
+         * @return The codec used to read/write this model.
+         * @see ItemModel.Unbaked#type()
+         */
+        MapCodec<? extends Unbaked> type();
+
+        /**
+         * Bake this turtle model.
+         *
+         * @param baker The current model baker
+         * @return The baked upgrade model.
+         * @see ItemModel.Unbaked#bake(ItemModel.BakingContext)
+         */
+        TurtleUpgradeModel bake(ModelBaker baker);
+    }
+}
--- 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
@@ -1,105 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-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.UnbakedModel;
-import net.minecraft.core.component.DataComponentPatch;
-import net.minecraft.resources.ResourceLocation;
-
-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
- *
- * @param <T> The type of turtle upgrade this modeller applies to.
- * @see RegisterTurtleUpgradeModeller For multi-loader registration support.
- */
-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, 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.
-     * @param side    Which side of the turtle (left or right) the upgrade resides on.
-     * @param data    Upgrade data instance for current turtle side.
-     * @return The model that you wish to be used to render your upgrade.
-     */
-    TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data);
-
-    /**
-     * Get the models that this turtle modeller depends on.
-     * <p>
-     * 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 Stream<ResourceLocation> getDependencies() {
-        return Stream.of();
-    }
-
-    /**
-     * 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}
-     * model type. It will not appear correct for 3D models with additional depth, such as blocks.
-     *
-     * @param <T> The type of the turtle upgrade.
-     * @return The constructed modeller.
-     */
-    @SuppressWarnings("unchecked")
-    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> flatItem() {
-        return (TurtleUpgradeModeller<T>) TurtleUpgradeModellers.UPGRADE_ITEM;
-    }
-
-    /**
-     * Construct a {@link TurtleUpgradeModeller} which has a single model for the left and right side.
-     *
-     * @param left  The model to use on the left.
-     * @param right The model to use on the right.
-     * @param <T>   The type of the turtle upgrade.
-     * @return The constructed modeller.
-     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ResourceLocation left, ResourceLocation right) {
-        return sided(ModelLocation.ofResource(left), ModelLocation.ofResource(right));
-    }
-
-    /**
-     * Construct a {@link TurtleUpgradeModeller} which has a single model for the left and right side.
-     *
-     * @param left  The model to use on the left.
-     * @param right The model to use on the right.
-     * @param <T>   The type of the turtle upgrade.
-     * @return The constructed modeller.
-     */
-    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, DataComponentPatch data) {
-                return TransformedModel.of(side == TurtleSide.LEFT ? left : right);
-            }
-
-            @Override
-            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
@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.client.turtle;
-
-import com.mojang.math.Transformation;
-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 dan200.computercraft.impl.client.ClientPlatformHelper;
-import net.minecraft.client.Minecraft;
-import net.minecraft.core.component.DataComponentPatch;
-import org.joml.Matrix4f;
-
-import javax.annotation.Nullable;
-
-final class TurtleUpgradeModellers {
-    private static final Transformation leftTransform = getMatrixFor(-0.4065f);
-    private static final Transformation rightTransform = getMatrixFor(0.4065f);
-
-    private static Transformation getMatrixFor(float offset) {
-        var matrix = new Matrix4f();
-        matrix.set(new float[]{
-            0.0f, 0.0f, -1.0f, 1.0f + offset,
-            1.0f, 0.0f, 0.0f, 0.0f,
-            0.0f, -1.0f, 0.0f, 1.0f,
-            0.0f, 0.0f, 0.0f, 1.0f,
-        });
-        matrix.transpose();
-        return new Transformation(matrix);
-    }
-
-    static final TurtleUpgradeModeller<ITurtleUpgrade> UPGRADE_ITEM = new UpgradeItemModeller();
-
-    private static final class UpgradeItemModeller implements TurtleUpgradeModeller<ITurtleUpgrade> {
-        @Override
-        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
@@ -1,71 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-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;
-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 javax.annotation.Nullable;
-
-@ApiStatus.Internal
-public interface ClientPlatformHelper {
-    /**
-     * Get a model from a resource.
-     *
-     * @param manager          The model manager.
-     * @param resourceLocation The model resourceLocation.
-     * @return The baked model.
-     * @see ModelLocation
-     */
-    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.
-     *
-     * @param model The model to wrap.
-     * @return The wrapped model.
-     * @see RenderType#glint()
-     */
-    BakedModel createdFoiledModel(BakedModel model);
-
-    static ClientPlatformHelper get() {
-        var instance = Instance.INSTANCE;
-        return instance == null ? Services.raise(ClientPlatformHelper.class, Instance.ERROR) : instance;
-    }
-
-    final class Instance {
-        static final @Nullable ClientPlatformHelper INSTANCE;
-        static final @Nullable Throwable ERROR;
-
-        static {
-            var helper = Services.tryLoad(ClientPlatformHelper.class);
-            INSTANCE = helper.instance();
-            ERROR = helper.error();
-        }
-
-        private Instance() {
-        }
-    }
-}
--- a/projects/common-api/src/client/java/dan200/computercraft/impl/client/ComputerCraftAPIClientService.java
+++ b/projects/common-api/src/client/java/dan200/computercraft/impl/client/ComputerCraftAPIClientService.java
@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.impl.client;
+
+import com.mojang.serialization.Codec;
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModel;
+import dan200.computercraft.impl.Services;
+import org.jetbrains.annotations.ApiStatus;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * Bridge between implementation
+ * <p>
+ * Do <strong>NOT</strong> directly reference this class. It exists for internal use by the API.
+ */
+@ApiStatus.Internal
+public interface ComputerCraftAPIClientService {
+    static ComputerCraftAPIClientService get() {
+        var instance = Instance.INSTANCE;
+        return instance == null ? Services.raise(ComputerCraftAPIClientService.class, Instance.ERROR) : instance;
+    }
+
+    Codec<TurtleUpgradeModel.Unbaked> getTurtleUpgradeModelCodec();
+
+    final class Instance {
+        static final @Nullable ComputerCraftAPIClientService INSTANCE;
+        static final @Nullable Throwable ERROR;
+
+        static {
+            var helper = Services.tryLoad(ComputerCraftAPIClientService.class);
+            INSTANCE = helper.instance();
+            ERROR = helper.error();
+        }
+
+        private Instance() {
+        }
+    }
+}
--- 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,13 +4,13 @@

 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;
-import dan200.computercraft.api.media.MediaProvider;
 import dan200.computercraft.api.network.PacketNetwork;
 import dan200.computercraft.api.network.wired.WiredElement;
 import dan200.computercraft.api.network.wired.WiredNode;
@@ -24,8 +24,7 @@ import net.minecraft.core.Direction;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
-
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;

 /**
 * The static entry point to the ComputerCraft API.
@@ -141,16 +140,6 @@ public final class ComputerCraftAPI {
        return getInstance().getBundledRedstoneOutput(world, pos, side);
    }

-    /**
-     * Registers a media provider to provide {@link IMedia} implementations for Items.
-     *
-     * @param provider The media provider to register.
-     * @see MediaProvider
-     */
-    public static void registerMediaProvider(MediaProvider provider) {
-        getInstance().registerMediaProvider(provider);
-    }
-
    /**
     * Attempt to get the game-wide wireless network.
     *
@@ -165,7 +154,13 @@ 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.
+     * 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}
     *
     * @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
@@ -28,6 +28,20 @@ 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()}.
--- 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
@@ -0,0 +1,24 @@
+// 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
@@ -0,0 +1,48 @@
+// 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
@@ -0,0 +1,30 @@
+// 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.pocket.PocketComputer;
+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<PocketComputer> 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. Meta will be inserted into a new sub-map named as per {@code namespace}.
+     * Create a new item detail provider. Details 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. Meta will be inserted directly into the results.
+     * Create a new item detail provider. Details will be inserted directly into the results.
     *
     * @param itemType The type the stack's item must have.
     */
@@ -53,21 +53,18 @@ 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 void provideDetails(Map<? super String, Object> data, ItemStack stack) {
+    public final void provideDetails(Map<? super String, Object> data, ItemStack stack) {
        var item = stack.getItem();
        if (!itemType.isInstance(item)) return;

-        // 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) {
+        if (namespace == null) {
+            provideDetails(data, stack, itemType.cast(item));
+        } else {
+            Map<? super String, Object> child = new HashMap<>();
+            provideDetails(child, stack, itemType.cast(item));
            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,8 +8,7 @@ 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 javax.annotation.Nullable;
+import org.jspecify.annotations.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/ComponentDetailProvider.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/detail/ComponentDetailProvider.java
@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.detail;
+
+import net.minecraft.core.component.DataComponentHolder;
+import net.minecraft.core.component.DataComponentType;
+import net.minecraft.world.item.ItemStack;
+import org.jspecify.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * An item detail provider for a specific {@linkplain DataComponentType data component} on {@link ItemStack}s or
+ * other {@link DataComponentHolder}.
+ *
+ * @param <T> The type of the component's contents.
+ */
+public abstract class ComponentDetailProvider<T> implements DetailProvider<DataComponentHolder> {
+    private final DataComponentType<T> component;
+    private final @Nullable String namespace;
+
+    /**
+     * Create a new component detail provider. Details will be inserted into a new sub-map named as per {@code namespace}.
+     *
+     * @param component The data component to provide details for.
+     * @param namespace The namespace to use for this provider.
+     */
+    public ComponentDetailProvider(@Nullable String namespace, DataComponentType<T> component) {
+        Objects.requireNonNull(component);
+        this.component = component;
+        this.namespace = namespace;
+    }
+
+    /**
+     * Create a new component detail provider. Details will be inserted directly into the results.
+     *
+     * @param component The data component to provide details for.
+     */
+    public ComponentDetailProvider(DataComponentType<T> component) {
+        this(null, component);
+    }
+
+    /**
+     * Provide additional details for the given data component. This method is called by {@code turtle.getItemDetail()}.
+     * New properties should be added to the given {@link Map}, {@code data}.
+     * <p>
+     * This method is always called on the server thread, so it is safe to interact with the world here, but you should
+     * take care to avoid long blocking operations as this will stall the server and other computers.
+     *
+     * @param data      The full details to be returned for this item stack. New properties should be added to this map.
+     * @param component The component to provide details for.
+     */
+    public abstract void provideComponentDetails(Map<? super String, Object> data, T component);
+
+    @Override
+    public final void provideDetails(Map<? super String, Object> data, DataComponentHolder holder) {
+        var value = holder.get(component);
+        if (value == null) return;
+
+        if (namespace == null) {
+            provideComponentDetails(data, value);
+        } else {
+            Map<? super String, Object> child = new HashMap<>();
+            provideComponentDetails(child, value);
+            data.put(namespace, child);
+        }
+    }
+}
--- 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,6 +14,7 @@ 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,6 +17,7 @@ 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> {
@@ -26,7 +27,7 @@ public interface DetailRegistry<T> {
     * @param provider The detail provider to register.
     * @see DetailProvider
     */
-    void addProvider(DetailProvider<T> provider);
+    void addProvider(DetailProvider<? super 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,6 +17,9 @@ 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
@@ -0,0 +1,48 @@
+// 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
@@ -0,0 +1,58 @@
+// 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/lua/ILuaAPIFactory.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/lua/ILuaAPIFactory.java
@@ -4,13 +4,14 @@

 package dan200.computercraft.api.lua;

-import javax.annotation.Nullable;
+import dan200.computercraft.api.ComputerCraftAPI;
+import org.jspecify.annotations.Nullable;

 /**
- * Construct an {@link ILuaAPI} for a specific computer.
+ * Construct an {@link ILuaAPI} for a computer.
 *
 * @see ILuaAPI
- * @see dan200.computercraft.api.ComputerCraftAPI#registerAPIFactory(ILuaAPIFactory)
+ * @see ComputerCraftAPI#registerAPIFactory(ILuaAPIFactory)
 */
@FunctionalInterface
 public interface ILuaAPIFactory {
--- 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
@@ -14,14 +14,14 @@ import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.JukeboxSong;
-
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;

 /**
 * Represents an item that can be placed in a disk drive and used by a Computer.
 * <p>
- * Implement this interface on your {@link Item} class to allow it to be used in the drive. Alternatively, register
- * a {@link MediaProvider}.
+ * Implement this interface on your {@link Item} class to allow it to be used in the drive, or register via
+ * {@code dan200.computercraft.api.media.MediaLookup} (Fabric) or {@code dan200.computercraft.api.media.MediaCapability}
+ * (NeoForge).
 */
 public interface IMedia {
    /**
--- 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
@@ -1,27 +0,0 @@
-// Copyright Daniel Ratcliffe, 2011-2022. This API may be redistributed unmodified and in full only.
-//
-// SPDX-License-Identifier: LicenseRef-CCPL
-
-package dan200.computercraft.api.media;
-
-import net.minecraft.world.item.ItemStack;
-
-import javax.annotation.Nullable;
-
-/**
- * This interface is used to provide {@link IMedia} implementations for {@link ItemStack}.
- *
- * @see dan200.computercraft.api.ComputerCraftAPI#registerMediaProvider(MediaProvider)
- */
-@FunctionalInterface
-public interface MediaProvider {
-    /**
-     * Produce an IMedia implementation from an ItemStack.
-     *
-     * @param stack The stack from which to extract the media information.
-     * @return An {@link IMedia} implementation, or {@code null} if the item is not something you wish to handle
-     * @see dan200.computercraft.api.ComputerCraftAPI#registerMediaProvider(MediaProvider)
-     */
-    @Nullable
-    IMedia getMedia(ItemStack stack);
-}
--- 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
@@ -0,0 +1,46 @@
+// 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 tile entity in world. In such as case, one should provide the
+ * Elements are generally tied to a block or block 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 objects on the network change. This may occur when network nodes are added or removed, or when
-     * peripherals change.
+     * 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.
     *
     * @param change The change which occurred.
     * @see WiredNetworkChange
--- 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
@@ -5,44 +5,17 @@
 package dan200.computercraft.api.pocket;

 import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.api.upgrades.UpgradeData;
 import net.minecraft.core.component.DataComponentPatch;
-import net.minecraft.world.entity.Entity;
 import net.minecraft.world.item.ItemStack;
-
-import javax.annotation.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jspecify.annotations.Nullable;

 /**
- * Wrapper class for pocket computers.
+ * Access to a pocket computer for {@linkplain IPocketUpgrade pocket upgrades}.
 */
-public interface IPocketAccess {
-    /**
-     * Gets the entity holding this item.
-     * <p>
-     * This must be called on the server thread.
-     *
-     * @return The holding entity, or {@code null} if none exists.
-     */
-    @Nullable
-    Entity getEntity();
-
-    /**
-     * Get the colour of this pocket computer as a RGB number.
-     *
-     * @return The colour this pocket computer is. This will be a RGB colour between {@code 0x000000} and
-     * {@code 0xFFFFFF} or -1 if it has no colour.
-     * @see #setColour(int)
-     */
-    int getColour();
-
-    /**
-     * Set the colour of the pocket computer to a RGB number.
-     *
-     * @param colour The colour this pocket computer should be changed to. This should be a RGB colour between
-     *               {@code 0x000000} and {@code 0xFFFFFF} or -1 to reset to the default colour.
-     * @see #getColour()
-     */
-    void setColour(int colour);
-
+@ApiStatus.NonExtendable
+public interface IPocketAccess extends PocketComputer {
    /**
     * Get the colour of this pocket computer's light as a RGB number.
     *
@@ -61,6 +34,27 @@ public interface IPocketAccess {
     */
    void setLight(int colour);

+    /**
+     * Get the currently equipped upgrade.
+     *
+     * @return The currently equipped upgrade.
+     * @see #getUpgradeData()
+     * @see #setUpgrade(UpgradeData)
+     */
+    @Nullable
+    UpgradeData<IPocketUpgrade> getUpgrade();
+
+    /**
+     * Set the upgrade for this pocket computer, also updating the item stack.
+     * <p>
+     * This method can only be called from the main server thread, when this computer is {@linkplain #isActive() is
+     * active}.
+     *
+     * @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>
@@ -70,11 +64,15 @@ public interface IPocketAccess {
     * @see #setUpgradeData(DataComponentPatch)
     * @see UpgradeBase#getUpgradeItem(DataComponentPatch)
     * @see UpgradeBase#getUpgradeData(ItemStack)
+     * @see #getUpgrade()
     */
    DataComponentPatch getUpgradeData();

    /**
     * Update the upgrade-specific data.
+     * <p>
+     * This method can only be called from the main server thread, when this computer is {@linkplain #isActive() is
+     * active}.
     *
     * @param data The new upgrade data.
     * @see #getUpgradeData()
--- 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
@@ -12,40 +12,17 @@ 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 javax.annotation.Nullable;
+import net.minecraft.server.level.ServerLevel;
+import org.jspecify.annotations.Nullable;

 /**
 * A peripheral which can be equipped to the back side of a pocket computer.
 * <p>
 * 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.
+ * {@link UpgradeType} instance, which are then registered in a Minecraft 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. 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"
- * }
- * }
+ * the upgrade registered internally.
 */
 public interface IPocketUpgrade extends UpgradeBase {
    ResourceKey<Registry<IPocketUpgrade>> REGISTRY = ResourceKey.createRegistryKey(ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "pocket_upgrade"));
@@ -94,7 +71,7 @@ public interface IPocketUpgrade extends UpgradeBase {
    /**
     * Called when the pocket computer is right clicked.
     *
-     * @param world      The world the computer is in.
+     * @param level      The world the computer is in.
     * @param access     The access object for the pocket item stack.
     * @param peripheral The peripheral for this upgrade.
     * @return {@code true} to stop the GUI from opening, otherwise false. You should always provide some code path
@@ -102,7 +79,7 @@ public interface IPocketUpgrade extends UpgradeBase {
     * access the GUI.
     * @see #createPeripheral(IPocketAccess)
     */
-    default boolean onRightClick(Level world, IPocketAccess access, @Nullable IPeripheral peripheral) {
+    default boolean onRightClick(ServerLevel level, IPocketAccess access, @Nullable IPeripheral peripheral) {
        return false;
    }
 }
--- a/projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketComputer.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketComputer.java
@@ -0,0 +1,81 @@
+// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.pocket;
+
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.ApiStatus;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * A pocket computer.
+ *
+ * @see IPocketAccess
+ * @see dan200.computercraft.api.component.ComputerComponents#POCKET
+ */
+@ApiStatus.NonExtendable
+public interface PocketComputer {
+    /**
+     * 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>
+     * This must be called on the server thread.
+     *
+     * @return The holding entity, or {@code null} if none exists.
+     */
+    @Nullable
+    Entity getEntity();
+
+    /**
+     * Check whether this pocket computer is currently being held by a player, lectern, or other valid entity.
+     * <p>
+     * As pocket computers are backed by item stacks, you must check for validity before updating the computer.
+     * <p>
+     * This must be called on the server thread.
+     *
+     * @return Whether this computer is active.
+     */
+    boolean isActive();
+
+    /**
+     * Get the colour of this pocket computer as an RGB number.
+     *
+     * <p>
+     * This method can only be called from the main server thread, when this computer is {@linkplain #isActive() is
+     * active}.
+     *
+     * @return The colour this pocket computer is. This will be a RGB colour between {@code 0x000000} and
+     * {@code 0xFFFFFF} or -1 if it has no colour.
+     * @see #setColour(int)
+     */
+    int getColour();
+
+    /**
+     * Set the colour of the pocket computer to an RGB number.
+     * <p>
+     * This method can only be called from the main server thread, when this computer is {@linkplain #isActive() is
+     * active}.
+     *
+     * @param colour The colour this pocket computer should be changed to. This should be a RGB colour between
+     *               {@code 0x000000} and {@code 0xFFFFFF} or -1 to reset to the default colour.
+     * @see #getColour()
+     */
+    void setColour(int colour);
+
+}
--- 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
@@ -17,8 +17,7 @@ import net.minecraft.world.Container;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.ApiStatus;
-
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;

 /**
 * The interface passed to turtle by turtles, providing methods that they can call.
--- 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
@@ -11,47 +11,76 @@ import dan200.computercraft.api.upgrades.UpgradeType;
 import dan200.computercraft.impl.ComputerCraftAPIService;
 import net.minecraft.core.Direction;
 import net.minecraft.core.Registry;
+import net.minecraft.core.RegistrySetBuilder.PatchedRegistries;
 import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.Items;
+import org.jspecify.annotations.Nullable;

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

 /**
 * 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 UpgradeType} instance, which are then registered in a registry.
+ * {@link UpgradeType} instance, which are then registered in a Minecraft 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. It is recommended this is done via
- * <a href="../upgrades/UpgradeType.html#datagen">data generators</a>.
+ * the upgrade automatically registered.
 *
 * <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 ITurtleUpgrade>> TURTLE_UPGRADES = DeferredRegister.create(ITurtleUpgrade.typeRegistry(), "my_mod");
+ * <h3>Registering the upgrade type</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.
 *
- * // 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));
+ * {@snippet class=com.example.examplemod.ExampleTurtleUpgrade region=body}
 *
- * // Then in your constructor
- * TURTLE_UPGRADES.register(bus);
- * }
+ * Now we must construct a new upgrade type. In most cases, you can use one of the helper methods (e.g.
+ * {@link UpgradeType#simpleWithCustomItem(Function)}), rather than defining your own implementation.
+ *
+ * {@snippet class=com.example.examplemod.ExampleMod region=turtle_upgrades}
+ *
+ * We now must register this upgrade type. 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 id="datagen">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_upgrade/<my_upgrade_id>.json}.
+ *
+ * {@snippet file=data/examplemod/computercraft/turtle_upgrade/example_turtle_upgrade.json}
+ *
+ * The {@code "type"} field points to the ID of the upgrade type we've just registered, while the other fields are read
+ * by the type itself. As our upgrade was defined with {@link UpgradeType#simpleWithCustomItem(Function)}, the
+ * {@code "item"} field will construct our upgrade with {@link Items#COMPASS}.
 * <p>
- * 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>
- * {@snippet lang="json" :
- * {
- *     "type": "my_mod:my_upgrade"
- * }
- * }
- * <p>
- * Finally, we need to register a model for our upgrade, see
- * {@link dan200.computercraft.api.client.turtle.TurtleUpgradeModeller} for more information.
+ * Similarly, {@linkplain dan200.computercraft.api.client.turtle.TurtleUpgradeModel the upgrade's model} is loaded from
+ * a resource pack, and so we must also create a new JSON file at
+ * {@code assets/<my_mod>/computercraft/turtle_upgrade/<my_upgrade_id>.json}.
+ *
+ * {@snippet file=assets/examplemod/computercraft/turtle_upgrade/example_turtle_upgrade.json}
+ *
+ * Rather than manually creating these file, it is recommended to use data-generators to generate this file. First, we
+ * register our new upgrades into a {@linkplain PatchedRegistries patched registry}. Models must similarly be
+ * registered.
+ *
+ * {@snippet class=com.example.examplemod.data.TurtleUpgradeProvider region=body}
+ *
+ * Next, we must write these upgrades to disk. Vanilla does not have complete support for this yet, so this must be done
+ * with mod-loader-specific APIs.
+ *
+ * <h4>Fabric</h4>
+ * {@snippet class=com.example.examplemod.FabricExampleModDataGenerator region=turtle_upgrades}
+ *
+ * <h4>Forge</h4>
+ * {@snippet class=com.example.examplemod.ForgeExampleModDataGenerator region=turtle_upgrades}
 */
 public interface ITurtleUpgrade extends UpgradeBase {
    /**
--- 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,8 +5,7 @@
 package dan200.computercraft.api.turtle;

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

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

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

-    private TurtleCommandResult(boolean success, @Nullable String errorMessage, @Nullable Object[] results) {
+    private TurtleCommandResult(boolean success, @Nullable String errorMessage, @Nullable Object @Nullable [] results) {
        this.success = success;
        this.errorMessage = errorMessage;
        this.results = results;
@@ -92,8 +91,7 @@ public final class TurtleCommandResult {
     *
     * @return The command's result, or {@code null} if it was a failure.
     */
-    @Nullable
-    public Object[] getResults() {
+    public @Nullable Object @Nullable [] 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
@@ -4,17 +4,33 @@

 package dan200.computercraft.api.turtle;

+import com.mojang.serialization.Codec;
+import net.minecraft.util.StringRepresentable;
+
 /**
- * An enum representing the two sides of the turtle that a turtle turtle might reside.
+ * An enum representing the two sides of the turtle that a turtle upgrade might reside.
 */
-public enum TurtleSide {
+public enum TurtleSide implements StringRepresentable {
    /**
     * The turtle's left side (where the pickaxe usually is on a Wireless Mining Turtle).
     */
-    LEFT,
+    LEFT("left"),

    /**
     * The turtle's right side (where the modem usually is on a Wireless Mining Turtle).
     */
-    RIGHT,
+    RIGHT("right");
+
+    public static final Codec<TurtleSide> CODEC = StringRepresentable.fromEnum(TurtleSide::values);
+
+    private final String name;
+
+    TurtleSide(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String getSerializedName() {
+        return name;
+    }
 }
--- 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
@@ -18,26 +18,18 @@ 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 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
+ * This can be used from your <a href="./ITurtleUpgrade.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);
- * }
- *}
+ * <h2>Example</h2>
+ * {@snippet class=com.example.examplemod.data.TurtleToolProvider region=body}
 */
 public final class TurtleToolBuilder {
    private final ResourceKey<ITurtleUpgrade> id;
--- 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
@@ -7,8 +7,11 @@ package dan200.computercraft.api.upgrades;
 import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import net.minecraft.core.Holder;
+import net.minecraft.core.component.DataComponentGetter;
 import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.core.component.DataComponentType;
 import net.minecraft.world.item.ItemStack;
+import org.jspecify.annotations.Nullable;

 /**
 * An upgrade (i.e. a {@link ITurtleUpgrade}) and its current upgrade data.
@@ -17,7 +20,9 @@ import net.minecraft.world.item.ItemStack;
 * @param data   The upgrade's data.
 * @param <T>    The type of upgrade, either {@link ITurtleUpgrade} or {@link IPocketUpgrade}.
 */
-public record UpgradeData<T extends UpgradeBase>(Holder.Reference<T> holder, DataComponentPatch data) {
+public record UpgradeData<T extends UpgradeBase>(
+    Holder.Reference<T> holder, DataComponentPatch data
+) implements DataComponentGetter {
    /**
     * A utility method to construct a new {@link UpgradeData} instance.
     *
@@ -66,4 +71,17 @@ public record UpgradeData<T extends UpgradeBase>(Holder.Reference<T> holder, Dat
    public ItemStack getUpgradeItem() {
        return upgrade().getUpgradeItem(data).copy();
    }
+
+    /**
+     * Get a component from the upgrade's {@link #data()} .
+     *
+     * @param component The component get.
+     * @param <U>       The type of the component's value.
+     * @return The component, or {@code null} if not present.
+     */
+    @Override
+    public <U> @Nullable U get(DataComponentType<? extends U> component) {
+        var result = data().get(component);
+        return result == null ? null : result.orElse(null);
+    }
 }
--- 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
@@ -7,9 +7,7 @@ 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;
@@ -23,13 +21,10 @@ import java.util.function.Function;
 * 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()}).
+ * While the {@link ITurtleUpgrade}/{@link IPocketUpgrade} class should contain the core logic of the upgrade, they are
+ * not registered directly. Instead, each upgrade class has 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.
@@ -38,35 +33,13 @@ import java.util.function.Function;
 * 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")));
- * }
- * }
+ * See <a href="../turtle/ITurtleUpgrade.html#datagen">the turtle upgrade docs</a> for a concrete example.
 *
 * @param <T> The upgrade subclass that this upgrade type represents.
 * @see ITurtleUpgrade
 * @see IPocketUpgrade
 */
-public interface UpgradeType<T extends UpgradeBase> {
+public sealed interface UpgradeType<T extends UpgradeBase> permits UpgradeTypeImpl {
    /**
     * The codec to read and write this upgrade from a datapack.
     *
--- a/projects/common-api/src/main/java/dan200/computercraft/impl/upgrades/UpgradeTypeImpl.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/impl/upgrades/UpgradeTypeImpl.java
@@ -2,12 +2,9 @@
 //
 // SPDX-License-Identifier: MPL-2.0

-package dan200.computercraft.impl.upgrades;
+package dan200.computercraft.api.upgrades;

 import com.mojang.serialization.MapCodec;
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeType;
-import org.jetbrains.annotations.ApiStatus;

 /**
 * Simple implementation of {@link UpgradeType}.
@@ -15,6 +12,5 @@ import org.jetbrains.annotations.ApiStatus;
 * @param codec The codec to read/write upgrades with.
 * @param <T>   The upgrade subclass that this upgrade type represents.
 */
-@ApiStatus.Internal
-public record UpgradeTypeImpl<T extends UpgradeBase>(MapCodec<T> codec) implements UpgradeType<T> {
+record UpgradeTypeImpl<T extends UpgradeBase>(MapCodec<T> codec) implements UpgradeType<T> {
 }
--- a/projects/common-api/src/main/java/dan200/computercraft/impl/ComputerCraftAPIService.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/impl/ComputerCraftAPIService.java
@@ -12,7 +12,7 @@ import dan200.computercraft.api.filesystem.Mount;
 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;
@@ -30,8 +30,7 @@ import net.minecraft.server.MinecraftServer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.ApiStatus;
-
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;

 /**
 * Backing interface for {@link ComputerCraftAPI}
@@ -60,8 +59,6 @@ public interface ComputerCraftAPIService {

    int getBundledRedstoneOutput(Level world, BlockPos pos, Direction side);

-    void registerMediaProvider(MediaProvider provider);
-
    PacketNetwork getWirelessNetwork(MinecraftServer server);

    void registerAPIFactory(ILuaAPIFactory factory);
@@ -84,6 +81,9 @@ public interface ComputerCraftAPIService {

    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/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/projects/common-api/src/main/java/dan200/computercraft/impl/Services.java
+++ b/projects/common-api/src/main/java/dan200/computercraft/impl/Services.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.util.ServiceLoader;
 import java.util.stream.Collectors;

--- a/projects/common-api/src/overview.html
+++ b/projects/common-api/src/overview.html
@@ -0,0 +1,128 @@
+<!--
+SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+
+SPDX-License-Identifier: MPL-2.0
+-->
+
+<!DOCTYPE HTML>
+<html lang="en">
+<body>
+<p>
+    This is the documentation for CC: Tweaked $modVersion for Minecraft $mcVersion. Documentation for other versions of
+    Minecraft are available on the CC: Tweaked website:
+
+<ul>
+    <li><a href="/mc-1.20.x/javadoc/">Minecraft 1.20.1</a>
+    <li><a href="/mc-1.21.x/javadoc/">Minecraft 1.21.1</a>
+</ul>
+
+<h1>Quick links</h1>
+<p>
+    You probably want to start in the following places:
+
+<ul>
+    <li>{@linkplain dan200.computercraft.api.peripheral Registering new peripherals}</li>
+    <li>
+        {@link dan200.computercraft.api.lua.LuaFunction} and {@link dan200.computercraft.api.lua.IArguments} for
+        adding methods to your peripheral or Lua objects.
+    </li>
+    <li>{@linkplain dan200.computercraft.api.turtle.ITurtleUpgrade Turtle upgrades}</li>
+    <li>{@linkplain dan200.computercraft.api.pocket.IPocketUpgrade Pocket upgrades}</li>
+</ul>
+
+<h1>Using</h1>
+<p>
+    CC: Tweaked is hosted on my maven repo, and so is relatively simple to depend on. You may wish to add a soft (or
+    hard) dependency in your <code>mods.toml</code> file, with the appropriate version bounds, to ensure that API
+    functionality you depend on is present.
+
+<pre class="language language-groovy"><code>repositories {
+    maven {
+        url "https://maven.squiddev.cc"
+        content { includeGroup("cc.tweaked") }
+    }
+}
+
+dependencies {
+    // Vanilla (i.e. for multi-loader systems)
+    compileOnly("cc.tweaked:cc-tweaked-$mcVersion-common-api:$modVersion")
+
+    // Forge Gradle
+    compileOnly("cc.tweaked:cc-tweaked-$mcVersion-core-api:$modVersion")
+    compileOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$modVersion"))
+    runtimeOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge:$modVersion"))
+
+    // Fabric Loom
+    modCompileOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric-api:$modVersion")
+    modRuntimeOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric:$modVersion")
+}
+</code></pre>
+
+<p>
+    You should also be careful to only use classes within the <code>dan200.computercraft.api</code> 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 <a href="https://github.com/cc-tweaked/CC-Tweaked/discussions/new/choose">start a discussion</a> to
+    let me know!
+
+
+<h1>Updating from Minecraft 1.20.1 to 1.21.1</h1>
+
+<h2>Peripherals</h2>
+<ul>
+    <li>
+        <p>
+            On NeoForge, the peripheral capability has migrated to NeoForge's new capability system.
+            <code>dan200.computercraft.api.peripheral.PeripheralCapability</code> can be used to register a peripheral.
+            <code>IPeripheralProvider</code> has also been removed, as capabilities can now be used for arbitrary
+            blocks.
+</ul>
+
+<p>
+    {@linkplain dan200.computercraft.api.peripheral Read more on registering peripherals}.
+
+<h2>Turtle and pocket upgrades</h2>
+Turtle and pocket upgrades have been migrated to use Minecraft's dynamic registries. While upgrades themselves have not
+changed much, the interface for registering them is dramatically different.
+
+<ul>
+    <li>
+        <p>
+            <code>TurtleUpgradeSerialiser</code> and <code>PocketUpgradeSerialiser</code> have been unified into a
+            single {@link dan200.computercraft.api.upgrades.UpgradeType} class
+        <ul>
+            <li>
+                Replace <code>TurtleUpgradeSerialiser.registryId()</code> with
+                {@link dan200.computercraft.api.turtle.ITurtleUpgrade#typeRegistry()} and <code>PocketUpgradeSerialiser.registryId()</code>
+                with {@link dan200.computercraft.api.pocket.IPocketUpgrade#typeRegistry()}.
+            <li>
+                Replace all other usages of <code>TurtleUpgradeSerialiser</code> and <code>PocketUpgradeSerialiser</code>
+                with {@link dan200.computercraft.api.upgrades.UpgradeType}.
+        </ul>
+
+    <li>
+        Upgrades are now (de)serialised using codecs, rather than manually reading from JSON and encoding/decoding
+        network packets. Instead of subclassing {@link dan200.computercraft.api.upgrades.UpgradeType}, it is recommended
+        you use {@link dan200.computercraft.api.upgrades.UpgradeType#create} to create a new type from a
+        <code>MapCodec</code>.
+
+    <li>
+        Upgrades are no longer aware of their ID, and so cannot compute their adjective. The adjective must now either
+        be hard-coded, or read as part of the codec.
+
+    <li>
+        The upgrade data providers have been removed, in favour of mod-loaders built-in support for dynamic registries.
+        I'm afraid it's probably easier if you delete your existing upgrade datagen code and start from scratch. See
+        <a href="./dan200/computercraft/api/turtle/ITurtleUpgrade.html#datagen">the <code>ITurtleUpgrade</code>
+        documentation for an example</a>.
+
+    <li>
+        Upgrades now store their additional data ({@link dan200.computercraft.api.turtle.ITurtleAccess#getUpgradeData},
+        {@link dan200.computercraft.api.pocket.IPocketAccess#getUpgradeData()}) as an immutable component map, rather
+        than a compound tag.
+</ul>
+
+<p>
+    {@linkplain dan200.computercraft.api.turtle.ITurtleUpgrade Read more on registering turtle upgrades}.
+
+</body>
+</html>
--- a/projects/common/build.gradle.kts
+++ b/projects/common/build.gradle.kts
@@ -6,17 +6,11 @@ import cc.tweaked.gradle.*

 plugins {
    id("cc-tweaked.vanilla")
-    id("cc-tweaked.gametest")
    id("cc-tweaked.illuaminate")
+    id("cc-tweaked.mod")
    id("cc-tweaked.publishing")
 }

-sourceSets {
-    main {
-        resources.srcDir("src/generated/resources")
-    }
-}
-
 minecraft {
    accessWideners(
        "src/main/resources/computercraft.accesswidener",
@@ -38,14 +32,13 @@ repositories {

 dependencies {
    // Pull in our other projects. See comments in MinecraftConfigurations on this nastiness.
-    implementation(project(":core"))
-    implementation(commonClasses(project(":common-api")))
-    clientImplementation(clientClasses(project(":common-api")))
+    api(project(":core"))
+    api(commonClasses(project(":common-api")))
+    clientApi(clientClasses(project(":common-api")))

    compileOnly(libs.mixin)
    compileOnly(libs.mixinExtra)
    compileOnly(libs.bundles.externalMods.common)
-    clientCompileOnly(variantOf(libs.emi) { classifier("api") })

    annotationProcessorEverywhere(libs.autoService)
    testFixturesAnnotationProcessor(libs.autoService)
@@ -68,7 +61,7 @@ dependencies {
 }

 illuaminate {
-    version.set(libs.versions.illuaminate)
+    version = libs.versions.illuaminate
 }

 val luaJavadoc by tasks.registering(Javadoc::class) {
@@ -89,11 +82,7 @@ val luaJavadoc by tasks.registering(Javadoc::class) {
    options.addStringOption("project-root", rootProject.file(".").absolutePath)
    options.noTimestamp(false)

-    javadocTool.set(
-        javaToolchains.javadocToolFor {
-            languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
-        },
-    )
+    javadocTool = javaToolchains.javadocToolFor { languageVersion = CCTweakedPlugin.JAVA_VERSION }
 }

 val lintLua by tasks.registering(IlluaminateExec::class) {
@@ -114,20 +103,31 @@ val lintLua by tasks.registering(IlluaminateExec::class) {
    doLast { if (System.getenv("GITHUB_ACTIONS") != null) println("::remove-matcher owner=illuaminate::") }
 }

-val runData by tasks.registering(MergeTrees::class) {
-    output = layout.projectDirectory.dir("src/generated/resources")
+fun MergeTrees.configureForDatagen(source: SourceSet, outputFolder: String) {
+    output = layout.projectDirectory.dir(outputFolder)

    for (loader in listOf("forge", "fabric")) {
-        mustRunAfter(":$loader:runData")
+        mustRunAfter(":$loader:$name")
        source {
            input {
-                from(project(":$loader").layout.buildDirectory.dir("generatedResources"))
+                from(project(":$loader").layout.buildDirectory.dir(source.getTaskName("generateResources", null)))
                exclude(".cache")
            }

-            output = project(":$loader").layout.projectDirectory.dir("src/generated/resources")
+            output = project(":$loader").layout.projectDirectory.dir(outputFolder)
        }
    }
 }

-tasks.withType(GenerateModuleMetadata::class).configureEach { isEnabled = false }
+val runData by tasks.registering(MergeTrees::class) {
+    configureForDatagen(sourceSets.main.get(), "src/generated/resources")
+}
+
+val runExampleData by tasks.registering(MergeTrees::class) {
+    configureForDatagen(sourceSets.examples.get(), "src/examples/generatedResources")
+}
+
+// We can't create accurate module metadata for our additional capabilities, so disable it.
+project.tasks.withType(GenerateModuleMetadata::class.java).configureEach {
+    isEnabled = false
+}
--- a/projects/common/src/client/java/dan200/computercraft/client/ClientHooks.java
+++ b/projects/common/src/client/java/dan200/computercraft/client/ClientHooks.java
@@ -6,12 +6,12 @@ package dan200.computercraft.client;

 import com.mojang.blaze3d.audio.Channel;
 import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.api.turtle.TurtleSide;
+import com.mojang.math.Axis;
 import dan200.computercraft.client.pocket.ClientPocketComputers;
 import dan200.computercraft.client.render.CableHighlightRenderer;
+import dan200.computercraft.client.render.ExtendedItemFrameRenderState;
 import dan200.computercraft.client.render.PocketItemRenderer;
 import dan200.computercraft.client.render.PrintoutItemRenderer;
-import dan200.computercraft.client.render.monitor.MonitorBlockEntityRenderer;
 import dan200.computercraft.client.render.monitor.MonitorHighlightRenderer;
 import dan200.computercraft.client.render.monitor.MonitorRenderState;
 import dan200.computercraft.client.sound.SpeakerManager;
@@ -21,27 +21,23 @@ import dan200.computercraft.shared.media.items.PrintoutItem;
 import dan200.computercraft.shared.peripheral.modem.wired.CableBlock;
 import dan200.computercraft.shared.peripheral.modem.wired.CableModemVariant;
 import dan200.computercraft.shared.peripheral.modem.wired.CableShapes;
-import dan200.computercraft.shared.peripheral.monitor.MonitorBlockEntity;
 import dan200.computercraft.shared.pocket.items.PocketComputerItem;
-import dan200.computercraft.shared.turtle.blocks.TurtleBlockEntity;
 import dan200.computercraft.shared.util.PauseAwareTimer;
 import dan200.computercraft.shared.util.WorldUtil;
 import net.minecraft.client.Camera;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.SubmitNodeCollector;
+import net.minecraft.client.renderer.entity.state.ItemFrameRenderState;
 import net.minecraft.client.sounds.AudioStream;
 import net.minecraft.client.sounds.SoundEngine;
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.InteractionHand;
-import net.minecraft.world.entity.decoration.ItemFrame;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;

-import javax.annotation.Nullable;
-import java.util.function.Consumer;
-
 /**
 * Event listeners for client-only code.
 * <p>
@@ -64,33 +60,38 @@ public final class ClientHooks {
    public static void onWorldUnload() {
        MonitorRenderState.destroyAll();
        SpeakerManager.reset();
+    }
+
+    public static void onDisconnect() {
        ClientPocketComputers.reset();
    }

    public static boolean drawHighlight(PoseStack transform, MultiBufferSource bufferSource, Camera camera, BlockHitResult hit) {
+        // TODO: Reconsider this API once https://github.com/FabricMC/fabric/pull/4906/ is merged.
        return CableHighlightRenderer.drawHighlight(transform, bufferSource, camera, hit)
            || MonitorHighlightRenderer.drawHighlight(transform, bufferSource, camera, hit);
    }

    public static boolean onRenderHeldItem(
-        PoseStack transform, MultiBufferSource render, int lightTexture, InteractionHand hand,
+        PoseStack transform, SubmitNodeCollector collector, int lightTexture, InteractionHand hand,
        float pitch, float equipProgress, float swingProgress, ItemStack stack
    ) {
        if (stack.getItem() instanceof PocketComputerItem) {
-            PocketItemRenderer.INSTANCE.renderItemFirstPerson(transform, render, lightTexture, hand, pitch, equipProgress, swingProgress, stack);
+            PocketItemRenderer.INSTANCE.renderItemFirstPerson(transform, collector, lightTexture, hand, pitch, equipProgress, swingProgress, stack);
            return true;
        }
        if (stack.getItem() instanceof PrintoutItem) {
-            PrintoutItemRenderer.INSTANCE.renderItemFirstPerson(transform, render, lightTexture, hand, pitch, equipProgress, swingProgress, stack);
+            PrintoutItemRenderer.INSTANCE.renderItemFirstPerson(transform, collector, lightTexture, hand, pitch, equipProgress, swingProgress, stack);
            return true;
        }

        return false;
    }

-    public static boolean onRenderItemFrame(PoseStack transform, MultiBufferSource render, ItemFrame frame, ItemStack stack, int light) {
-        if (stack.getItem() instanceof PrintoutItem) {
-            PrintoutItemRenderer.onRenderInFrame(transform, render, frame, stack, light);
+    public static boolean onRenderItemFrame(PoseStack transform, SubmitNodeCollector render, ItemFrameRenderState frame, ExtendedItemFrameRenderState state) {
+        if (state.printoutData != null) {
+            transform.mulPose(Axis.ZP.rotationDegrees(frame.rotation * 360.0f / 8.0f));
+            PrintoutItemRenderer.onRenderInFrame(transform, render, frame, state.printoutData, state.isBook);
            return true;
        }

@@ -101,62 +102,20 @@ public final class ClientHooks {
        SpeakerManager.onPlayStreaming(engine, channel, stream);
    }

-    /**
-     * Add additional information about the currently targeted block to the debug screen.
-     *
-     * @param addText A callback which adds a single line of text.
-     */
-    public static void addBlockDebugInfo(Consumer<String> addText) {
-        var minecraft = Minecraft.getInstance();
-        if (!minecraft.getDebugOverlay().showDebugScreen() || minecraft.level == null) return;
-        if (minecraft.hitResult == null || minecraft.hitResult.getType() != HitResult.Type.BLOCK) return;
-
-        var tile = minecraft.level.getBlockEntity(((BlockHitResult) minecraft.hitResult).getBlockPos());
-
-        if (tile instanceof MonitorBlockEntity monitor) {
-            addText.accept("");
-            addText.accept(
-                String.format("Targeted monitor: (%d, %d), %d x %d", monitor.getXIndex(), monitor.getYIndex(), monitor.getWidth(), monitor.getHeight())
-            );
-        } else if (tile instanceof TurtleBlockEntity turtle) {
-            addText.accept("");
-            addText.accept("Targeted turtle:");
-            addText.accept(String.format("Id: %d", turtle.getComputerID()));
-            addTurtleUpgrade(addText, turtle, TurtleSide.LEFT);
-            addTurtleUpgrade(addText, turtle, TurtleSide.RIGHT);
-        }
-    }
-
-    private static void addTurtleUpgrade(Consumer<String> out, TurtleBlockEntity turtle, TurtleSide side) {
-        var upgrade = turtle.getAccess().getUpgradeWithData(side);
-        if (upgrade != null) out.accept(String.format("Upgrade[%s]: %s", side, upgrade.holder().key().location()));
-    }
-
-    /**
-     * Add additional information about the game to the debug screen.
-     *
-     * @param addText A callback which adds a single line of text.
-     */
-    public static void addGameDebugInfo(Consumer<String> addText) {
-        if (MonitorBlockEntityRenderer.hasRenderedThisFrame() && Minecraft.getInstance().getDebugOverlay().showDebugScreen()) {
-            addText.accept("[CC:T] Monitor renderer: " + MonitorBlockEntityRenderer.currentRenderer());
-        }
-    }
-
-    public static @Nullable BlockState getBlockBreakingState(BlockState state, BlockPos pos) {
+    public static BlockState getBlockBreakingState(BlockState state, BlockPos pos) {
        // Only apply to cables which have both a cable and modem
        if (state.getBlock() != ModRegistry.Blocks.CABLE.get()
            || !state.getValue(CableBlock.CABLE)
            || state.getValue(CableBlock.MODEM) == CableModemVariant.None
        ) {
-            return null;
+            return state;
        }

        var hit = Minecraft.getInstance().hitResult;
-        if (hit == null || hit.getType() != HitResult.Type.BLOCK) return null;
+        if (hit == null || hit.getType() != HitResult.Type.BLOCK) return state;
        var hitPos = ((BlockHitResult) hit).getBlockPos();

-        if (!hitPos.equals(pos)) return null;
+        if (!hitPos.equals(pos)) return state;

        return WorldUtil.isVecInside(CableShapes.getModemShape(state), hit.getLocation().subtract(pos.getX(), pos.getY(), pos.getZ()))
            ? state.getBlock().defaultBlockState().setValue(CableBlock.MODEM, state.getValue(CableBlock.MODEM))
--- a/projects/common/src/client/java/dan200/computercraft/client/ClientRegistry.java
+++ b/projects/common/src/client/java/dan200/computercraft/client/ClientRegistry.java
@@ -4,59 +4,59 @@

 package dan200.computercraft.client;

-import com.mojang.brigadier.CommandDispatcher;
-import com.mojang.brigadier.arguments.IntegerArgumentType;
-import com.mojang.brigadier.builder.LiteralArgumentBuilder;
-import com.mojang.brigadier.builder.RequiredArgumentBuilder;
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.client.turtle.RegisterTurtleUpgradeModeller;
-import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
+import com.mojang.serialization.MapCodec;
+import dan200.computercraft.api.client.StandaloneModel;
+import dan200.computercraft.api.client.turtle.*;
 import dan200.computercraft.client.gui.*;
-import dan200.computercraft.client.pocket.ClientPocketComputers;
-import dan200.computercraft.client.render.RenderTypes;
+import dan200.computercraft.client.item.colour.PocketComputerLight;
+import dan200.computercraft.client.item.model.TurtleOverlayModel;
+import dan200.computercraft.client.item.properties.PocketComputerStateProperty;
+import dan200.computercraft.client.item.properties.TurtleShowElfOverlay;
+import dan200.computercraft.client.model.LecternBookModel;
+import dan200.computercraft.client.model.LecternPocketModel;
+import dan200.computercraft.client.model.LecternPrintoutModel;
+import dan200.computercraft.client.platform.ClientPlatformHelper;
+import dan200.computercraft.client.platform.ModelKey;
+import dan200.computercraft.client.render.CustomLecternRenderer;
 import dan200.computercraft.client.render.TurtleBlockEntityRenderer;
 import dan200.computercraft.client.render.monitor.MonitorBlockEntityRenderer;
-import dan200.computercraft.client.turtle.TurtleModemModeller;
-import dan200.computercraft.client.turtle.TurtleUpgradeModellers;
-import dan200.computercraft.core.util.Colour;
+import dan200.computercraft.client.turtle.TurtleOverlay;
+import dan200.computercraft.client.turtle.TurtleOverlayManager;
+import dan200.computercraft.client.turtle.TurtleUpgradeModelManager;
 import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.command.CommandComputerCraft;
-import dan200.computercraft.shared.computer.core.ComputerState;
-import dan200.computercraft.shared.computer.core.ServerContext;
 import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
-import dan200.computercraft.shared.media.items.DiskItem;
-import dan200.computercraft.shared.turtle.TurtleOverlay;
-import net.minecraft.Util;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.color.item.ItemColor;
+import net.minecraft.client.color.item.ItemTintSource;
+import net.minecraft.client.gui.components.debug.DebugScreenEntry;
+import net.minecraft.client.gui.render.pip.PictureInPictureRenderer;
+import net.minecraft.client.gui.render.state.pip.PictureInPictureRenderState;
 import net.minecraft.client.gui.screens.MenuScreens;
 import net.minecraft.client.gui.screens.Screen;
 import net.minecraft.client.gui.screens.inventory.MenuAccess;
-import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.client.renderer.ShaderInstance;
+import net.minecraft.client.model.geom.ModelLayerLocation;
+import net.minecraft.client.model.geom.builders.LayerDefinition;
+import net.minecraft.client.renderer.MultiBufferSource;
 import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderers;
-import net.minecraft.client.renderer.item.ClampedItemPropertyFunction;
-import net.minecraft.client.renderer.item.ItemProperties;
-import net.minecraft.network.chat.Component;
+import net.minecraft.client.renderer.item.ItemModel;
+import net.minecraft.client.renderer.item.properties.conditional.ConditionalItemModelProperty;
+import net.minecraft.client.renderer.item.properties.select.SelectItemModelProperty;
+import net.minecraft.client.resources.model.MissingBlockModel;
+import net.minecraft.client.resources.model.ModelBaker;
+import net.minecraft.client.resources.model.ModelManager;
+import net.minecraft.client.resources.model.ResolvableModel;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.resources.PreparableReloadListener;
-import net.minecraft.server.packs.resources.ResourceProvider;
-import net.minecraft.util.FastColor;
-import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.server.packs.resources.ResourceManager;
 import net.minecraft.world.inventory.AbstractContainerMenu;
 import net.minecraft.world.inventory.MenuType;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.component.DyedItemColor;
-import net.minecraft.world.level.ItemLike;

-import javax.annotation.Nullable;
-import java.io.File;
-import java.io.IOException;
-import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
 import java.util.function.BiConsumer;
-import java.util.function.Consumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 import java.util.function.Supplier;

 /**
@@ -71,6 +71,19 @@ public final class ClientRegistry {
    private ClientRegistry() {
    }

+    private static final Map<ResourceLocation, ModelKey<StandaloneModel>> models = new ConcurrentHashMap<>();
+
+    public static ModelKey<StandaloneModel> getModel(ResourceLocation model) {
+        return models.computeIfAbsent(model, m -> ClientPlatformHelper.get().createModelKey(m::toString));
+    }
+
+    public static StandaloneModel getModel(ModelManager manager, ResourceLocation modelId) {
+        var model = getModel(modelId).get(manager);
+        if (model != null) return model;
+
+        return Objects.requireNonNull(getModel(MissingBlockModel.LOCATION).get(manager));
+    }
+
    /**
     * Register any client-side objects which don't have to be done on the main thread.
     */
@@ -79,25 +92,7 @@ public final class ClientRegistry {
        BlockEntityRenderers.register(ModRegistry.BlockEntities.MONITOR_ADVANCED.get(), MonitorBlockEntityRenderer::new);
        BlockEntityRenderers.register(ModRegistry.BlockEntities.TURTLE_NORMAL.get(), TurtleBlockEntityRenderer::new);
        BlockEntityRenderers.register(ModRegistry.BlockEntities.TURTLE_ADVANCED.get(), TurtleBlockEntityRenderer::new);
-    }
-
-    /**
-     * Register any client-side objects which must be done on the main thread.
-     *
-     * @param itemProperties Callback to register item properties.
-     */
-    public static void registerMainThread(RegisterItemProperty itemProperties) {
-        registerItemProperty(itemProperties, "state",
-            new UnclampedPropertyFunction((stack, world, player, random) -> {
-                var computer = ClientPocketComputers.get(stack);
-                return (computer == null ? ComputerState.OFF : computer.getState()).ordinal();
-            }),
-            ModRegistry.Items.POCKET_COMPUTER_NORMAL, ModRegistry.Items.POCKET_COMPUTER_ADVANCED
-        );
-        registerItemProperty(itemProperties, "coloured",
-            (stack, world, player, random) -> DyedItemColor.getOrDefault(stack, -1) != -1 ? 1 : 0,
-            ModRegistry.Items.POCKET_COMPUTER_NORMAL, ModRegistry.Items.POCKET_COMPUTER_ADVANCED
-        );
+        BlockEntityRenderers.register(ModRegistry.BlockEntities.LECTERN.get(), CustomLecternRenderer::new);
    }

    public static void registerMenuScreens(RegisterMenuScreen register) {
@@ -114,138 +109,112 @@ public final class ClientRegistry {
        <M extends AbstractContainerMenu, U extends Screen & MenuAccess<M>> void register(MenuType<? extends M> type, MenuScreens.ScreenConstructor<M, U> factory);
    }

-    public static void registerTurtleModellers(RegisterTurtleUpgradeModeller register) {
-        register.register(ModRegistry.TurtleUpgradeTypes.SPEAKER.get(), TurtleUpgradeModeller.sided(
-            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "block/turtle_speaker_left"),
-            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "block/turtle_speaker_right")
-        ));
-        register.register(ModRegistry.TurtleUpgradeTypes.WORKBENCH.get(), TurtleUpgradeModeller.sided(
-            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "block/turtle_crafting_table_left"),
-            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "block/turtle_crafting_table_right")
-        ));
-        register.register(ModRegistry.TurtleUpgradeTypes.WIRELESS_MODEM.get(), new TurtleModemModeller());
-        register.register(ModRegistry.TurtleUpgradeTypes.TOOL.get(), TurtleUpgradeModeller.flatItem());
-    }
-
-    @SafeVarargs
-    private static void registerItemProperty(RegisterItemProperty itemProperties, String name, ClampedItemPropertyFunction getter, Supplier<? extends Item>... items) {
-        var id = ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, name);
-        for (var item : items) itemProperties.register(item.get(), id, getter);
-    }
-
-    /**
-     * Register an item property via {@link ItemProperties#register}. Forge and Fabric expose different methods, so we
-     * supply this via mod-loader-specific code.
-     */
-    public interface RegisterItemProperty {
-        void register(Item item, ResourceLocation name, ClampedItemPropertyFunction property);
-    }
-
-    public static void registerReloadListeners(Consumer<PreparableReloadListener> register, Minecraft minecraft) {
-        register.accept(GuiSprites.initialise(minecraft.getTextureManager()));
+    public static void registerTurtleModels(RegisterTurtleUpgradeModel register) {
+        register.register(BasicUpgradeModel.ID, BasicUpgradeModel.CODEC);
+        register.register(ItemUpgradeModel.ID, ItemUpgradeModel.CODEC);
+        register.register(SelectUpgradeModel.ID, SelectUpgradeModel.CODEC);
    }

    private static final ResourceLocation[] EXTRA_MODELS = {
        TurtleOverlay.ELF_MODEL,
+        TurtleBlockEntityRenderer.NORMAL_TURTLE_MODEL,
+        TurtleBlockEntityRenderer.ADVANCED_TURTLE_MODEL,
        TurtleBlockEntityRenderer.COLOUR_TURTLE_MODEL,
+        MissingBlockModel.LOCATION,
    };

-    public static void registerExtraModels(Consumer<ResourceLocation> register, Collection<ResourceLocation> extraModels) {
-        for (var model : EXTRA_MODELS) register.accept(model);
-        extraModels.forEach(register);
-        TurtleUpgradeModellers.getDependencies().forEach(register);
-    }
-
-    public static void registerItemColours(BiConsumer<ItemColor, ItemLike> register) {
-        register.accept(
-            (stack, layer) -> layer == 1 ? DiskItem.getColour(stack) : -1,
-            ModRegistry.Items.DISK.get()
-        );
-
-        register.accept(
-            (stack, layer) -> layer == 1 ? DyedItemColor.getOrDefault(stack, Colour.BLUE.getARGB()) : -1,
-            ModRegistry.Items.TREASURE_DISK.get()
-        );
-
-        register.accept(ClientRegistry::getPocketColour, ModRegistry.Items.POCKET_COMPUTER_NORMAL.get());
-        register.accept(ClientRegistry::getPocketColour, ModRegistry.Items.POCKET_COMPUTER_ADVANCED.get());
-
-        register.accept(ClientRegistry::getTurtleColour, ModRegistry.Blocks.TURTLE_NORMAL.get());
-        register.accept(ClientRegistry::getTurtleColour, ModRegistry.Blocks.TURTLE_ADVANCED.get());
-    }
-
-    private static int getPocketColour(ItemStack stack, int layer) {
-        return switch (layer) {
-            default -> -1;
-            case 1 -> DyedItemColor.getOrDefault(stack, -1); // Frame colour
-            case 2 -> { // Light colour
-                var computer = ClientPocketComputers.get(stack);
-                yield computer == null || computer.getLightState() == -1 ? Colour.BLACK.getARGB() : FastColor.ARGB32.opaque(computer.getLightState());
-            }
-        };
-    }
-
-    private static int getTurtleColour(ItemStack stack, int layer) {
-        return layer == 0 ? DyedItemColor.getOrDefault(stack, -1) : -1;
-    }
-
-    public static void registerShaders(ResourceProvider resources, BiConsumer<ShaderInstance, Consumer<ShaderInstance>> load) throws IOException {
-        RenderTypes.registerShaders(resources, load);
-    }
-
-    private record UnclampedPropertyFunction(
-        ClampedItemPropertyFunction function
-    ) implements ClampedItemPropertyFunction {
-        @Override
-        public float unclampedCall(ItemStack stack, @Nullable ClientLevel level, @Nullable LivingEntity entity, int layer) {
-            return function.unclampedCall(stack, level, entity, layer);
-        }
-
-        @Deprecated
-        @Override
-        public float call(ItemStack stack, @Nullable ClientLevel level, @Nullable LivingEntity entity, int layer) {
-            return function.unclampedCall(stack, level, entity, layer);
-        }
+    /**
+     * Additional models to load.
+     *
+     * @param turtleOverlays The unbaked turtle models.
+     * @param turtleUpgrades The unbaked turtle upgrades.
+     * @see #gatherExtraModels(ResourceManager, Executor)
+     * @see #registerExtraModels(RegisterExtraModels, ExtraModels)
+     */
+    public record ExtraModels(
+        Map<ResourceLocation, TurtleOverlay.Unbaked> turtleOverlays,
+        Map<ResourceLocation, TurtleUpgradeModel.Unbaked> turtleUpgrades
+    ) {
    }

    /**
-     * Register client-side commands.
+     * Gather the list of extra models to load.
     *
-     * @param dispatcher The dispatcher to register the commands to.
-     * @param sendError  A function to send an error message.
-     * @param <T>        The type of the client-side command context.
+     * @param resources The current resource manager.
+     * @param executor  The executor to schedule loading on.
+     * @return A promise which contains our extra models.
     */
-    public static <T> void registerClientCommands(CommandDispatcher<T> dispatcher, BiConsumer<T, Component> sendError) {
-        dispatcher.register(LiteralArgumentBuilder.<T>literal(CommandComputerCraft.CLIENT_OPEN_FOLDER)
-            .requires(x -> Minecraft.getInstance().getSingleplayerServer() != null)
-            .then(RequiredArgumentBuilder.<T, Integer>argument("computer_id", IntegerArgumentType.integer(0))
-                .executes(c -> handleOpenComputerCommand(c.getSource(), sendError, c.getArgument("computer_id", Integer.class)))
-            ));
+    public static CompletableFuture<ExtraModels> gatherExtraModels(ResourceManager resources, Executor executor) {
+        var turtleOverlays = TurtleOverlayManager.loader().load(resources, executor);
+        var turtleUpgrades = TurtleUpgradeModelManager.loader().load(resources, executor);
+        return turtleOverlays.thenCombine(turtleUpgrades, ExtraModels::new);
    }

    /**
-     * Handle the {@link CommandComputerCraft#CLIENT_OPEN_FOLDER} command.
-     *
-     * @param context   The command context.
-     * @param sendError A function to send an error message.
-     * @param id        The computer's id.
-     * @param <T>       The type of the client-side command context.
-     * @return {@code 1} if a folder was opened, {@code 0} otherwise.
+     * A callback used to register a model for a {@link ModelKey}.
     */
-    private static <T> int handleOpenComputerCommand(T context, BiConsumer<T, Component> sendError, int id) {
-        var server = Minecraft.getInstance().getSingleplayerServer();
-        if (server == null) {
-            sendError.accept(context, Component.literal("Not on a single-player server"));
-            return 0;
+    public interface RegisterExtraModels {
+        default <U extends ResolvableModel, T> void register(ModelKey<T> key, U unbaked, BiFunction<U, ModelBaker, T> bake) {
+            register(key, unbaked, ResolvableModel::resolveDependencies, bake);
        }

-        var file = new File(ServerContext.get(server).storageDir().toFile(), "computer/" + id);
-        if (!file.isDirectory()) {
-            sendError.accept(context, Component.literal("Computer's folder does not exist"));
-            return 0;
-        }
+        /**
+         * Register an extra model.
+         * <p>
+         * This accepts functions to resolve dependencies and bake the model. While this would be conceptually nicer as
+         * an interface, it would require multiple adaptors to convert between "upgrade model", "a"bstract model" and
+         * "platform-specific model", so working with functions is cleaner.
+         *
+         * @param key     The model key for this model.
+         * @param unbaked The unbaked model.
+         * @param resolve The function to resolve dependencies for this model.
+         * @param bake    The function to bake this model.
+         * @param <U>     The type of unbaked model.
+         * @param <T>     The type of baked model.
+         */
+        <U, T> void register(ModelKey<T> key, U unbaked, BiConsumer<U, ResolvableModel.Resolver> resolve, BiFunction<U, ModelBaker, T> bake);
+    }

-        Util.getPlatform().openFile(file);
-        return 1;
+    public static void registerExtraModels(RegisterExtraModels register, ExtraModels models) {
+        for (var model : EXTRA_MODELS) {
+            register.register(getModel(model), model, (id, r) -> r.markDependency(id), StandaloneModel::of);
+        }
+        TurtleOverlayManager.loader().register(register, models.turtleOverlays());
+        TurtleUpgradeModelManager.loader().register(register, models.turtleUpgrades());
+    }
+
+    public static void registerItemModels(BiConsumer<ResourceLocation, MapCodec<? extends ItemModel.Unbaked>> register) {
+        register.accept(TurtleOverlayModel.ID, TurtleOverlayModel.CODEC);
+        register.accept(dan200.computercraft.client.item.model.TurtleUpgradeModel.ID, dan200.computercraft.client.item.model.TurtleUpgradeModel.CODEC);
+    }
+
+    public static void registerItemColours(BiConsumer<ResourceLocation, MapCodec<? extends ItemTintSource>> register) {
+        register.accept(PocketComputerLight.ID, PocketComputerLight.CODEC);
+    }
+
+    public static void registerSelectItemProperties(BiConsumer<ResourceLocation, SelectItemModelProperty.Type<?, ?>> register) {
+        register.accept(PocketComputerStateProperty.ID, PocketComputerStateProperty.TYPE);
+    }
+
+    public static void registerConditionalItemProperties(BiConsumer<ResourceLocation, MapCodec<? extends ConditionalItemModelProperty>> register) {
+        register.accept(TurtleShowElfOverlay.ID, TurtleShowElfOverlay.CODEC);
+    }
+
+    public static void registerLayerDefinitions(BiConsumer<ModelLayerLocation, Supplier<LayerDefinition>> register) {
+        register.accept(LecternBookModel.LAYER, LecternBookModel::createLayer);
+        register.accept(LecternPrintoutModel.LAYER, LecternPrintoutModel::createLayer);
+        register.accept(LecternPocketModel.LAYER, LecternPocketModel::createLayer);
+    }
+
+    public interface RegisterPictureInPictureRenderer {
+        <T extends PictureInPictureRenderState> void register(Class<T> state, Function<MultiBufferSource.BufferSource, PictureInPictureRenderer<T>> factory);
+    }
+
+    public static void registerPictureInPictureRenderers(RegisterPictureInPictureRenderer register) {
+        register.register(PrintoutScreen.PrintoutRenderState.class, PrintoutScreen.PrintoutPictureRenderer::new);
+    }
+
+    public static void registerDebugScreenEntries(BiConsumer<ResourceLocation, DebugScreenEntry> register) {
+        register.accept(LookingAtBlockEntityDebugEntry.ID, LookingAtBlockEntityDebugEntry.create());
    }
 }
--- a/projects/common/src/client/java/dan200/computercraft/client/ClientTableFormatter.java
+++ b/projects/common/src/client/java/dan200/computercraft/client/ClientTableFormatter.java
@@ -15,8 +15,8 @@ import net.minecraft.client.gui.components.ChatComponent;
 import net.minecraft.network.chat.Component;
 import net.minecraft.util.Mth;
 import org.apache.commons.lang3.StringUtils;
+import org.jspecify.annotations.Nullable;

-import javax.annotation.Nullable;
 import java.util.Objects;

 /**
--- a/projects/common/src/client/java/dan200/computercraft/client/CustomModelManager.java
+++ b/projects/common/src/client/java/dan200/computercraft/client/CustomModelManager.java
@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: 2025 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.client;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.JsonOps;
+import dan200.computercraft.client.platform.ClientPlatformHelper;
+import dan200.computercraft.client.platform.ModelKey;
+import dan200.computercraft.shared.util.ResourceUtils;
+import net.minecraft.client.resources.model.ModelBaker;
+import net.minecraft.client.resources.model.ModelManager;
+import net.minecraft.client.resources.model.ResolvableModel;
+import net.minecraft.resources.FileToIdConverter;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.packs.resources.ResourceManager;
+
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.function.BiFunction;
+
+/**
+ * A manager for loading custom models. This is responsible for {@linkplain #load(ResourceManager, Executor) loading
+ * models from resource packs}, {@linkplain #register(ClientRegistry.RegisterExtraModels, Map) registering them as
+ * extra models}, and then {@linkplain #get(ModelManager, ResourceLocation) looking them up}.
+ *
+ * @param <U> The type of unbaked model.
+ * @param <T> The type of baked model.
+ */
+public class CustomModelManager<U extends ResolvableModel, T> {
+    private final String kind;
+    private final FileToIdConverter lister;
+    private final Codec<U> codec;
+    private final BiFunction<U, ModelBaker, T> bake;
+
+    private final ModelKey<T> missingModelKey;
+    private final U missingModel;
+
+    private final Map<ResourceLocation, ModelKey<T>> modelKeys = new ConcurrentHashMap<>();
+
+    public CustomModelManager(String kind, FileToIdConverter lister, Codec<U> codec, BiFunction<U, ModelBaker, T> bake, U missingModel) {
+        this.kind = kind;
+        this.lister = lister;
+        this.codec = codec;
+        this.bake = bake;
+
+        this.missingModelKey = ClientPlatformHelper.get().createModelKey(() -> "Missing " + kind);
+        this.missingModel = missingModel;
+    }
+
+    private ModelKey<T> getModelKey(ResourceLocation id) {
+        return modelKeys.computeIfAbsent(id, o -> ClientPlatformHelper.get().createModelKey(() -> kind + " " + o));
+    }
+
+    /**
+     * Load our models from resources.
+     *
+     * @param resources The current resource manager.
+     * @param executor  The executor to schedule work on.
+     * @return The map of unbaked models.
+     */
+    public CompletableFuture<Map<ResourceLocation, U>> load(ResourceManager resources, Executor executor) {
+        return ResourceUtils.load(resources, executor, kind, lister, JsonOps.INSTANCE, codec);
+    }
+
+    /**
+     * Register our unbaked models.
+     *
+     * @param register The callback to register models with.
+     * @param models   The models to register.
+     */
+    public void register(ClientRegistry.RegisterExtraModels register, Map<ResourceLocation, U> models) {
+        models.forEach((id, model) -> register.register(getModelKey(id), model, bake));
+        register.register(missingModelKey, missingModel, bake);
+    }
+
+    /**
+     * Find the model with the given id. If the model does not exist, then the missing model is returned instead.
+     *
+     * @param modelManager The model manager.
+     * @param id           The model id.
+     * @return The loaded model.
+     */
+    public T get(ModelManager modelManager, ResourceLocation id) {
+        var model = getModelKey(id).get(modelManager);
+        if (model != null) return model;
+
+        var missing = missingModelKey.get(modelManager);
+        if (missing == null) throw new IllegalStateException("Models have not yet been loaded.");
+        return missing;
+    }
+}
--- a/Show More
+++ b/Show More