Merge branch 'mc-1.18.x' into mc-1.19.x

One more version and then it's a palendrome! Sort of.

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -9,8 +9,8 @@ body:
     description: What version of Minecraft are you using?
     options:
       - 1.16.x
-      - 1.17.x
       - 1.18.x
+      - 1.19.x
   validations:
     required: true
 - type: input

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,5 @@
 blank_issues_enabled: false
 contact_links:
-- name: ComputerCraft Discord
-  url: https://discord.computercraft.cc
-  about: Get help on the ComputerCraft Discord.
 - name: GitHub Discussions
   url: https://github.com/cc-tweaked/CC-Tweaked/discussions
-  about: Or ask questions on GitHub Discussions.
+  about: Ask questions on GitHub Discussions.

.github/workflows/main-ci.yml

@@ -15,7 +15,7 @@ jobs:
       with:
         java-version: 8
 
-    - name: Cache gradle dependencies
+    - name: Cache Gradle dependencies
       uses: actions/cache@v2
       with:
         path: ~/.gradle/caches
@@ -32,7 +32,7 @@ jobs:
       run: |
         ./gradlew assemble || ./gradlew assemble
         ./gradlew downloadAssets || ./gradlew downloadAssets
-        xvfb-run ./gradlew build
+        ./gradlew build
 
     - name: Upload Jar
       uses: actions/upload-artifact@v2
@@ -40,31 +40,12 @@ jobs:
         name: CC-Tweaked
         path: build/libs
 
-    - name: Upload Screnshots
-      uses: actions/upload-artifact@v2
-      with:
-        name: Screenshots
-        path: test-files/client/screenshots
-        if-no-files-found: ignore
-        retention-days: 5
-      if: failure()
-
-    - name: Upload Coverage
+    - name: Upload coverage
       uses: codecov/codecov-action@v2
 
     - name: Parse test reports
       run: ./tools/parse-reports.py
       if: ${{ failure() }}
 
-    - name: Cache pre-commit
-      uses: actions/cache@v2
-      with:
-        path: ~/.cache/pre-commit
-        key: ${{ runner.os }}-pre-commit-${{ hashFiles('config/pre-commit/config.yml') }}
-        restore-keys: |
-          ${{ runner.os }}-pre-commit-
-
     - name: Run linters
-      run: |
-        pip install pre-commit
-        pre-commit run --config config/pre-commit/config.yml --show-diff-on-failure --all --color=always
+      uses: pre-commit/action@v3.0.0

.github/workflows/make-doc.yml

@@ -26,12 +26,6 @@ jobs:
         restore-keys: |
           ${{ runner.os }}-gradle-
 
-    - name: Setup illuaminate
-      run: |
-        test -d bin || mkdir bin
-        test -f bin/illuaminate || wget -q -Obin/illuaminate https://squiddev.cc/illuaminate/linux-x86-64/illuaminate
-        chmod +x bin/illuaminate
-
     - name: Setup node
       run: npm ci
 

.gitignore

@@ -2,6 +2,7 @@
 /classes
 /logs
 /build
+/buildSrc/build
 /out
 /doc/out/
 /node_modules

.gitpod.yml

@@ -17,6 +17,6 @@ vscode:
 
 tasks:
   - name: Setup pre-commit hool
-    init: pre-commit install --config config/pre-commit/config.yml --allow-missing-config
+    init: pre-commit install --allow-missing-config
   - name: Install npm packages
     init: npm ci

.pre-commit-config.yaml

@@ -41,8 +41,8 @@ repos:
   - id: illuaminate
     name: Check Lua code
     files: ".*\\.(lua|java|md)"
-    language: script
-    entry: config/pre-commit/illuaminate-lint.sh
+    language: system
+    entry: ./gradlew lintLua -i
     pass_filenames: false
     require_serial: true
 

CODE_OF_CONDUCT.md

@@ -0,0 +1,133 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+"conduct AT squiddev DOT cc". All complaints will be reviewed and investigated
+promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

CONTRIBUTING.md

@@ -39,40 +39,30 @@ are run whenever you submit a PR, it's often useful to run this before committin
 
  - **[Checkstyle]:** Checks Java code to ensure it is consistently formatted. This can be run with `./gradlew build` or
    `./gradle check`.
- - **[illuaminate]:** Checks Lua code for semantic and styleistic issues. See [the usage section][illuaminate-usage] for
-   how to download and run it. You may need to generate the Java documentation stubs (see "Documentation" below) for all
-   lints to pass.
+ - **[illuaminate]:** Checks Lua code for semantic and styleistic issues. This can be run with `./gradlew lintLua`.
 
 ### Documentation
 When writing documentation for [CC: Tweaked's documentation website][docs], it may be useful to build the documentation
 and preview it yourself before submitting a PR.
 
-Building all documentation is, sadly, a multi-stage process (though this is largely hidden by Gradle). First we need to
-convert Java doc-comments into Lua ones, we also generate some Javascript to embed. All of this is then finally fed into
-illuaminate, which spits out our HTML.
+Our documentation generation pipeline is rather complex, and involves invoking several external tools. Most of this
+complexity is hidden by Gradle, but you will need to perform some initial setup:
 
-#### Setting up the tooling
-For various reasons, getting the environment set up to build documentation can be pretty complex. I'd quite like to
-automate this via Docker and/or nix in the future, but this needs to be done manually for now.
+ - Install [Node/npm][node].
+ - Run `npm ci` to install our Node dependencies.
 
-This tooling is only needed if you need to build the whole website. If you just want to generate the Lua stubs, you can
-skp this section.
- - Install Node/npm and install our Node packages with `npm ci`.
- - Install [illuaminate][illuaminate-usage] as described above.
-
-#### Building documentation
-Gradle should be your entrypoint to building most documentation. There's two tasks which are of interest:
-
- - `./gradlew luaJavadoc` - Generate documentation stubs for Java methods.
- - `./gradlew docWebsite` - Generate the whole website (including Javascript pages). The resulting HTML is stored at
-   `./build/docs/site/`.
+You can now run `./gradlew docWebsite`. This generates documentation from our Lua and Java code, writing the resulting
+HTML into `./build/docs/site`.
 
 #### Writing documentation
 illuaminate's documentation system is not currently documented (somewhat ironic), but is _largely_ the same as
 [ldoc][ldoc]. Documentation comments are written in Markdown,
 
 Our markdown engine does _not_ support GitHub flavoured markdown, and so does not support all the features one might
-expect (such as tables). It is very much recommended that you build and preview the docs locally first.
+expect. It is recommended that you build and preview the docs locally first.
+
+When iterating on documentation, you can get Gradle to rebuild the website every time a file changes by running
+`./gradlew docWebsite -t`. This will take a couple of seconds to run, but definitely beats running it manually!
 
 ### Testing
 Thankfully running tests is much simpler than running the documentation generator! `./gradlew check` will run the
@@ -90,11 +80,10 @@ Before we get into writing tests, it's worth mentioning the various test suites
 
    These tests are run by the '"Core" Java' test suite, and so are also run with `./gradlew test`.
 
- - In-game (`./src/testMod/java/dan200/computercraft/ingame/`): These tests are run on an actual Minecraft server and client,
-   using [the same system Mojang do][mc-test]. The aim of these is to test in-game behaviour of blocks and peripherals.
+ - In-game (`./src/testMod/java/dan200/computercraft/ingame/`): These tests are run on an actual Minecraft server, using
+   the same system Mojang do][mc-test]. The aim of these is to test in-game behaviour of blocks and peripherals.
 
-   These are run by `./gradlew testClient` and `./gradlew testServer`. You may want to run the client under `xvfb-run`
-   or similar when running in a headless environment.
+   These tests are run with `./gradlew testServer`.
 
 ## CraftOS tests
 CraftOS's tests are written using a test system called "mcfly", heavily inspired by [busted] (and thus RSpec). Groups of
@@ -107,9 +96,9 @@ asserts that your variable `foo` is equal to the expected value `"bar"`.
 [community]: README.md#Community "Get in touch with the community."
 [checkstyle]: https://checkstyle.org/
 [illuaminate]: https://github.com/SquidDev/illuaminate/ "Illuaminate on GitHub"
-[illuaminate-usage]: https://github.com/SquidDev/illuaminate/blob/master/README.md#usage "Installing Illuaminate"
 [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"

README.md

@@ -13,9 +13,8 @@ developing the mod, [check out the instructions here](CONTRIBUTING.md#developing
 
 ## Community
 If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
-ComputerCraft we have a [forum](https://forums.computercraft.cc/) and [Discord guild](https://discord.computercraft.cc)!
-There's also a fairly populated, albeit quiet [IRC channel](http://webchat.esper.net/?channels=computercraft), if that's
-more your cup of tea.
+ComputerCraft, do check out our [forum] and [GitHub discussions page][GitHub discussions]! There's also a fairly
+populated, albeit quiet [IRC channel][irc], if that's more your cup of tea.
 
 We also host fairly comprehensive documentation at [tweaked.cc](https://tweaked.cc/ "The CC: Tweaked website").
 
@@ -35,7 +34,8 @@ repositories {
 }
 
 dependencies {
-  implementation fg.deobf("org.squiddev:cc-tweaked-${mc_version}:${cct_version}")
+  compileOnly fg.deobf("org.squiddev:cc-tweaked-${mc_version}:${cct_version}:api")
+  runtimeOnly fg.deobf("org.squiddev:cc-tweaked-${mc_version}:${cct_version}")
 }
 ```
 
@@ -51,3 +51,6 @@ the generated documentation [can be browsed online](https://tweaked.cc/javadoc/)
 [modrinth]: https://modrinth.com/mod/gu7yAYhd "Download CC: Tweaked from Modrinth"
 [forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
 [ccrestitched]: https://www.curseforge.com/minecraft/mc-mods/cc-restitched "Download CC: Restitched from CurseForge"
+[forum]: https://forums.computercraft.cc/
+[GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
+[IRC]: http://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"

build.gradle

@@ -1,30 +1,22 @@
-buildscript {
-    repositories {
-        mavenCentral()
-        maven { url = "https://maven.minecraftforge.net" }
-        maven { url = 'https://maven.parchmentmc.org' }
-    }
-    dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:5.1.+'
-        classpath "org.spongepowered:mixingradle:0.7.+"
-        classpath 'org.parchmentmc:librarian:1.+'
-    }
-}
-
 plugins {
     id "checkstyle"
     id "jacoco"
     id "maven-publish"
-    id "com.github.hierynomus.license" version "0.16.1"
+    id "org.cadixdev.licenser" version "0.6.1"
     id "com.matthewprenger.cursegradle" version "1.4.0"
     id "com.github.breadmoirai.github-release" version "2.2.12"
-    id "org.jetbrains.kotlin.jvm" version "1.6.0"
-    id "com.modrinth.minotaur" version "1.2.1"
+    id "org.jetbrains.kotlin.jvm" version "1.7.0"
+    id "com.modrinth.minotaur" version "2.+"
+    id "net.minecraftforge.gradle" version "5.1.+"
+    id "org.spongepowered.mixin" version "0.7.+"
+    id "org.parchmentmc.librarian.forgegradle" version "1.+"
+    id "com.github.johnrengelman.shadow" version "7.1.2"
+    id "cc-tweaked.illuaminate"
 }
 
-apply plugin: 'net.minecraftforge.gradle'
-apply plugin: "org.spongepowered.mixin"
-apply plugin: 'org.parchmentmc.librarian.forgegradle'
+import org.apache.tools.ant.taskdefs.condition.Os
+import cc.tweaked.gradle.IlluaminateExec
+import cc.tweaked.gradle.IlluaminateExecToDir
 
 version = mod_version
 
@@ -39,12 +31,7 @@ java {
 
     withSourcesJar()
     withJavadocJar()
-}
-
-tasks.withType(JavaExec).configureEach {
-    javaLauncher = javaToolchains.launcherFor {
-        languageVersion = javaVersion
-    }
+    registerFeature("extraMods") { usingSourceSet(sourceSets.main) }
 }
 
 sourceSets {
@@ -64,6 +51,7 @@ minecraft {
 
             property 'forge.logging.markers', 'REGISTRIES'
             property 'forge.logging.console.level', 'debug'
+            forceExit = false
 
             mods {
                 computercraft {
@@ -108,6 +96,8 @@ minecraft {
         gameTestServer {
             workingDirectory project.file('test-files/server')
 
+            property("forge.logging.console.level", "info")
+
             mods {
                 cctest {
                     source sourceSets.testMod
@@ -122,8 +112,8 @@ minecraft {
         }
     }
 
-    // mappings channel: 'parchment', version: "${mapping_version}-${mc_version}"
-    mappings channel: 'official', version: mc_version
+    mappings channel: 'parchment', version: "${mapping_version}-${mc_version}"
+    // mappings channel: 'official', version: mc_version
 
     accessTransformer file('src/main/resources/META-INF/accesstransformer.cfg')
     accessTransformer file('src/testMod/resources/META-INF/accesstransformer.cfg')
@@ -133,6 +123,10 @@ mixin {
     add sourceSets.main, 'computercraft.mixins.refmap.json'
 }
 
+reobf {
+    shadowJar {}
+}
+
 repositories {
     mavenCentral()
     maven {
@@ -142,7 +136,7 @@ repositories {
 }
 
 configurations {
-    shade
+    shade { transitive = false }
     implementation.extendsFrom shade
 
     cctJavadoc
@@ -158,8 +152,10 @@ dependencies {
     minecraft "net.minecraftforge:forge:${mc_version}-${forge_version}"
     annotationProcessor 'org.spongepowered:mixin:0.8.4:processor'
 
-    compileOnly fg.deobf("mezz.jei:jei-1.18.2:9.4.1.116:api")
-    // runtimeOnly fg.deobf("mezz.jei:jei-1.18.2:9.4.1.116")
+    extraModsCompileOnly fg.deobf("mezz.jei:jei-1.19.2-forge-api:11.3.0.262")
+    extraModsCompileOnly fg.deobf("mezz.jei:jei-1.19.2-common-api:11.3.0.262")
+    extraModsRuntimeOnly fg.deobf("mezz.jei:jei-1.19.2-forge:11.3.0.262")
+    extraModsCompileOnly fg.deobf("maven.modrinth:oculus:1.2.5")
 
     shade 'org.squiddev:Cobalt:0.5.5'
     shade 'io.netty:netty-codec-http:4.1.76.Final'
@@ -168,28 +164,36 @@ dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter-params:5.7.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
     testImplementation 'org.hamcrest:hamcrest:2.2'
-    testImplementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.6.0'
-    testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2'
+    testImplementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.7.0'
+    testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.2'
 
     testModImplementation sourceSets.main.output
     testModExtra('org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.6.0') {
         exclude group: "org.jetbrains", module: "annotations"
     }
 
-    cctJavadoc 'cc.tweaked:cct-javadoc:1.4.6'
+    cctJavadoc 'cc.tweaked:cct-javadoc:1.4.7'
+}
+
+illuaminate {
+    version.set("0.1.0-3-g0f40379")
 }
 
 // Compile tasks
 
-compileTestModJava {
-    dependsOn(compileJava)
-}
-
 javadoc {
     include "dan200/computercraft/api/**/*.java"
 }
 
-task luaJavadoc(type: Javadoc) {
+def apiJar = tasks.register("apiJar", Jar.class) {
+    archiveClassifier.set("api")
+    from(sourceSets.main.output) {
+        include "dan200/computercraft/api/**/*"
+    }
+}
+assemble.dependsOn(apiJar)
+
+def luaJavadoc = tasks.register("luaJavadoc", Javadoc.class) {
     description "Generates documentation for Java-side Lua functions."
     group "documentation"
 
@@ -207,6 +211,9 @@ task luaJavadoc(type: Javadoc) {
 }
 
 jar {
+    finalizedBy("reobfJar")
+
+    archiveClassifier.set("slim")
     manifest {
         attributes([
             "Specification-Title"     : "computercraft",
@@ -215,20 +222,29 @@ jar {
             "Implementation-Title"    : "CC: Tweaked",
             "Implementation-Version"  : "${mod_version}",
             "Implementation-Vendor"   : "SquidDev",
-            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
-        ,
+            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
             "MixinConfigs"            : "computercraft.mixins.json",
         ])
     }
-
-    duplicatesStrategy(DuplicatesStrategy.WARN)
-
-    from configurations.shade.collect { it.isDirectory() ? it : zipTree(it) }
 }
 
-jar.finalizedBy('reobfJar')
+shadowJar {
+    finalizedBy("reobfShadowJar")
 
-[compileJava, compileTestJava, compileTestModJava].forEach {
+    archiveClassifier.set("")
+    configurations = [project.configurations.shade]
+    relocate("org.squiddev.cobalt", "cc.tweaked.internal.cobalt")
+    relocate("io.netty.handler.codec.http", "cc.tweaked.internal.netty")
+    minimize()
+}
+
+assemble.dependsOn("shadowJar")
+
+[
+    tasks.named("compileJava", JavaCompile.class),
+    tasks.named("compileTestJava", JavaCompile.class),
+    tasks.named("compileTestModJava", JavaCompile.class)
+].forEach {
     it.configure {
         options.compilerArgs << "-Xlint" << "-Xlint:-processing"
     }
@@ -292,17 +308,11 @@ sourcesJar {
 
 // Web tasks
 
-
-import com.hierynomus.gradle.license.tasks.LicenseCheck
-import com.hierynomus.gradle.license.tasks.LicenseFormat
-import com.modrinth.minotaur.TaskModrinthUpload
-import org.apache.tools.ant.taskdefs.condition.Os
-
 List<String> mkCommand(String command) {
     return Os.isFamily(Os.FAMILY_WINDOWS) ? ["cmd", "/c", command] : ["sh", "-c", command]
 }
 
-task rollup(type: Exec) {
+def rollup = tasks.register("rollup", Exec.class) {
     group = "build"
     description = "Bundles JS into rollup"
 
@@ -315,36 +325,46 @@ task rollup(type: Exec) {
     commandLine mkCommand('"node_modules/.bin/rollup" --config rollup.config.js')
 }
 
-task illuaminateDocs(type: Exec, dependsOn: [rollup, luaJavadoc]) {
-    group = "build"
+def illuaminateDocs = tasks.register("illuaminateDocs", IlluaminateExecToDir.class) {
+    group = "documentation"
     description = "Generates docs using Illuaminate"
+    dependsOn(rollup)
 
-    inputs.files(fileTree("doc")).withPropertyName("docs")
-    inputs.files(fileTree("src/main/resources/data/computercraft/lua/rom")).withPropertyName("lua rom")
+    // Config files
     inputs.file("illuaminate.sexp").withPropertyName("illuaminate.sexp")
-    inputs.dir("$buildDir/docs/luaJavadoc")
+    // Sources
+    inputs.files(fileTree("doc")).withPropertyName("docs")
+    inputs.files(fileTree("src/main/resources/data/computercraft/lua")).withPropertyName("lua rom")
+    inputs.files(luaJavadoc)
+    // Additional assets
     inputs.file("$buildDir/rollup/index.js").withPropertyName("scripts")
     inputs.file("src/web/styles.css").withPropertyName("styles")
-    outputs.dir("$buildDir/docs/lua")
 
-    commandLine mkCommand('"bin/illuaminate" doc-gen')
+    // Output directory. Also defined in illuaminate.sexp and transform.tsx
+    output.set(new File(buildDir, "docs/lua"))
+
+    args = ["doc-gen"]
 }
 
-task jsxDocs(type: Exec, dependsOn: [illuaminateDocs]) {
-    group = "build"
+def jsxDocs = tasks.register("jsxDocs", Exec) {
+    group = "documentation"
     description = "Post-processes documentation to statically render some dynamic content."
 
     inputs.files(fileTree("src/web")).withPropertyName("sources")
     inputs.file("src/generated/export/index.json").withPropertyName("export")
     inputs.file("package-lock.json").withPropertyName("package-lock.json")
     inputs.file("tsconfig.json").withPropertyName("Typescript config")
-    inputs.files(fileTree("$buildDir/docs/lua"))
+    inputs.files(illuaminateDocs)
     outputs.dir("$buildDir/docs/site")
 
-    commandLine mkCommand('"node_modules/.bin/ts-node" --esm src/web/transform.tsx')
+    commandLine mkCommand('"node_modules/.bin/ts-node" -T --esm src/web/transform.tsx')
 }
 
-task docWebsite(type: Copy, dependsOn: [jsxDocs]) {
+def docWebsite = tasks.register("docWebsite", Copy.class) {
+    group = "documentation"
+    description = "Copy additional assets to the website directory."
+    dependsOn(jsxDocs)
+
     from('doc') {
         include 'logo.png'
         include 'images/**'
@@ -379,94 +399,92 @@ jacocoTestReport {
     }
 }
 
-check.dependsOn jacocoTestReport
+test.finalizedBy("jacocoTestReport")
 
 license {
-    mapping("java", "SLASHSTAR_STYLE")
-    strictCheck true
+    header = file('config/license/main.txt')
+    lineEnding = '\n'
+    newLine = false
 
-    ext.year = Calendar.getInstance().get(Calendar.YEAR)
-}
+    properties {
+        year = Calendar.getInstance().get(Calendar.YEAR)
+    }
 
-[licenseMain, licenseFormatMain].forEach {
-    it.configure {
-        include("**/*.java")
-        exclude("dan200/computercraft/api/**")
-        header file('config/license/main.txt')
+    include("**/*.java") // We could apply to Kotlin, but for now let's not
+    matching("dan200/computercraft/api/**") {
+        header = file('config/license/api.txt')
     }
 }
 
-[licenseTest, licenseFormatTest, licenseTestMod, licenseFormatTestMod].forEach {
-    it.configure {
-        include("**/*.java")
-        header file('config/license/main.txt')
-    }
+check.dependsOn("licenseCheck")
+
+def lintLua = tasks.register("lintLua", IlluaminateExec.class) {
+    group = JavaBasePlugin.VERIFICATION_GROUP
+    description = "Lint Lua (and Lua docs) with illuaminate"
+
+    // Config files
+    inputs.file("illuaminate.sexp").withPropertyName("illuaminate.sexp")
+    // Sources
+    inputs.files(fileTree("doc")).withPropertyName("docs")
+    inputs.files(fileTree("src/main/resources/data/computercraft/lua")).withPropertyName("lua rom")
+    inputs.files(luaJavadoc)
+
+    args = ["lint"]
+
+    doFirst { if (System.getenv("GITHUB_ACTIONS") != null) println("::add-matcher::.github/matchers/illuaminate.json") }
+    doLast { if (System.getenv("GITHUB_ACTIONS") != null) println("::remove-matcher owner=illuaminate::") }
 }
 
-gradle.projectsEvaluated {
-    tasks.withType(LicenseFormat) {
-        outputs.upToDateWhen { false }
-    }
-}
+def testServerClassDumpDir = new File(buildDir, "jacocoClassDump/runTestServer")
 
-
-task licenseAPI(type: LicenseCheck)
-task licenseFormatAPI(type: LicenseFormat)
-[licenseAPI, licenseFormatAPI].forEach {
-    it.configure {
-        source = sourceSets.main.java
-        include("dan200/computercraft/api/**")
-        header file('config/license/api.txt')
-    }
-}
-
-tasks.register("testServer", JavaExec.class).configure {
-    it.group('In-game tests')
-    it.description("Runs tests on a temporary Minecraft instance.")
-    it.dependsOn("prepareRunGameTestServer", "cleanTestServer", 'compileTestModJava')
+def testServer = tasks.register("testServer", JavaExec.class) {
+    group("In-game tests")
+    description("Runs tests on a temporary Minecraft instance.")
+    dependsOn("cleanTestServer")
+    finalizedBy("jacocoTestServerReport")
 
     // Copy from runTestServer. We do it in this slightly odd way as runTestServer
     // isn't created until the task is configured (which is no good for us).
     JavaExec exec = tasks.getByName("runGameTestServer")
+    dependsOn(exec.getDependsOn())
     exec.copyTo(it)
-    it.setClasspath(exec.getClasspath())
-    it.mainClass = exec.mainClass
-    it.setArgs(exec.getArgs())
+    setClasspath(exec.getClasspath())
+    mainClass = exec.mainClass
+    javaLauncher = exec.javaLauncher
+    setArgs(exec.getArgs())
 
     // Jacoco and modlauncher don't play well together as the classes loaded in-game don't
     // match up with those written to disk. We get Jacoco to dump all classes to disk, and
     // use that when generating the report.
-    def coverageOut = new File(buildDir, "jacocoClassDump/testServer")
     jacoco.applyTo(it)
     it.jacoco.setIncludes(["dan200.computercraft.*"])
-    it.jacoco.setClassDumpDir(coverageOut)
-    it.outputs.dir(coverageOut)
+    it.jacoco.setClassDumpDir(testServerClassDumpDir)
+    outputs.dir(testServerClassDumpDir)
     // 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.
     it.jacoco.setIncludeNoLocationClasses(true)
 }
 
-tasks.register("jacocoTestServerReport", JacocoReport.class).configure {
-    it.group('In-game')
-    it.description("Generate coverage reports for testServer")
-    it.dependsOn("testServer")
+tasks.register("jacocoTestServerReport", JacocoReport.class) {
+    group("In-game tests")
+    description("Generate coverage reports for testServer")
+    dependsOn(testServer)
 
-    it.executionData(new File(buildDir, "jacoco/testServer.exec"))
-    it.sourceDirectories.from(sourceSets.main.allJava.srcDirs)
-    it.classDirectories.from(new File(buildDir, "jacocoClassDump/testServer"))
+    executionData(new File(buildDir, "jacoco/testServer.exec"))
+    sourceDirectories.from(sourceSets.main.allJava.srcDirs)
+    classDirectories.from(testServerClassDumpDir)
 
-    it.reports {
+    reports {
         xml.enabled true
         html.enabled true
     }
 }
 
-check.dependsOn("jacocoTestServerReport")
-
+check.dependsOn(testServer)
 
 // Upload tasks
 
-task checkRelease {
+def checkRelease = tasks.register("checkRelease") {
     group "upload"
     description "Verifies that everything is ready for a release"
 
@@ -504,9 +522,9 @@ task checkRelease {
         if (!ok) throw new IllegalStateException("Could not check release")
     }
 }
-check.dependsOn checkRelease
+check.dependsOn(checkRelease)
 
-def isStable = true
+def isStable = false
 
 curseforge {
     apiKey = project.hasProperty('curseForgeApiKey') ? project.curseForgeApiKey : ''
@@ -514,36 +532,29 @@ curseforge {
         id = '282001'
         releaseType = isStable ? 'release' : 'alpha'
         changelog = "Release notes can be found on the GitHub repository (https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v${mc_version}-${mod_version})."
+        mainArtifact(shadowJar)
 
         addGameVersion "${mc_version}"
     }
 }
 
-tasks.register('publishModrinth', TaskModrinthUpload.class).configure {
-    dependsOn('assemble', 'reobfJar')
-    onlyIf {
-        project.hasProperty('modrinthApiKey')
-    }
-
+modrinth {
     token = project.hasProperty('modrinthApiKey') ? project.getProperty('modrinthApiKey') : ''
     projectId = 'gu7yAYhd'
     versionNumber = "${project.mc_version}-${project.mod_version}"
-    uploadFile = jar
-    versionType = isStable ? 'RELEASE' : 'ALPHA'
-    addGameVersion(project.mc_version)
+    versionName = "${project.mod_version}"
+    versionType = isStable ? 'release' : 'alpha'
+    uploadFile = shadowJar
+    gameVersions = [project.mc_version]
     changelog = "Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v${mc_version}-${mod_version})."
-    addLoader('forge')
-}
-
-tasks.withType(GenerateModuleMetadata) {
-    // We can't generate metadata as that includes Forge as a dependency.
-    enabled = false
 }
 
 publishing {
     publications {
         maven(MavenPublication) {
             from components.java
+            artifact(apiJar)
+            fg.component(it)
 
             pom {
                 name = 'CC: Tweaked'
@@ -562,11 +573,9 @@ publishing {
                 licenses {
                     license {
                         name = 'ComputerCraft Public License, Version 1.0'
-                        url = 'https://github.com/cc-tweaked/CC-Tweaked/blob/mc-1.15.x/LICENSE'
+                        url = 'https://github.com/cc-tweaked/CC-Tweaked/blob/mc-1.16.x/LICENSE'
                     }
                 }
-
-                withXml { asNode().remove(asNode().get("dependencies")) }
             }
         }
     }
@@ -614,10 +623,11 @@ githubRelease {
     prerelease !isStable
 }
 
-def uploadTasks = ["publish", "curseforge", "publishModrinth", "githubRelease"]
-uploadTasks.forEach { tasks.getByName(it).dependsOn checkRelease }
+def uploadTasks = ["publish", "curseforge", "modrinth", "githubRelease"]
+uploadTasks.forEach { tasks.named(it) { dependsOn(checkRelease) } }
 
-task uploadAll(dependsOn: uploadTasks) {
-    group "upload"
-    description "Uploads to all repositories (Maven, Curse, Modrinth, GitHub release)"
+tasks.register("uploadAll") {
+    group = "upload"
+    description = "Uploads to all repositories (Maven, Curse, Modrinth, GitHub release)"
+    dependsOn(uploadTasks)
 }

buildSrc/build.gradle.kts

@@ -0,0 +1,18 @@
+plugins {
+    `java-gradle-plugin`
+    `kotlin-dsl`
+}
+
+repositories {
+    mavenCentral()
+    gradlePluginPortal()
+}
+
+gradlePlugin {
+    plugins {
+        register("cc-tweaked.illuaminate") {
+            id = "cc-tweaked.illuaminate"
+            implementationClass = "cc.tweaked.gradle.IlluaminatePlugin"
+        }
+    }
+}

buildSrc/src/main/kotlin/cc/tweaked/gradle/ExecTasks.kt

@@ -0,0 +1,11 @@
+package cc.tweaked.gradle
+
+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
+    abstract val output: Property<File>
+}

buildSrc/src/main/kotlin/cc/tweaked/gradle/Illuaminate.kt

@@ -0,0 +1,121 @@
+package cc.tweaked.gradle
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.AbstractExecTask
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.TaskAction
+import java.io.File
+
+abstract class IlluaminateExtension {
+    /** The version of illuaminate to use. */
+    abstract val version: Property<String>
+
+    /** The path to illuaminate. If not given, illuaminate will be downloaded automatically. */
+    abstract val file: Property<File>
+}
+
+class IlluaminatePlugin : Plugin<Project> {
+    override fun apply(project: Project) {
+        val extension = project.extensions.create("illuaminate", IlluaminateExtension::class.java)
+        extension.file.convention(setupDependency(project, extension.version))
+
+        project.tasks.register(SetupIlluaminate.NAME, SetupIlluaminate::class.java) {
+            file.set(extension.file.map { it.absolutePath })
+        }
+    }
+
+    /** Set up a repository for illuaminate and download our binary from it. */
+    private fun setupDependency(project: Project, version: Provider<String>): Provider<File> {
+        project.repositories.ivy {
+            name = "Illuaminate"
+            setUrl("https://squiddev.cc/illuaminate/bin/")
+            patternLayout {
+                artifact("[revision]/[artifact]-[ext]")
+            }
+            metadataSources {
+                artifact()
+            }
+            content {
+                includeModule("cc.squiddev", "illuaminate")
+            }
+        }
+
+        return version.map {
+            val dep = illuaminateArtifact(project, it)
+            val configuration = project.configurations.detachedConfiguration(dep)
+            configuration.isTransitive = false
+            configuration.resolve().single()
+        }
+    }
+
+    /** Define a dependency for illuaminate from a version number and the current operating system. */
+    private fun illuaminateArtifact(project: Project, version: String): Dependency {
+        val osName = System.getProperty("os.name").toLowerCase()
+        val (os, suffix) = when {
+            osName.contains("windows") -> Pair("windows", ".exe")
+            osName.contains("mac os") || osName.contains("darwin") -> Pair("macos", "")
+            osName.contains("linux") -> Pair("linux", "")
+            else -> error("Unsupported OS $osName for illuaminate")
+        }
+
+        val osArch = System.getProperty("os.arch").toLowerCase()
+        val arch = when {
+            osArch == "arm" || osArch.startsWith("aarch") -> error("Unsupported architecture '$osArch' for illuaminate")
+            osArch.contains("64") -> "x86_64"
+            else -> error("Unsupported architecture $osArch for illuaminate")
+        }
+
+        return project.dependencies.create(
+            mapOf(
+                "group" to "cc.squiddev",
+                "name" to "illuaminate",
+                "version" to version,
+                "ext" to "$os-$arch$suffix",
+            ),
+        )
+    }
+}
+
+private val Task.illuaminatePath: String? // "?" needed to avoid overload ambiguity in setExecutable below.
+    get() = project.extensions.getByType(IlluaminateExtension::class.java).file.get().absolutePath
+
+/** Prepares illuaminate for being run. This simply requests the dependency and then marks it as executable. */
+abstract class SetupIlluaminate : DefaultTask() {
+    @get:Input
+    abstract val file: Property<String>
+
+    @TaskAction
+    fun setExecutable() {
+        val file = File(this.file.get())
+        if (file.canExecute()) {
+            didWork = false
+            return
+        }
+
+        file.setExecutable(true)
+    }
+
+    companion object {
+        const val NAME: String = "setupIlluaminate"
+    }
+}
+
+abstract class IlluaminateExec : AbstractExecTask<IlluaminateExec>(IlluaminateExec::class.java) {
+    init {
+        dependsOn(SetupIlluaminate.NAME)
+        executable = illuaminatePath
+    }
+}
+
+abstract class IlluaminateExecToDir : ExecToDir() {
+    init {
+        dependsOn(SetupIlluaminate.NAME)
+        executable = illuaminatePath
+    }
+}

config/pre-commit/illuaminate-lint.sh

@@ -1,16 +0,0 @@
-#!/usr/bin/env sh
-set -e
-
-test -d bin || mkdir bin
-test -f bin/illuaminate || curl -s -obin/illuaminate https://squiddev.cc/illuaminate/linux-x86-64/illuaminate
-chmod +x bin/illuaminate
-
-if [ -n ${GITHUB_ACTIONS+x} ]; then
-    # Register a problem matcher (see https://github.com/actions/toolkit/blob/master/docs/problem-matchers.md)
-    # for illuaminate.
-    echo "::add-matcher::.github/matchers/illuaminate.json"
-    trap 'echo "::remove-matcher owner=illuaminate::"' EXIT
-fi
-
-./gradlew luaJavadoc
-bin/illuaminate lint

doc/guides/gps_setup.md

@@ -0,0 +1,90 @@
+---
+module: [kind=guide] gps_setup
+---
+
+# Setting up GPS
+The @{gps} API allows computers and turtles to find their current position using wireless modems.
+
+In order to use GPS, you'll need to set up multiple *GPS hosts*. These are computers running the special `gps host`
+program, which tell other computers the host's position. Several hosts running together are known as a *GPS
+constellation*.
+
+In order to give the best results, a GPS constellation needs at least four computers. More than four GPS hosts per
+constellation is redundant, but it does not cause problems.
+
+## Building a GPS constellation
+![An example GPS constellation.](/images/gps-constellation-example.png){.big-image}
+
+We are going to build our GPS constellation as shown in the image above. You will need 4 computers and either 4 wireless
+modems or 4 ender modems. Try not to mix ender and wireless modems together as you might get some odd behavior when your
+requesting computers are out of range.
+
+:::tip Ender modems vs wireless modems
+Ender modems have a very large range, which makes them very useful for setting up GPS hosts. If you do this then you
+will likely only need one GPS constellation for the whole dimension (such as the Overworld or Nether).
+
+If you do use wireless modems then you may find that you need multiple GPS constellations to cover your needs.
+
+A computer needs a wireless or ender modem and to be in range of a GPS constellation that is in the same dimension as it
+to use the GPS API. The reason for this is that ComputerCraft mimics real-life GPS by making use of the distance
+parameter of @{modem_message|modem messages} and some maths.
+:::
+
+Locate where you want to place your GPS constellation. You will need an area at least 6 blocks high, 6 blocks wide, and
+6 blocks deep (6x6x6). If you are using wireless modems then you may want to build your constellation as high as you can
+because high altitude boosts modem message range and thus the radius that your constellation covers.
+
+The GPS constellation will only work when it is in a loaded chunk. If you want your constellation to always be
+accessible, you may want to permanently load the chunk using a vanilla or modded chunk loader. Make sure that your 6x6x6
+area fits in a single chunk to reduce the number of chunks that need to be kept loaded.
+
+Let's get started building the constellation! Place your first computer in one of the corners of your 6x6x6. Remember
+which computer this is as other computers need to be placed relative to it. Place the second computer 4 blocks above the
+first. Go back to your first computer and place your third computer 5 blocks in front of your first computer, leaving 4
+blocks of air between them. Finally for the fourth computer, go back to your first computer and place it 5 blocks right
+of your first computer, leaving 4 blocks of air between them.
+
+With all four computers placed within the 6x6x6, place one modem on top of each computer. You should have 4 modems and 4
+computers all within your 6x6x6 where each modem is attached to a computer and each computer has a modem.
+
+Currently your GPS constellation will not work, that's because each host is not aware that it's a GPS host. We will fix
+this in the next section.
+
+## Configuring the constellation
+Now that the structure of your constellation is built, we need to configure each host in it.
+
+Go back to the first computer that you placed and create a startup file, by running `edit startup`.
+
+Type the following code into the file:
+```lua
+shell.run("gps", "host", x, y, z)
+```
+
+Escape from the computer GUI and then press <kbd>F3</kbd> to open Minecraft's debug screen and then look at the computer
+(without opening the GUI). On the right of the screen about halfway down you should see an entry labeled `Targeted
+Block`, the numbers correspond to the position of the block that you are looking at. Replace `x` with the first number,
+`y` with the second number, and `z` with the third number.
+
+For example, if I had a computer at x = 59, y = 5, z = -150, then my <kbd>F3</kbd> debug screen entry would be `Target
+Block: 59, 5, -150` and I would change my startup file to this `shell.run("gps", "host", 59, 5, -150)`.
+
+To hide Minecraft's debug screen, press <kbd>F3</kbd> again.
+
+Create similar startup files for the other computers in your constellation, making sure to input the each computer's own
+coordinates.
+
+:::caution Modem messages come from the computer's position, not the modem's
+Wireless modems transmit from the block that they are attached to *not* the block space that they occupy, the
+coordinates that you input into your GPS host should be the position of the computer and not the position of the modem.
+:::
+
+Congratulations, your constellation is now fully set up! You can test it by placing another computer close by, placing a
+wireless modem on it, and running the `gps locate` program (or calling the @{gps.locate} function).
+
+:::info Why use Minecraft's coordinates?
+CC doesn't care if you use Minecraft's coordinate system, so long as all of the GPS hosts with overlapping ranges use
+the same reference point (requesting computers will get confused if hosts have different reference points). However,
+using MC's coordinate system does provide a nice standard to adopt server-wide. It also is consistent with how command
+computers get their location, they use MC's command system to get their block which returns that in MC's coordinate
+system.
+:::

doc/guides/speaker_audio.md

@@ -185,7 +185,7 @@ end
 
 :::note Confused?
 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 [Discord] or [IRC] either!
+cover. That said, don't be afraid to ask on [GitHub Discussions] or [IRC] either!
 :::
 
 It's worth noting that the examples of audio processing we've mentioned here are about manipulating the _amplitude_ of
@@ -200,6 +200,5 @@ This is, I'm afraid, left as an exercise to the reader.
 [PCM]: https://en.wikipedia.org/wiki/Pulse-code_modulation "Pulse-code Modulation - Wikipedia"
 [Ring Buffer]: https://en.wikipedia.org/wiki/Circular_buffer "Circular buffer - Wikipedia"
 [Sine Wave]: https://en.wikipedia.org/wiki/Sine_wave "Sine wave - Wikipedia"
-
-[Discord]: https://discord.computercraft.cc "The Minecraft Computer Mods Discord"
-[IRC]: http://webchat.esper.net/?channels=computercraft "IRC webchat on EsperNet"
+[GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
+[IRC]: http://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"

doc/index.md

@@ -37,8 +37,7 @@ little daunting getting started. Thankfully, there's several fantastic tutorials
 Once you're a little more familiar with the mod, the sidebar and links below provide more detailed documentation on the
 various APIs and peripherals provided by the mod.
 
-If you get stuck, do pop in to the [Minecraft Computer Mod Discord guild][discord] or ComputerCraft's
-[IRC channel][irc].
+If you get stuck, do [ask a question on GitHub][GitHub Discussions] or pop in to the ComputerCraft's [IRC channel][IRC].
 
 ## Get Involved
 CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please do [create an issue][bug].
@@ -51,5 +50,5 @@ CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please
 [forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
 [ccrestitched]: https://www.curseforge.com/minecraft/mc-mods/cc-restitched "Download CC: Restitched from CurseForge"
 [lua]: https://www.lua.org/ "Lua's main website"
-[discord]: https://discord.computercraft.cc "The Minecraft Computer Mods Discord"
-[irc]: http://webchat.esper.net/?channels=computercraft "IRC webchat on EsperNet"
+[GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
+[IRC]: http://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"

doc/stub/global.lua

@@ -14,7 +14,7 @@ thread, not the whole program.
 
 :::tip
 Because sleep internally uses timers, it is a function that yields. This means
-that you can use it to prevent "Too long without yielding" errors, however, as
+that you can use it to prevent "Too long without yielding" errors. However, as
 the minimum sleep time is 0.05 seconds, it will slow your program down.
 :::
 

gradle.properties

@@ -1,10 +1,11 @@
 org.gradle.jvmargs=-Xmx3G
+kotlin.stdlib.default.dependency=false
 
 # Mod properties
-mod_version=1.100.6
+mod_version=1.100.10
 
 # Minecraft properties (update mods.toml when changing)
-mc_version=1.19
-mapping_version=2022.03.13
-forge_version=41.0.16
+mc_version=1.19.2
+mapping_version=1.18.2-2022.07.03
+forge_version=43.1.1
 # NO SERIOUSLY, UPDATE mods.toml WHEN CHANGING

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

package.json

@@ -11,7 +11,7 @@
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^8.2.5",
-    "@rollup/plugin-url": "^6.1.0",
+    "@rollup/plugin-url": "^7.0.0",
     "@types/glob": "^7.2.0",
     "@types/react-dom": "^18.0.5",
     "glob": "^8.0.3",

settings.gradle

@@ -1 +0,0 @@
-rootProject.name = "cc-tweaked-${mc_version}"

settings.gradle.kts

@@ -0,0 +1,17 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        maven("https://maven.minecraftforge.net")
+        maven("https://maven.parchmentmc.org")
+    }
+    resolutionStrategy {
+        eachPlugin {
+            if (requested.id.id == "org.spongepowered.mixin") {
+                useModule("org.spongepowered:mixingradle:${requested.version}")
+            }
+        }
+    }
+}
+
+val mc_version: String by settings
+rootProject.name = "cc-tweaked-${mc_version}"

src/main/java/dan200/computercraft/ComputerCraft.java

@@ -13,8 +13,8 @@ import dan200.computercraft.shared.computer.core.ClientComputerRegistry;
 import dan200.computercraft.shared.computer.core.ServerComputerRegistry;
 import dan200.computercraft.shared.peripheral.monitor.MonitorRenderer;
 import net.minecraftforge.fml.common.Mod;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.List;
 import java.util.concurrent.TimeUnit;
@@ -81,7 +81,7 @@ public final class ComputerCraft
     public static final ServerComputerRegistry serverComputerRegistry = new ServerComputerRegistry();
 
     // Logging
-    public static final Logger log = LogManager.getLogger( MOD_ID );
+    public static final Logger log = LoggerFactory.getLogger( MOD_ID );
 
     public ComputerCraft()
     {

src/main/java/dan200/computercraft/api/client/ComputerCraftAPIClient.java

@@ -0,0 +1,57 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2022. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+package dan200.computercraft.api.client;
+
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+
+import javax.annotation.Nonnull;
+
+public final class ComputerCraftAPIClient
+{
+    private ComputerCraftAPIClient()
+    {
+    }
+
+    /**
+     * Register a {@link TurtleUpgradeModeller} for a class of turtle upgrades.
+     *
+     * This may be called at any point after registry creation, though it is recommended to call it within {@link FMLClientSetupEvent}.
+     *
+     * @param serialiser The turtle upgrade serialiser.
+     * @param modeller   The upgrade modeller.
+     * @param <T>        The type of the turtle upgrade.
+     */
+    public static <T extends ITurtleUpgrade> void registerTurtleUpgradeModeller( @Nonnull TurtleUpgradeSerialiser<T> serialiser, @Nonnull TurtleUpgradeModeller<T> modeller )
+    {
+        getInstance().registerTurtleUpgradeModeller( serialiser, modeller );
+    }
+
+    private static IComputerCraftAPIClient instance;
+
+    @Nonnull
+    private static IComputerCraftAPIClient getInstance()
+    {
+        if( instance != null ) return instance;
+
+        try
+        {
+            return instance = (IComputerCraftAPIClient) Class.forName( "dan200.computercraft.client.ComputerCraftAPIClientImpl" )
+                .getField( "INSTANCE" ).get( null );
+        }
+        catch( ReflectiveOperationException e )
+        {
+            throw new IllegalStateException( "Cannot find ComputerCraft API", e );
+        }
+    }
+
+    public interface IComputerCraftAPIClient
+    {
+        <T extends ITurtleUpgrade> void registerTurtleUpgradeModeller( @Nonnull TurtleUpgradeSerialiser<T> serialiser, @Nonnull TurtleUpgradeModeller<T> modeller );
+    }
+}

src/main/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModeller.java

@@ -0,0 +1,68 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2022. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+package dan200.computercraft.api.client.turtle;
+
+import dan200.computercraft.api.client.ComputerCraftAPIClient;
+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.api.turtle.TurtleUpgradeSerialiser;
+import net.minecraft.client.resources.model.ModelResourceLocation;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * Provides models for a {@link ITurtleUpgrade}.
+ *
+ * @param <T> The type of turtle upgrade this modeller applies to.
+ * @see ComputerCraftAPIClient#registerTurtleUpgradeModeller(TurtleUpgradeSerialiser, TurtleUpgradeModeller) To register a modeller.
+ */
+public interface TurtleUpgradeModeller<T extends ITurtleUpgrade>
+{
+    /**
+     * Obtain the model to be used when rendering a turtle peripheral.
+     *
+     * When the current turtle is {@literal null}, this function should be constant for a given upgrade and side.
+     *
+     * @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.
+     * @return The model that you wish to be used to render your upgrade.
+     */
+    @Nonnull
+    TransformedModel getModel( @Nonnull T upgrade, @Nullable ITurtleAccess turtle, @Nonnull TurtleSide side );
+
+    /**
+     * A basic {@link TurtleUpgradeModeller} which renders using the upgrade's {@linkplain ITurtleUpgrade#getCraftingItem()
+     * crafting item}.
+     *
+     * 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.FLAT_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( ModelResourceLocation left, ModelResourceLocation right )
+    {
+        return ( upgrade, turtle, side ) -> TransformedModel.of( side == TurtleSide.LEFT ? left : right );
+    }
+}

src/main/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModellers.java

@@ -0,0 +1,31 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2022. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+package dan200.computercraft.api.client.turtle;
+
+import com.mojang.math.Matrix4f;
+import com.mojang.math.Transformation;
+import dan200.computercraft.api.client.TransformedModel;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleSide;
+
+class TurtleUpgradeModellers
+{
+    private static final Transformation leftTransform = getMatrixFor( -0.40625f );
+    private static final Transformation rightTransform = getMatrixFor( 0.40625f );
+
+    private static Transformation getMatrixFor( float offset )
+    {
+        return new Transformation( new Matrix4f( 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,
+        } ) );
+    }
+
+    static final TurtleUpgradeModeller<ITurtleUpgrade> FLAT_ITEM = ( upgrade, turtle, side ) ->
+        TransformedModel.of( upgrade.getCraftingItem(), side == TurtleSide.LEFT ? leftTransform : rightTransform );
+}

src/main/java/dan200/computercraft/api/lua/IArguments.java

@@ -443,16 +443,4 @@ public interface IArguments
     {
         return optTable( index ).orElse( def );
     }
-
-    /**
-     * This is called when the current function finishes, before any main thread tasks have run.
-     *
-     * Called when the current function returns, and so some values are no longer guaranteed to be safe to access.
-     *
-     * @deprecated This method was an internal implementation detail and is no longer used.
-     */
-    @Deprecated
-    default void releaseImmediate()
-    {
-    }
 }

src/main/java/dan200/computercraft/api/pocket/PocketUpgradeDataProvider.java

@@ -7,7 +7,7 @@ package dan200.computercraft.api.pocket;
 
 import dan200.computercraft.api.upgrades.UpgradeDataProvider;
 import net.minecraft.data.DataGenerator;
-import net.minecraftforge.forge.event.lifecycle.GatherDataEvent;
+import net.minecraftforge.data.event.GatherDataEvent;
 
 import javax.annotation.Nonnull;
 import java.util.function.Consumer;

src/main/java/dan200/computercraft/api/pocket/PocketUpgradeSerialiser.java

@@ -33,7 +33,7 @@ import java.util.function.Function;
  * @see IPocketUpgrade
  * @see PocketUpgradeDataProvider
  */
-public interface PocketUpgradeSerialiser<T extends IPocketUpgrade> extends UpgradeSerialiser<T, PocketUpgradeSerialiser<?>>
+public interface PocketUpgradeSerialiser<T extends IPocketUpgrade> extends UpgradeSerialiser<T>
 {
     /**
      * The ID for the associated registry.
@@ -47,6 +47,7 @@ public interface PocketUpgradeSerialiser<T extends IPocketUpgrade> extends Upgra
 
     /**
      * The associated registry.
+     *
      * @return The registry for pocket upgrade serialisers.
      * @see #REGISTRY_ID
      */
@@ -68,7 +69,7 @@ public interface PocketUpgradeSerialiser<T extends IPocketUpgrade> extends Upgra
     @Nonnull
     static <T extends IPocketUpgrade> PocketUpgradeSerialiser<T> simple( @Nonnull Function<ResourceLocation, T> factory )
     {
-        class Impl extends SimpleSerialiser<T, PocketUpgradeSerialiser<?>> implements PocketUpgradeSerialiser<T>
+        class Impl extends SimpleSerialiser<T> implements PocketUpgradeSerialiser<T>
         {
             private Impl( Function<ResourceLocation, T> constructor )
             {
@@ -91,7 +92,7 @@ public interface PocketUpgradeSerialiser<T extends IPocketUpgrade> extends Upgra
     @Nonnull
     static <T extends IPocketUpgrade> PocketUpgradeSerialiser<T> simpleWithCustomItem( @Nonnull BiFunction<ResourceLocation, ItemStack, T> factory )
     {
-        class Impl extends SerialiserWithCraftingItem<T, PocketUpgradeSerialiser<?>> implements PocketUpgradeSerialiser<T>
+        class Impl extends SerialiserWithCraftingItem<T> implements PocketUpgradeSerialiser<T>
         {
             private Impl( BiFunction<ResourceLocation, ItemStack, T> factory )
             {

src/main/java/dan200/computercraft/api/turtle/ITurtleUpgrade.java

@@ -5,16 +5,11 @@
  */
 package dan200.computercraft.api.turtle;
 
-import dan200.computercraft.api.client.TransformedModel;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.IUpgradeBase;
-import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.core.Direction;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
 import net.minecraftforge.event.entity.player.AttackEntityEvent;
-import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.event.level.BlockEvent;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -85,21 +80,6 @@ public interface ITurtleUpgrade extends IUpgradeBase
         return TurtleCommandResult.failure();
     }
 
-    /**
-     * Called to obtain the model to be used when rendering a turtle peripheral.
-     *
-     * This can be obtained from {@link net.minecraft.client.renderer.ItemModelShaper#getItemModel(ItemStack)},
-     * {@link net.minecraft.client.resources.model.ModelManager#getModel(ModelResourceLocation)} or any other
-     * source.
-     *
-     * @param turtle Access to the turtle that the upgrade resides on. This will be null when getting item models!
-     * @param side   Which side of the turtle (left or right) the upgrade resides on.
-     * @return The model that you wish to be used to render your upgrade.
-     */
-    @Nonnull
-    @OnlyIn( Dist.CLIENT )
-    TransformedModel getModel( @Nullable ITurtleAccess turtle, @Nonnull TurtleSide side );
-
     /**
      * Called once per tick for each turtle which has the upgrade equipped.
      *

src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeDataProvider.java

@@ -14,7 +14,7 @@ import net.minecraft.tags.TagKey;
 import net.minecraft.world.entity.ai.attributes.Attributes;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.level.block.Block;
-import net.minecraftforge.forge.event.lifecycle.GatherDataEvent;
+import net.minecraftforge.data.event.GatherDataEvent;
 import net.minecraftforge.registries.ForgeRegistries;
 
 import javax.annotation.Nonnull;
@@ -140,7 +140,10 @@ public abstract class TurtleUpgradeDataProvider extends UpgradeDataProvider<ITur
             add.accept( new Upgrade<>( id, serialiser, s -> {
                 s.addProperty( "item", ForgeRegistries.ITEMS.getKey( toolItem ).toString() );
                 if( adjective != null ) s.addProperty( "adjective", adjective );
-                if( craftingItem != null ) s.addProperty( "craftItem", ForgeRegistries.ITEMS.getKey( craftingItem ).toString() );
+                if( craftingItem != null )
+                {
+                    s.addProperty( "craftItem", ForgeRegistries.ITEMS.getKey( craftingItem ).toString() );
+                }
                 if( damageMultiplier != null ) s.addProperty( "damageMultiplier", damageMultiplier );
                 if( breakable != null ) s.addProperty( "breakable", breakable.location().toString() );
             } ) );

src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeSerialiser.java

@@ -6,6 +6,8 @@
 package dan200.computercraft.api.turtle;
 
 import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.api.client.ComputerCraftAPIClient;
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
 import dan200.computercraft.api.upgrades.IUpgradeBase;
 import dan200.computercraft.api.upgrades.UpgradeSerialiser;
 import dan200.computercraft.internal.upgrades.SerialiserWithCraftingItem;
@@ -54,25 +56,36 @@ import java.util.function.Function;
  * }
  * }</pre>
  *
+ * Finally, we need to register a model for our upgrade. This is done with
+ * {@link ComputerCraftAPIClient#registerTurtleUpgradeModeller(TurtleUpgradeSerialiser, TurtleUpgradeModeller)}:
+ *
+ * <pre>{@code
+ * // Register our model inside FMLClientSetupEvent
+ * ComputerCraftAPIClient.registerTurtleUpgradeModeller(MY_UPGRADE.get(), TurtleUpgradeModeller.flatItem())
+ * }</pre>
+ *
  * {@link TurtleUpgradeDataProvider} provides a data provider to aid with generating these JSON files.
  *
  * @param <T> The type of turtle upgrade this is responsible for serialising.
  * @see ITurtleUpgrade
  * @see TurtleUpgradeDataProvider
+ * @see TurtleUpgradeModeller
  */
-public interface TurtleUpgradeSerialiser<T extends ITurtleUpgrade> extends UpgradeSerialiser<T, TurtleUpgradeSerialiser<?>>
+public interface TurtleUpgradeSerialiser<T extends ITurtleUpgrade> extends UpgradeSerialiser<T>
 {
     /**
      * The ID for the associated registry.
      *
      * This is largely intended for use with Forge Registry methods/classes, such as {@link DeferredRegister} and
      * {@link RegistryManager#getRegistry(ResourceKey)}.
+     *
      * @see #registry()
      */
     ResourceKey<Registry<TurtleUpgradeSerialiser<?>>> REGISTRY_ID = ResourceKey.createRegistryKey( new ResourceLocation( ComputerCraft.MOD_ID, "turtle_upgrade_serialiser" ) );
 
     /**
      * The associated registry.
+     *
      * @return The registry for pocket upgrade serialisers.
      * @see #REGISTRY_ID
      */
@@ -94,7 +107,7 @@ public interface TurtleUpgradeSerialiser<T extends ITurtleUpgrade> extends Upgra
     @Nonnull
     static <T extends ITurtleUpgrade> TurtleUpgradeSerialiser<T> simple( @Nonnull Function<ResourceLocation, T> factory )
     {
-        class Impl extends SimpleSerialiser<T, TurtleUpgradeSerialiser<?>> implements TurtleUpgradeSerialiser<T>
+        class Impl extends SimpleSerialiser<T> implements TurtleUpgradeSerialiser<T>
         {
             private Impl( Function<ResourceLocation, T> constructor )
             {
@@ -117,7 +130,7 @@ public interface TurtleUpgradeSerialiser<T extends ITurtleUpgrade> extends Upgra
     @Nonnull
     static <T extends ITurtleUpgrade> TurtleUpgradeSerialiser<T> simpleWithCustomItem( @Nonnull BiFunction<ResourceLocation, ItemStack, T> factory )
     {
-        class Impl extends SerialiserWithCraftingItem<T, TurtleUpgradeSerialiser<?>> implements TurtleUpgradeSerialiser<T>
+        class Impl extends SerialiserWithCraftingItem<T> implements TurtleUpgradeSerialiser<T>
         {
             private Impl( BiFunction<ResourceLocation, ItemStack, T> factory )
             {

src/main/java/dan200/computercraft/api/upgrades/IUpgradeBase.java

@@ -68,7 +68,7 @@ public interface IUpgradeBase
      * @param stack The stack to check. This is guaranteed to be non-empty and have the same item as
      *              {@link #getCraftingItem()}.
      * @return If this stack may be used to equip this upgrade.
-     * @see net.minecraftforge.common.crafting.NBTIngredient#test(ItemStack) For the implementation of the default
+     * @see net.minecraftforge.common.crafting.StrictNBTIngredient#test(ItemStack) For the implementation of the default
      * check.
      */
     default boolean isItemSuitable( @Nonnull ItemStack stack )

src/main/java/dan200/computercraft/api/upgrades/UpgradeDataProvider.java

@@ -5,8 +5,6 @@
  */
 package dan200.computercraft.api.upgrades;
 
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParseException;
 import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
@@ -36,10 +34,9 @@ import java.util.function.Function;
  * @param <T> The base class of upgrades.
  * @param <R> The upgrade serialiser to register for.
  */
-public abstract class UpgradeDataProvider<T extends IUpgradeBase, R extends UpgradeSerialiser<?, R>> implements DataProvider
+public abstract class UpgradeDataProvider<T extends IUpgradeBase, R extends UpgradeSerialiser<? extends T>> implements DataProvider
 {
     private static final Logger LOGGER = LogManager.getLogger();
-    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
 
     private final DataGenerator generator;
     private final String name;
@@ -134,7 +131,7 @@ public abstract class UpgradeDataProvider<T extends IUpgradeBase, R extends Upgr
 
             try
             {
-                @SuppressWarnings( "unchecked" ) var result = (T) upgrade.serialiser().fromJson( upgrade.id(), json );
+                var result = upgrade.serialiser().fromJson( upgrade.id(), json );
                 upgrades.add( result );
             }
             catch( IllegalArgumentException | JsonParseException e )
@@ -176,7 +173,7 @@ public abstract class UpgradeDataProvider<T extends IUpgradeBase, R extends Upgr
      * @param serialise  Augment the generated JSON with additional fields.
      * @param <R>        The type of upgrade serialiser.
      */
-    public static record Upgrade<R extends UpgradeSerialiser<?, R>>(
+    public record Upgrade<R extends UpgradeSerialiser<?>>(
         ResourceLocation id, R serialiser, Consumer<JsonObject> serialise
     )
     {

src/main/java/dan200/computercraft/api/upgrades/UpgradeSerialiser.java

@@ -19,12 +19,11 @@ import javax.annotation.Nonnull;
  *
  * However, it may sometimes be useful to implement this if you have some shared logic between upgrade types.
  *
- * @param <R> The serialiser for this upgrade category, either {@code TurtleUpgradeSerialiser<?>} or {@code PocketUpgradeSerialiser<?>}.
  * @param <T> The upgrade that this class can serialise and deserialise.
  * @see TurtleUpgradeSerialiser
  * @see PocketUpgradeSerialiser
  */
-public interface UpgradeSerialiser<T extends IUpgradeBase, R extends UpgradeSerialiser<?, R>>
+public interface UpgradeSerialiser<T extends IUpgradeBase>
 {
     /**
      * Read this upgrade from a JSON file in a datapack.

src/main/java/dan200/computercraft/client/ClientHooks.java

@@ -10,7 +10,7 @@ import dan200.computercraft.client.sound.SpeakerManager;
 import dan200.computercraft.shared.peripheral.monitor.ClientMonitor;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.client.event.ClientPlayerNetworkEvent;
-import net.minecraftforge.event.world.WorldEvent;
+import net.minecraftforge.event.level.LevelEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
 
@@ -18,9 +18,9 @@ import net.minecraftforge.fml.common.Mod;
 public class ClientHooks
 {
     @SubscribeEvent
-    public static void onWorldUnload( WorldEvent.Unload event )
+    public static void onWorldUnload( LevelEvent.Unload event )
     {
-        if( event.getWorld().isClientSide() )
+        if( event.getLevel().isClientSide() )
         {
             ClientMonitor.destroyAll();
             SpeakerManager.reset();
@@ -28,13 +28,13 @@ public class ClientHooks
     }
 
     @SubscribeEvent
-    public static void onLogIn( ClientPlayerNetworkEvent.LoggedInEvent event )
+    public static void onLogIn( ClientPlayerNetworkEvent.LoggingIn event )
     {
         ComputerCraft.clientComputerRegistry.reset();
     }
 
     @SubscribeEvent
-    public static void onLogOut( ClientPlayerNetworkEvent.LoggedOutEvent event )
+    public static void onLogOut( ClientPlayerNetworkEvent.LoggingOut event )
     {
         ComputerCraft.clientComputerRegistry.reset();
     }

src/main/java/dan200/computercraft/client/ClientRegistry.java

@@ -6,10 +6,13 @@
 package dan200.computercraft.client;
 
 import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.api.client.ComputerCraftAPIClient;
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
 import dan200.computercraft.client.gui.*;
 import dan200.computercraft.client.render.TileEntityMonitorRenderer;
 import dan200.computercraft.client.render.TileEntityTurtleRenderer;
 import dan200.computercraft.client.render.TurtleModelLoader;
+import dan200.computercraft.client.turtle.TurtleModemModeller;
 import dan200.computercraft.shared.Registry;
 import dan200.computercraft.shared.common.IColouredItem;
 import dan200.computercraft.shared.computer.inventory.ContainerComputerBase;
@@ -19,8 +22,6 @@ import dan200.computercraft.shared.media.items.ItemTreasureDisk;
 import dan200.computercraft.shared.pocket.items.ItemPocketComputer;
 import dan200.computercraft.shared.util.Colour;
 import net.minecraft.client.gui.screens.MenuScreens;
-import net.minecraft.client.renderer.ItemBlockRenderTypes;
-import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderers;
 import net.minecraft.client.renderer.item.ItemProperties;
 import net.minecraft.client.renderer.item.ItemPropertyFunction;
@@ -28,10 +29,8 @@ import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.Item;
 import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.ColorHandlerEvent;
-import net.minecraftforge.client.event.ModelRegistryEvent;
-import net.minecraftforge.client.model.ForgeModelBakery;
-import net.minecraftforge.client.model.ModelLoaderRegistry;
+import net.minecraftforge.client.event.ModelEvent;
+import net.minecraftforge.client.event.RegisterColorHandlersEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
@@ -69,17 +68,22 @@ public final class ClientRegistry
     private ClientRegistry() {}
 
     @SubscribeEvent
-    public static void registerModels( ModelRegistryEvent event )
+    public static void registerModelLoaders( ModelEvent.RegisterGeometryLoaders event )
+    {
+        event.register( "turtle", TurtleModelLoader.INSTANCE );
+    }
+
+    @SubscribeEvent
+    public static void registerModels( ModelEvent.RegisterAdditional event )
     {
-        ModelLoaderRegistry.registerLoader( new ResourceLocation( ComputerCraft.MOD_ID, "turtle" ), TurtleModelLoader.INSTANCE );
         for( String model : EXTRA_MODELS )
         {
-            ForgeModelBakery.addSpecialModel( new ModelResourceLocation( new ResourceLocation( ComputerCraft.MOD_ID, model ), "inventory" ) );
+            event.register( new ModelResourceLocation( new ResourceLocation( ComputerCraft.MOD_ID, model ), "inventory" ) );
         }
     }
 
     @SubscribeEvent
-    public static void onItemColours( ColorHandlerEvent.Item event )
+    public static void onItemColours( RegisterColorHandlersEvent.Item event )
     {
         if( Registry.ModItems.DISK == null || Registry.ModBlocks.TURTLE_NORMAL == null )
         {
@@ -87,17 +91,17 @@ public final class ClientRegistry
             return;
         }
 
-        event.getItemColors().register(
+        event.register(
             ( stack, layer ) -> layer == 1 ? ((ItemDisk) stack.getItem()).getColour( stack ) : 0xFFFFFF,
             Registry.ModItems.DISK.get()
         );
 
-        event.getItemColors().register(
+        event.register(
             ( stack, layer ) -> layer == 1 ? ItemTreasureDisk.getColour( stack ) : 0xFFFFFF,
             Registry.ModItems.TREASURE_DISK.get()
         );
 
-        event.getItemColors().register( ( stack, layer ) -> {
+        event.register( ( stack, layer ) -> {
             switch( layer )
             {
                 case 0:
@@ -114,7 +118,7 @@ public final class ClientRegistry
         }, Registry.ModItems.POCKET_COMPUTER_NORMAL.get(), Registry.ModItems.POCKET_COMPUTER_ADVANCED.get() );
 
         // Setup turtle colours
-        event.getItemColors().register(
+        event.register(
             ( stack, tintIndex ) -> tintIndex == 0 ? ((IColouredItem) stack.getItem()).getColour( stack ) : 0xFFFFFF,
             Registry.ModBlocks.TURTLE_NORMAL.get(), Registry.ModBlocks.TURTLE_ADVANCED.get()
         );
@@ -123,20 +127,24 @@ public final class ClientRegistry
     @SubscribeEvent
     public static void setupClient( FMLClientSetupEvent event )
     {
-        // While turtles themselves are not transparent, their upgrades may be.
-        ItemBlockRenderTypes.setRenderLayer( Registry.ModBlocks.TURTLE_NORMAL.get(), RenderType.translucent() );
-        ItemBlockRenderTypes.setRenderLayer( Registry.ModBlocks.TURTLE_ADVANCED.get(), RenderType.translucent() );
-
-        // Monitors' textures have transparent fronts and so count as cutouts.
-        ItemBlockRenderTypes.setRenderLayer( Registry.ModBlocks.MONITOR_NORMAL.get(), RenderType.cutout() );
-        ItemBlockRenderTypes.setRenderLayer( Registry.ModBlocks.MONITOR_ADVANCED.get(), RenderType.cutout() );
-
         // Setup TESRs
         BlockEntityRenderers.register( Registry.ModBlockEntities.MONITOR_NORMAL.get(), TileEntityMonitorRenderer::new );
         BlockEntityRenderers.register( Registry.ModBlockEntities.MONITOR_ADVANCED.get(), TileEntityMonitorRenderer::new );
         BlockEntityRenderers.register( Registry.ModBlockEntities.TURTLE_NORMAL.get(), TileEntityTurtleRenderer::new );
         BlockEntityRenderers.register( Registry.ModBlockEntities.TURTLE_ADVANCED.get(), TileEntityTurtleRenderer::new );
 
+        ComputerCraftAPIClient.registerTurtleUpgradeModeller( Registry.ModTurtleSerialisers.SPEAKER.get(), TurtleUpgradeModeller.sided(
+            new ModelResourceLocation( "computercraft:turtle_speaker_upgrade_left", "inventory" ),
+            new ModelResourceLocation( "computercraft:turtle_speaker_upgrade_right", "inventory" )
+        ) );
+        ComputerCraftAPIClient.registerTurtleUpgradeModeller( Registry.ModTurtleSerialisers.WORKBENCH.get(), TurtleUpgradeModeller.sided(
+            new ModelResourceLocation( "computercraft:turtle_crafting_table_left", "inventory" ),
+            new ModelResourceLocation( "computercraft:turtle_crafting_table_right", "inventory" )
+        ) );
+        ComputerCraftAPIClient.registerTurtleUpgradeModeller( Registry.ModTurtleSerialisers.WIRELESS_MODEM_NORMAL.get(), new TurtleModemModeller( false ) );
+        ComputerCraftAPIClient.registerTurtleUpgradeModeller( Registry.ModTurtleSerialisers.WIRELESS_MODEM_ADVANCED.get(), new TurtleModemModeller( true ) );
+        ComputerCraftAPIClient.registerTurtleUpgradeModeller( Registry.ModTurtleSerialisers.TOOL.get(), TurtleUpgradeModeller.flatItem() );
+
         event.enqueueWork( () -> {
             registerContainers();
 

src/main/java/dan200/computercraft/client/ClientTableFormatter.java

@@ -8,8 +8,8 @@ package dan200.computercraft.client;
 import dan200.computercraft.shared.command.text.ChatHelpers;
 import dan200.computercraft.shared.command.text.TableBuilder;
 import dan200.computercraft.shared.command.text.TableFormatter;
-import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
 import net.minecraft.ChatFormatting;
+import net.minecraft.client.GuiMessageTag;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.Font;
 import net.minecraft.client.gui.components.ChatComponent;
@@ -18,13 +18,12 @@ import net.minecraft.util.Mth;
 import org.apache.commons.lang3.StringUtils;
 
 import javax.annotation.Nullable;
+import java.util.Objects;
 
 public class ClientTableFormatter implements TableFormatter
 {
     public static final ClientTableFormatter INSTANCE = new ClientTableFormatter();
 
-    private static final Int2IntOpenHashMap lastHeights = new Int2IntOpenHashMap();
-
     private static Font renderer()
     {
         return Minecraft.getInstance().font;
@@ -59,7 +58,7 @@ public class ClientTableFormatter implements TableFormatter
     }
 
     @Override
-    public void writeLine( int id, Component component )
+    public void writeLine( String label, Component component )
     {
         Minecraft mc = Minecraft.getInstance();
         ChatComponent chat = mc.gui.getChat();
@@ -68,20 +67,25 @@ public class ClientTableFormatter implements TableFormatter
         // int maxWidth = MathHelper.floor( chat.getChatWidth() / chat.getScale() );
         // List<ITextProperties> list = RenderComponentsUtil.wrapComponents( component, maxWidth, mc.fontRenderer );
         // if( !list.isEmpty() ) chat.printChatMessageWithOptionalDeletion( list.get( 0 ), id );
-        chat.addMessage( component, id );
+        chat.addMessage( component, null, createTag( label ) );
     }
 
     @Override
-    public int display( TableBuilder table )
+    public void display( TableBuilder table )
     {
         ChatComponent chat = Minecraft.getInstance().gui.getChat();
 
-        int lastHeight = lastHeights.get( table.getId() );
+        var tag = createTag( table.getId() );
+        if( chat.allMessages.removeIf( guiMessage -> guiMessage.tag() != null && Objects.equals( guiMessage.tag().logTag(), tag.logTag() ) ) )
+        {
+            chat.refreshTrimmedMessage();
+        }
 
-        int height = TableFormatter.super.display( table );
-        lastHeights.put( table.getId(), height );
+        TableFormatter.super.display( table );
+    }
 
-        for( int i = height; i < lastHeight; i++ ) chat.removeById( i + table.getId() );
-        return height;
+    private static GuiMessageTag createTag( String id )
+    {
+        return new GuiMessageTag( 0xa0a0a0, null, null, "ComputerCraft/" + id );
     }
 }

src/main/java/dan200/computercraft/client/ComputerCraftAPIClientImpl.java

@@ -0,0 +1,29 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+package dan200.computercraft.client;
+
+import dan200.computercraft.api.client.ComputerCraftAPIClient;
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
+import dan200.computercraft.client.turtle.TurtleUpgradeModellers;
+
+import javax.annotation.Nonnull;
+
+public final class ComputerCraftAPIClientImpl implements ComputerCraftAPIClient.IComputerCraftAPIClient
+{
+    public static final ComputerCraftAPIClientImpl INSTANCE = new ComputerCraftAPIClientImpl();
+
+    private ComputerCraftAPIClientImpl()
+    {
+    }
+
+    @Override
+    public <T extends ITurtleUpgrade> void registerTurtleUpgradeModeller( @Nonnull TurtleUpgradeSerialiser<T> serialiser, @Nonnull TurtleUpgradeModeller<T> modeller )
+    {
+        TurtleUpgradeModellers.register( serialiser, modeller );
+    }
+}

src/main/java/dan200/computercraft/client/gui/GuiPrintout.java

@@ -8,7 +8,6 @@ package dan200.computercraft.client.gui;
 import com.mojang.blaze3d.systems.RenderSystem;
 import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.blaze3d.vertex.Tesselator;
-import com.mojang.math.Matrix4f;
 import dan200.computercraft.core.terminal.TextBuffer;
 import dan200.computercraft.shared.common.ContainerHeldItem;
 import dan200.computercraft.shared.media.items.ItemPrintout;
@@ -99,9 +98,8 @@ public class GuiPrintout extends AbstractContainerScreen<ContainerHeldItem>
         RenderSystem.enableDepthTest();
 
         MultiBufferSource.BufferSource renderer = MultiBufferSource.immediate( Tesselator.getInstance().getBuilder() );
-        Matrix4f matrix = transform.last().pose();
-        drawBorder( matrix, renderer, leftPos, topPos, getBlitOffset(), page, pages, book, FULL_BRIGHT_LIGHTMAP );
-        drawText( matrix, renderer, leftPos + X_TEXT_MARGIN, topPos + Y_TEXT_MARGIN, ItemPrintout.LINES_PER_PAGE * page, FULL_BRIGHT_LIGHTMAP, text, colours );
+        drawBorder( transform, renderer, leftPos, topPos, getBlitOffset(), page, pages, book, FULL_BRIGHT_LIGHTMAP );
+        drawText( transform, renderer, leftPos + X_TEXT_MARGIN, topPos + Y_TEXT_MARGIN, ItemPrintout.LINES_PER_PAGE * page, FULL_BRIGHT_LIGHTMAP, text, colours );
         renderer.endBatch();
     }
 

src/main/java/dan200/computercraft/client/gui/widgets/WidgetTerminal.java

@@ -7,7 +7,6 @@ package dan200.computercraft.client.gui.widgets;
 
 import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.blaze3d.vertex.Tesselator;
-import com.mojang.math.Matrix4f;
 import dan200.computercraft.client.render.RenderTypes;
 import dan200.computercraft.client.render.text.FixedWidthFontRenderer;
 import dan200.computercraft.core.terminal.Terminal;
@@ -316,11 +315,10 @@ public class WidgetTerminal extends AbstractWidget
     public void render( @Nonnull PoseStack transform, int mouseX, int mouseY, float partialTicks )
     {
         if( !visible ) return;
-        Matrix4f matrix = transform.last().pose();
         Terminal terminal = computer.getTerminal();
 
         var bufferSource = MultiBufferSource.immediate( Tesselator.getInstance().getBuilder() );
-        var emitter = FixedWidthFontRenderer.toVertexConsumer( matrix, bufferSource.getBuffer( RenderTypes.TERMINAL_WITH_DEPTH ) );
+        var emitter = FixedWidthFontRenderer.toVertexConsumer( transform, bufferSource.getBuffer( RenderTypes.TERMINAL ) );
 
         if( terminal != null )
         {

src/main/java/dan200/computercraft/client/render/CableHighlightRenderer.java

@@ -23,7 +23,7 @@ import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.Vec3;
 import net.minecraft.world.phys.shapes.VoxelShape;
 import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.DrawSelectionEvent;
+import net.minecraftforge.client.event.RenderHighlightEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
 
@@ -41,7 +41,7 @@ public final class CableHighlightRenderer
      * @see net.minecraft.client.renderer.LevelRenderer#renderHitOutline
      */
     @SubscribeEvent
-    public static void drawHighlight( DrawSelectionEvent.HighlightBlock event )
+    public static void drawHighlight( RenderHighlightEvent.Block event )
     {
         BlockHitResult hit = event.getTarget();
         BlockPos pos = hit.getBlockPos();

src/main/java/dan200/computercraft/client/render/DebugOverlay.java

@@ -15,7 +15,7 @@ import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
 import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.RenderGameOverlayEvent;
+import net.minecraftforge.client.event.CustomizeGuiOverlayEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
 
@@ -25,7 +25,7 @@ import java.util.List;
 public class DebugOverlay
 {
     @SubscribeEvent
-    public static void onRenderText( RenderGameOverlayEvent.Text event )
+    public static void onRenderText( CustomizeGuiOverlayEvent.DebugText event )
     {
         Minecraft minecraft = Minecraft.getInstance();
         if( !minecraft.options.renderDebug || minecraft.level == null ) return;

src/main/java/dan200/computercraft/client/render/ItemPocketRenderer.java

@@ -96,23 +96,19 @@ public final class ItemPocketRenderer extends ItemMapLikeRenderer
         // Render the light
         int lightColour = ItemPocketComputer.getLightState( stack );
         if( lightColour == -1 ) lightColour = Colour.BLACK.getHex();
-        renderLight( matrix, bufferSource, lightColour, width, height );
+        renderLight( transform, bufferSource, lightColour, width, height );
 
         if( computer != null && terminal != null )
         {
             FixedWidthFontRenderer.drawTerminal(
-                FixedWidthFontRenderer.toVertexConsumer( matrix, bufferSource.getBuffer( RenderTypes.TERMINAL_WITHOUT_DEPTH ) ),
+                FixedWidthFontRenderer.toVertexConsumer( transform, bufferSource.getBuffer( RenderTypes.TERMINAL ) ),
                 MARGIN, MARGIN, terminal, !computer.isColour(), MARGIN, MARGIN, MARGIN, MARGIN
             );
-            FixedWidthFontRenderer.drawBlocker(
-                FixedWidthFontRenderer.toVertexConsumer( matrix, bufferSource.getBuffer( RenderTypes.TERMINAL_BLOCKER ) ),
-                0, 0, width, height
-            );
         }
         else
         {
             FixedWidthFontRenderer.drawEmptyTerminal(
-                FixedWidthFontRenderer.toVertexConsumer( matrix, bufferSource.getBuffer( RenderTypes.TERMINAL_WITH_DEPTH ) ),
+                FixedWidthFontRenderer.toVertexConsumer( transform, bufferSource.getBuffer( RenderTypes.TERMINAL ) ),
                 0, 0, width, height
             );
         }
@@ -131,14 +127,14 @@ public final class ItemPocketRenderer extends ItemMapLikeRenderer
         ComputerBorderRenderer.render( transform, render.getBuffer( ComputerBorderRenderer.getRenderType( texture ) ), 0, 0, 0, light, width, height, true, r, g, b );
     }
 
-    private static void renderLight( Matrix4f transform, MultiBufferSource render, int colour, int width, int height )
+    private static void renderLight( PoseStack transform, MultiBufferSource render, int colour, int width, int height )
     {
         byte r = (byte) ((colour >>> 16) & 0xFF);
         byte g = (byte) ((colour >>> 8) & 0xFF);
         byte b = (byte) (colour & 0xFF);
         byte[] c = new byte[] { r, g, b, (byte) 255 };
 
-        VertexConsumer buffer = render.getBuffer( RenderTypes.TERMINAL_WITH_DEPTH );
+        VertexConsumer buffer = render.getBuffer( RenderTypes.TERMINAL );
         FixedWidthFontRenderer.drawQuad(
             FixedWidthFontRenderer.toVertexConsumer( transform, buffer ),
             width - LIGHT_HEIGHT * 2, height + BORDER / 2.0f, 0.001f, LIGHT_HEIGHT * 2, LIGHT_HEIGHT,

src/main/java/dan200/computercraft/client/render/ItemPrintoutRenderer.java

@@ -6,7 +6,6 @@
 package dan200.computercraft.client.render;
 
 import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.math.Matrix4f;
 import com.mojang.math.Vector3f;
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.shared.media.items.ItemPrintout;
@@ -106,10 +105,9 @@ public final class ItemPrintoutRenderer extends ItemMapLikeRenderer
         transform.scale( scale, scale, scale );
         transform.translate( (max - width) / 2.0, (max - height) / 2.0, 0.0 );
 
-        Matrix4f matrix = transform.last().pose();
-        drawBorder( matrix, render, 0, 0, -0.01f, 0, pages, book, light );
+        drawBorder( transform, render, 0, 0, -0.01f, 0, pages, book, light );
         drawText(
-            matrix, render, X_TEXT_MARGIN, Y_TEXT_MARGIN, 0, light,
+            transform, render, X_TEXT_MARGIN, Y_TEXT_MARGIN, 0, light,
             ItemPrintout.getText( stack ), ItemPrintout.getColours( stack )
         );
     }

src/main/java/dan200/computercraft/client/render/MonitorHighlightRenderer.java

@@ -18,7 +18,7 @@ import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.phys.Vec3;
 import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.DrawSelectionEvent;
+import net.minecraftforge.client.event.RenderHighlightEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
 
@@ -38,7 +38,7 @@ public final class MonitorHighlightRenderer
     }
 
     @SubscribeEvent
-    public static void drawHighlight( DrawSelectionEvent.HighlightBlock event )
+    public static void drawHighlight( RenderHighlightEvent.Block event )
     {
         // Preserve normal behaviour when crouching.
         if( event.getCamera().getEntity().isCrouching() ) return;

src/main/java/dan200/computercraft/client/render/PrintoutRenderer.java

@@ -5,6 +5,7 @@
  */
 package dan200.computercraft.client.render;
 
+import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.blaze3d.vertex.VertexConsumer;
 import com.mojang.math.Matrix4f;
 import dan200.computercraft.client.render.text.FixedWidthFontRenderer;
@@ -54,7 +55,7 @@ public final class PrintoutRenderer
 
     private PrintoutRenderer() {}
 
-    public static void drawText( Matrix4f transform, MultiBufferSource bufferSource, int x, int y, int start, int light, TextBuffer[] text, TextBuffer[] colours )
+    public static void drawText( PoseStack transform, MultiBufferSource bufferSource, int x, int y, int start, int light, TextBuffer[] text, TextBuffer[] colours )
     {
         var buffer = bufferSource.getBuffer( RenderTypes.PRINTOUT_TEXT );
         var emitter = FixedWidthFontRenderer.toVertexConsumer( transform, buffer );
@@ -67,7 +68,7 @@ public final class PrintoutRenderer
         }
     }
 
-    public static void drawText( Matrix4f transform, MultiBufferSource bufferSource, int x, int y, int start, int light, String[] text, String[] colours )
+    public static void drawText( PoseStack transform, MultiBufferSource bufferSource, int x, int y, int start, int light, String[] text, String[] colours )
     {
         var buffer = bufferSource.getBuffer( RenderTypes.PRINTOUT_TEXT );
         var emitter = FixedWidthFontRenderer.toVertexConsumer( transform, buffer );
@@ -81,8 +82,9 @@ public final class PrintoutRenderer
         }
     }
 
-    public static void drawBorder( Matrix4f transform, MultiBufferSource bufferSource, float x, float y, float z, int page, int pages, boolean isBook, int light )
+    public static void drawBorder( PoseStack transform, MultiBufferSource bufferSource, float x, float y, float z, int page, int pages, boolean isBook, int light )
     {
+        var matrix = transform.last().pose();
         int leftPages = page;
         int rightPages = pages - page - 1;
 
@@ -96,11 +98,11 @@ public final class PrintoutRenderer
             float right = x + X_SIZE + offset - 4;
 
             // Left and right border
-            drawTexture( transform, buffer, left - 4, y - 8, z - 0.02f, COVER_X, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2, light );
-            drawTexture( transform, buffer, right, y - 8, z - 0.02f, COVER_X + COVER_SIZE, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2, light );
+            drawTexture( matrix, buffer, left - 4, y - 8, z - 0.02f, COVER_X, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2, light );
+            drawTexture( matrix, buffer, right, y - 8, z - 0.02f, COVER_X + COVER_SIZE, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2, light );
 
             // Draw centre panel (just stretched texture, sorry).
-            drawTexture( transform, buffer,
+            drawTexture( matrix, buffer,
                 x - offset, y, z - 0.02f, X_SIZE + offset * 2, Y_SIZE,
                 COVER_X + COVER_SIZE / 2.0f, COVER_SIZE, COVER_SIZE, Y_SIZE,
                 light
@@ -110,17 +112,20 @@ public final class PrintoutRenderer
             while( borderX < right )
             {
                 double thisWidth = Math.min( right - borderX, X_SIZE );
-                drawTexture( transform, buffer, borderX, y - 8, z - 0.02f, 0, COVER_Y, (float) thisWidth, COVER_SIZE, light );
-                drawTexture( transform, buffer, borderX, y + Y_SIZE - 4, z - 0.02f, 0, COVER_Y + COVER_SIZE, (float) thisWidth, COVER_SIZE, light );
+                drawTexture( matrix, buffer, borderX, y - 8, z - 0.02f, 0, COVER_Y, (float) thisWidth, COVER_SIZE, light );
+                drawTexture( matrix, buffer, borderX, y + Y_SIZE - 4, z - 0.02f, 0, COVER_Y + COVER_SIZE, (float) thisWidth, COVER_SIZE, light );
                 borderX += thisWidth;
             }
         }
 
-        // Left half
-        drawTexture( transform, buffer, x, y, z, X_FOLD_SIZE * 2, 0, X_SIZE / 2.0f, Y_SIZE, light );
+        // Current page background: Z-offset is interleaved between the "zeroth" left/right page and the first
+        // left/right page, so that the "bold" border can be drawn over the edge where appropriate.
+        drawTexture( matrix, buffer, x, y, z - 1e-3f * 0.5f, X_FOLD_SIZE * 2, 0, X_SIZE, Y_SIZE, light );
+
+        // Left pages
         for( int n = 0; n <= leftPages; n++ )
         {
-            drawTexture( transform, buffer,
+            drawTexture( matrix, buffer,
                 x - offsetAt( n ), y, z - 1e-3f * n,
                 // Use the left "bold" fold for the outermost page
                 n == leftPages ? 0 : X_FOLD_SIZE, 0,
@@ -128,11 +133,10 @@ public final class PrintoutRenderer
             );
         }
 
-        // Right half
-        drawTexture( transform, buffer, x + X_SIZE / 2.0f, y, z, X_FOLD_SIZE * 2 + X_SIZE / 2.0f, 0, X_SIZE / 2.0f, Y_SIZE, light );
+        // Right pages
         for( int n = 0; n <= rightPages; n++ )
         {
-            drawTexture( transform, buffer,
+            drawTexture( matrix, buffer,
                 x + (X_SIZE - X_FOLD_SIZE) + offsetAt( n ), y, z - 1e-3f * n,
                 // Two folds, then the main page. Use the right "bold" fold for the outermost page.
                 X_FOLD_SIZE * 2 + X_SIZE + (n == rightPages ? X_FOLD_SIZE : 0), 0,

src/main/java/dan200/computercraft/client/render/RenderTypes.java

@@ -30,24 +30,9 @@ public class RenderTypes
     private static MonitorTextureBufferShader monitorTboShader;
 
     /**
-     * Renders a fullbright terminal without writing to the depth layer. This is used in combination with
-     * {@link #TERMINAL_BLOCKER} to ensure we can render a terminal without z-fighting.
+     * Renders a fullbright terminal.
      */
-    public static final RenderType TERMINAL_WITHOUT_DEPTH = Types.TERMINAL_WITHOUT_DEPTH;
-
-    /**
-     * A transparent texture which only writes to the depth layer.
-     */
-    public static final RenderType TERMINAL_BLOCKER = Types.TERMINAL_BLOCKER;
-
-    /**
-     * Renders a fullbright terminal which also writes to the depth layer. This is used when z-fighting isn't an issue -
-     * for instance rendering an empty terminal or inside a GUI.
-     *
-     * This is identical to <em>vanilla's</em> {@link RenderType#text}. Forge overrides one with a definition which sets
-     * sortOnUpload to true, which is entirely broken!
-     */
-    public static final RenderType TERMINAL_WITH_DEPTH = Types.TERMINAL_WITH_DEPTH;
+    public static final RenderType TERMINAL = RenderType.text( FixedWidthFontRenderer.FONT );
 
     /**
      * Renders a monitor with the TBO shader.
@@ -57,7 +42,7 @@ public class RenderTypes
     public static final RenderType MONITOR_TBO = Types.MONITOR_TBO;
 
     /**
-     * A variant of {@link #TERMINAL_WITH_DEPTH} which uses the lightmap rather than rendering fullbright.
+     * A variant of {@link #TERMINAL} which uses the lightmap rather than rendering fullbright.
      */
     public static final RenderType PRINTOUT_TEXT = RenderType.text( FixedWidthFontRenderer.FONT );
 
@@ -77,7 +62,7 @@ public class RenderTypes
     @Nonnull
     static ShaderInstance getTerminalShader()
     {
-        return GameRenderer.getPositionColorTexShader();
+        return GameRenderer.getRendertypeTextShader();
     }
 
     @SubscribeEvent
@@ -99,8 +84,6 @@ public class RenderTypes
             FixedWidthFontRenderer.FONT,
             false, false // blur, minimap
         );
-        private static final VertexFormat TERM_FORMAT = DefaultVertexFormat.POSITION_COLOR_TEX;
-        private static final ShaderStateShard TERM_SHADER = new ShaderStateShard( RenderTypes::getTerminalShader );
 
         static final RenderType MONITOR_TBO = RenderType.create(
             "monitor_tbo", DefaultVertexFormat.POSITION_TEX, VertexFormat.Mode.TRIANGLE_STRIP, 128,
@@ -111,36 +94,6 @@ public class RenderTypes
                 .createCompositeState( false )
         );
 
-        static final RenderType TERMINAL_WITHOUT_DEPTH = RenderType.create(
-            "terminal_without_depth", TERM_FORMAT, VertexFormat.Mode.QUADS, 1024,
-            false, false, // useDelegate, needsSorting
-            RenderType.CompositeState.builder()
-                .setTextureState( TERM_FONT_TEXTURE )
-                .setShaderState( TERM_SHADER )
-                .setLightmapState( LIGHTMAP )
-                .setWriteMaskState( COLOR_WRITE )
-                .createCompositeState( false )
-        );
-
-        static final RenderType TERMINAL_BLOCKER = RenderType.create(
-            "terminal_blocker", DefaultVertexFormat.POSITION, VertexFormat.Mode.QUADS, 256,
-            false, false, // useDelegate, needsSorting
-            RenderType.CompositeState.builder()
-                .setShaderState( POSITION_SHADER )
-                .setWriteMaskState( DEPTH_WRITE )
-                .createCompositeState( false )
-        );
-
-        static final RenderType TERMINAL_WITH_DEPTH = RenderType.create(
-            "terminal_with_depth", TERM_FORMAT, VertexFormat.Mode.QUADS, 1024,
-            false, false, // useDelegate, needsSorting
-            RenderType.CompositeState.builder()
-                .setTextureState( TERM_FONT_TEXTURE )
-                .setShaderState( TERM_SHADER )
-                .setLightmapState( LIGHTMAP )
-                .createCompositeState( false )
-        );
-
         private Types( String name, Runnable setup, Runnable destroy )
         {
             super( name, setup, destroy );

src/main/java/dan200/computercraft/client/render/TileEntityMonitorRenderer.java

@@ -8,8 +8,11 @@ package dan200.computercraft.client.render;
 import com.mojang.blaze3d.platform.GlStateManager;
 import com.mojang.blaze3d.platform.MemoryTracker;
 import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.BufferBuilder;
 import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.Tesselator;
 import com.mojang.blaze3d.vertex.VertexConsumer;
+import com.mojang.math.Matrix3f;
 import com.mojang.math.Matrix4f;
 import com.mojang.math.Vector3f;
 import dan200.computercraft.ComputerCraft;
@@ -17,13 +20,15 @@ import dan200.computercraft.client.FrameInfo;
 import dan200.computercraft.client.render.text.DirectFixedWidthFontRenderer;
 import dan200.computercraft.client.render.text.FixedWidthFontRenderer;
 import dan200.computercraft.client.util.DirectBuffers;
+import dan200.computercraft.client.util.DirectVertexBuffer;
 import dan200.computercraft.core.terminal.Terminal;
+import dan200.computercraft.shared.integration.ShaderMod;
 import dan200.computercraft.shared.peripheral.monitor.ClientMonitor;
 import dan200.computercraft.shared.peripheral.monitor.MonitorRenderer;
 import dan200.computercraft.shared.peripheral.monitor.TileMonitor;
 import dan200.computercraft.shared.util.DirectionUtil;
+import net.minecraft.Util;
 import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderer;
 import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
 import net.minecraft.core.BlockPos;
@@ -34,6 +39,7 @@ import org.lwjgl.opengl.GL31;
 
 import javax.annotation.Nonnull;
 import java.nio.ByteBuffer;
+import java.util.function.Consumer;
 
 import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_HEIGHT;
 import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_WIDTH;
@@ -45,6 +51,9 @@ public class TileEntityMonitorRenderer implements BlockEntityRenderer<TileMonito
      * the monitor frame and contents.
      */
     private static final float MARGIN = (float) (TileMonitor.RENDER_MARGIN * 1.1);
+
+    private static final Matrix3f IDENTITY_NORMAL = Util.make( new Matrix3f(), Matrix3f::setIdentity );
+
     private static ByteBuffer backingBuffer;
 
     public TileEntityMonitorRenderer( BlockEntityRendererProvider.Context context )
@@ -101,7 +110,7 @@ public class TileEntityMonitorRenderer implements BlockEntityRenderer<TileMonito
 
         // Draw the contents
         Terminal terminal = originTerminal.getTerminal();
-        if( terminal != null )
+        if( terminal != null && !ShaderMod.INSTANCE.isRenderingShadowPass() )
         {
             // Draw a terminal
             int width = terminal.getWidth(), height = terminal.getHeight();
@@ -113,14 +122,14 @@ public class TileEntityMonitorRenderer implements BlockEntityRenderer<TileMonito
 
             Matrix4f matrix = transform.last().pose();
 
-            renderTerminal( bufferSource, matrix, originTerminal, (float) (MARGIN / xScale), (float) (MARGIN / yScale) );
+            renderTerminal( matrix, originTerminal, (float) (MARGIN / xScale), (float) (MARGIN / yScale) );
 
             transform.popPose();
         }
         else
         {
             FixedWidthFontRenderer.drawEmptyTerminal(
-                FixedWidthFontRenderer.toVertexConsumer( transform.last().pose(), bufferSource.getBuffer( RenderTypes.TERMINAL_WITH_DEPTH ) ),
+                FixedWidthFontRenderer.toVertexConsumer( transform, bufferSource.getBuffer( RenderTypes.TERMINAL ) ),
                 -MARGIN, MARGIN,
                 (float) (xSize + 2 * MARGIN), (float) -(ySize + MARGIN * 2)
             );
@@ -129,7 +138,7 @@ public class TileEntityMonitorRenderer implements BlockEntityRenderer<TileMonito
         transform.popPose();
     }
 
-    private static void renderTerminal( @Nonnull MultiBufferSource bufferSource, Matrix4f matrix, ClientMonitor monitor, float xMargin, float yMargin )
+    private static void renderTerminal( Matrix4f matrix, ClientMonitor monitor, float xMargin, float yMargin )
     {
         Terminal terminal = monitor.getTerminal();
         int width = terminal.getWidth(), height = terminal.getHeight();
@@ -163,59 +172,81 @@ public class TileEntityMonitorRenderer implements BlockEntityRenderer<TileMonito
                 MonitorTextureBufferShader shader = RenderTypes.getMonitorTextureBufferShader();
                 shader.setupUniform( monitor.tboUniform );
 
-                VertexConsumer buffer = bufferSource.getBuffer( RenderTypes.MONITOR_TBO );
+                BufferBuilder buffer = Tesselator.getInstance().getBuilder();
+                buffer.begin( RenderTypes.MONITOR_TBO.mode(), RenderTypes.MONITOR_TBO.format() );
                 tboVertex( buffer, matrix, -xMargin, -yMargin );
                 tboVertex( buffer, matrix, -xMargin, pixelHeight + yMargin );
                 tboVertex( buffer, matrix, pixelWidth + xMargin, -yMargin );
                 tboVertex( buffer, matrix, pixelWidth + xMargin, pixelHeight + yMargin );
+                RenderTypes.MONITOR_TBO.end( buffer, 0, 0, 0 );
 
                 break;
             }
 
             case VBO:
             {
-                var vbo = monitor.buffer;
+                var backgroundBuffer = monitor.backgroundBuffer;
+                var foregroundBuffer = monitor.foregroundBuffer;
                 if( redraw )
                 {
-                    int vertexSize = RenderTypes.TERMINAL_WITHOUT_DEPTH.format().getVertexSize();
-                    ByteBuffer buffer = getBuffer( DirectFixedWidthFontRenderer.getVertexCount( terminal ) * vertexSize );
+                    int size = DirectFixedWidthFontRenderer.getVertexCount( terminal );
 
-                    // Draw the main terminal and store how many vertices it has.
-                    DirectFixedWidthFontRenderer.drawTerminalWithoutCursor(
-                        buffer, 0, 0, terminal, !monitor.isColour(), yMargin, yMargin, xMargin, xMargin
-                    );
-                    int termIndexes = buffer.position() / vertexSize;
+                    // In an ideal world we could upload these both into one buffer. However, we can't render VBOs with
+                    // and starting and ending offset, and so need to use two buffers instead.
 
-                    // If the cursor is visible, we append it to the end of our buffer. When rendering, we can either
-                    // render n or n+1 quads and so toggle the cursor on and off.
-                    DirectFixedWidthFontRenderer.drawCursor( buffer, 0, 0, terminal, !monitor.isColour() );
+                    renderToBuffer( backgroundBuffer, size, sink ->
+                        DirectFixedWidthFontRenderer.drawTerminalBackground( sink, 0, 0, terminal, !monitor.isColour(), yMargin, yMargin, xMargin, xMargin ) );
 
-                    buffer.flip();
-
-                    vbo.upload( termIndexes, RenderTypes.TERMINAL_WITHOUT_DEPTH.mode(), RenderTypes.TERMINAL_WITHOUT_DEPTH.format(), buffer );
+                    renderToBuffer( foregroundBuffer, size, sink -> {
+                        DirectFixedWidthFontRenderer.drawTerminalForeground( sink, 0, 0, terminal, !monitor.isColour() );
+                        // If the cursor is visible, we append it to the end of our buffer. When rendering, we can either
+                        // render n or n+1 quads and so toggle the cursor on and off.
+                        DirectFixedWidthFontRenderer.drawCursor( sink, 0, 0, terminal, !monitor.isColour() );
+                    } );
                 }
 
-                bufferSource.getBuffer( RenderTypes.TERMINAL_WITHOUT_DEPTH );
-                RenderTypes.TERMINAL_WITHOUT_DEPTH.setupRenderState();
+                // Our VBO doesn't transform its vertices with the provided pose stack, which means that the inverse view
+                // rotation matrix gives entirely wrong numbers for fog distances. We just set it to the identity which
+                // gives a good enough approximation.
+                Matrix3f oldInverseRotation = RenderSystem.getInverseViewRotationMatrix();
+                RenderSystem.setInverseViewRotationMatrix( IDENTITY_NORMAL );
 
-                vbo.drawWithShader(
+                RenderTypes.TERMINAL.setupRenderState();
+
+                // Render background geometry
+                backgroundBuffer.drawWithShader( matrix, RenderSystem.getProjectionMatrix(), RenderTypes.getTerminalShader() );
+
+                // Render foreground geometry with glPolygonOffset enabled.
+                GL11.glPolygonOffset( -1.0f, -10.0f );
+                GL11.glEnable( GL11.GL_POLYGON_OFFSET_FILL );
+                foregroundBuffer.drawWithShader(
                     matrix, RenderSystem.getProjectionMatrix(), RenderTypes.getTerminalShader(),
                     // As mentioned in the above comment, render the extra cursor quad if it is visible this frame. Each
                     // // quad has an index count of 6.
-                    FixedWidthFontRenderer.isCursorVisible( terminal ) && FrameInfo.getGlobalCursorBlink() ? vbo.getIndexCount() + 6 : vbo.getIndexCount()
+                    FixedWidthFontRenderer.isCursorVisible( terminal ) && FrameInfo.getGlobalCursorBlink()
+                        ? foregroundBuffer.getIndexCount() + 6 : foregroundBuffer.getIndexCount()
                 );
 
-                FixedWidthFontRenderer.drawBlocker(
-                    FixedWidthFontRenderer.toVertexConsumer( matrix, bufferSource.getBuffer( RenderTypes.TERMINAL_BLOCKER ) ),
-                    -xMargin, -yMargin, pixelWidth + xMargin, pixelHeight + yMargin
-                );
+                // Clear state
+                GL11.glPolygonOffset( 0.0f, -0.0f );
+                GL11.glDisable( GL11.GL_POLYGON_OFFSET_FILL );
+                RenderTypes.TERMINAL.clearRenderState();
+
+                RenderSystem.setInverseViewRotationMatrix( oldInverseRotation );
+
                 break;
             }
         }
+    }
 
-        // Force a flush of the buffer. WorldRenderer.updateCameraAndRender will "finish" all the built-in buffers
-        // before calling renderer.finish, which means our TBO quad or depth blocker won't be rendered yet!
-        bufferSource.getBuffer( RenderType.solid() );
+    private static void renderToBuffer( DirectVertexBuffer vbo, int size, Consumer<DirectFixedWidthFontRenderer.QuadEmitter> draw )
+    {
+        var sink = ShaderMod.INSTANCE.getQuadEmitter( size, TileEntityMonitorRenderer::getBuffer );
+        var buffer = sink.buffer();
+
+        draw.accept( sink );
+        buffer.flip();
+        vbo.upload( buffer.limit() / sink.format().getVertexSize(), RenderTypes.TERMINAL.mode(), sink.format(), buffer );
     }
 
     private static void tboVertex( VertexConsumer builder, Matrix4f matrix, float x, float y )

src/main/java/dan200/computercraft/client/render/TileEntityTurtleRenderer.java

@@ -12,6 +12,7 @@ import com.mojang.math.Vector3f;
 import dan200.computercraft.api.client.TransformedModel;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.client.turtle.TurtleUpgradeModellers;
 import dan200.computercraft.shared.computer.core.ComputerFamily;
 import dan200.computercraft.shared.turtle.blocks.TileTurtle;
 import dan200.computercraft.shared.util.DirectionUtil;
@@ -34,7 +35,7 @@ import net.minecraft.util.RandomSource;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
 import net.minecraft.world.phys.Vec3;
-import net.minecraftforge.client.model.data.EmptyModelData;
+import net.minecraftforge.client.model.data.ModelData;
 
 import javax.annotation.Nonnull;
 import java.util.List;
@@ -148,7 +149,7 @@ public class TileEntityTurtleRenderer implements BlockEntityRenderer<TileTurtle>
         transform.mulPose( Vector3f.XN.rotationDegrees( toolAngle ) );
         transform.translate( 0.0f, -0.5f, -0.5f );
 
-        TransformedModel model = upgrade.getModel( turtle.getAccess(), side );
+        TransformedModel model = TurtleUpgradeModellers.getModel( upgrade, turtle.getAccess(), side );
         model.getMatrix().push( transform );
         renderModel( transform, renderer, lightmapCoord, overlayLight, model.getModel(), null );
         transform.popPose();
@@ -165,10 +166,10 @@ public class TileEntityTurtleRenderer implements BlockEntityRenderer<TileTurtle>
     private void renderModel( @Nonnull PoseStack transform, @Nonnull VertexConsumer renderer, int lightmapCoord, int overlayLight, BakedModel model, int[] tints )
     {
         random.setSeed( 0 );
-        renderQuads( transform, renderer, lightmapCoord, overlayLight, model.getQuads( null, null, random, EmptyModelData.INSTANCE ), tints );
+        renderQuads( transform, renderer, lightmapCoord, overlayLight, model.getQuads( null, null, random, ModelData.EMPTY, null ), tints );
         for( Direction facing : DirectionUtil.FACINGS )
         {
-            renderQuads( transform, renderer, lightmapCoord, overlayLight, model.getQuads( null, facing, random, EmptyModelData.INSTANCE ), tints );
+            renderQuads( transform, renderer, lightmapCoord, overlayLight, model.getQuads( null, facing, random, ModelData.EMPTY, null ), tints );
         }
     }
 
@@ -185,10 +186,10 @@ public class TileEntityTurtleRenderer implements BlockEntityRenderer<TileTurtle>
                 if( idx >= 0 && idx < tints.length ) tint = tints[bakedquad.getTintIndex()];
             }
 
-            float f = (float) (tint >> 16 & 255) / 255.0F;
-            float f1 = (float) (tint >> 8 & 255) / 255.0F;
-            float f2 = (float) (tint & 255) / 255.0F;
-            buffer.putBulkData( matrix, bakedquad, f, f1, f2, lightmapCoord, overlayLight, true );
+            float r = (float) (tint >> 16 & 255) / 255.0F;
+            float g = (float) (tint >> 8 & 255) / 255.0F;
+            float b = (float) (tint & 255) / 255.0F;
+            buffer.putBulkData( matrix, bakedquad, r, g, b, lightmapCoord, overlayLight );
         }
     }
 }

src/main/java/dan200/computercraft/client/render/TransformedBakedModel.java

@@ -0,0 +1,60 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+package dan200.computercraft.client.render;
+
+import com.mojang.math.Transformation;
+import dan200.computercraft.api.client.TransformedModel;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.block.model.BakedQuad;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.core.Direction;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.client.model.BakedModelWrapper;
+import net.minecraftforge.client.model.QuadTransformers;
+import net.minecraftforge.client.model.data.ModelData;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.annotation.Nonnull;
+import java.util.List;
+
+public class TransformedBakedModel extends BakedModelWrapper<BakedModel>
+{
+    private final Transformation transformation;
+    private final boolean isIdentity;
+
+    public TransformedBakedModel( BakedModel model, Transformation transformation )
+    {
+        super( model );
+        this.transformation = transformation;
+        isIdentity = transformation.isIdentity();
+    }
+
+    public TransformedBakedModel( TransformedModel model )
+    {
+        this( model.getModel(), model.getMatrix() );
+    }
+
+    @Nonnull
+    @Override
+    public List<BakedQuad> getQuads( @Nullable BlockState state, @Nullable Direction side, @Nonnull RandomSource rand )
+    {
+        return getQuads( state, side, rand, ModelData.EMPTY, null );
+    }
+
+    @Override
+    public @NotNull List<BakedQuad> getQuads( @Nullable BlockState state, @Nullable Direction side, @NotNull RandomSource rand, @NotNull ModelData extraData, @Nullable RenderType renderType )
+    {
+        List<BakedQuad> quads = originalModel.getQuads( state, side, rand, extraData, renderType );
+        return isIdentity ? quads : QuadTransformers.applying( transformation ).process( quads );
+    }
+
+    public TransformedBakedModel composeWith( Transformation other )
+    {
+        return new TransformedBakedModel( originalModel, other.compose( transformation ) );
+    }
+}

src/main/java/dan200/computercraft/client/render/TurtleModelLoader.java

@@ -13,11 +13,10 @@ import net.minecraft.client.renderer.block.model.ItemOverrides;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.client.resources.model.*;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.resources.ResourceManager;
 import net.minecraft.util.GsonHelper;
-import net.minecraftforge.client.model.IModelConfiguration;
-import net.minecraftforge.client.model.IModelLoader;
-import net.minecraftforge.client.model.geometry.IModelGeometry;
+import net.minecraftforge.client.model.geometry.IGeometryBakingContext;
+import net.minecraftforge.client.model.geometry.IGeometryLoader;
+import net.minecraftforge.client.model.geometry.IUnbakedGeometry;
 
 import javax.annotation.Nonnull;
 import java.util.Collection;
@@ -25,7 +24,7 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.function.Function;
 
-public final class TurtleModelLoader implements IModelLoader<TurtleModelLoader.TurtleModel>
+public final class TurtleModelLoader implements IGeometryLoader<TurtleModelLoader.TurtleModel>
 {
     private static final ResourceLocation COLOUR_TURTLE_MODEL = new ResourceLocation( ComputerCraft.MOD_ID, "block/turtle_colour" );
 
@@ -35,20 +34,15 @@ public final class TurtleModelLoader implements IModelLoader<TurtleModelLoader.T
     {
     }
 
-    @Override
-    public void onResourceManagerReload( @Nonnull ResourceManager manager )
-    {
-    }
-
     @Nonnull
     @Override
-    public TurtleModel read( @Nonnull JsonDeserializationContext deserializationContext, @Nonnull JsonObject modelContents )
+    public TurtleModel read( @Nonnull JsonObject modelContents, @Nonnull JsonDeserializationContext deserializationContext )
     {
         ResourceLocation model = new ResourceLocation( GsonHelper.getAsString( modelContents, "model" ) );
         return new TurtleModel( model );
     }
 
-    public static final class TurtleModel implements IModelGeometry<TurtleModel>
+    public static final class TurtleModel implements IUnbakedGeometry<TurtleModel>
     {
         private final ResourceLocation family;
 
@@ -58,7 +52,7 @@ public final class TurtleModelLoader implements IModelLoader<TurtleModelLoader.T
         }
 
         @Override
-        public Collection<Material> getTextures( IModelConfiguration owner, Function<ResourceLocation, UnbakedModel> modelGetter, Set<Pair<String, String>> missingTextureErrors )
+        public Collection<Material> getMaterials( IGeometryBakingContext context, Function<ResourceLocation, UnbakedModel> modelGetter, Set<Pair<String, String>> missingTextureErrors )
         {
             Set<Material> materials = new HashSet<>();
             materials.addAll( modelGetter.apply( family ).getMaterials( modelGetter, missingTextureErrors ) );
@@ -67,7 +61,7 @@ public final class TurtleModelLoader implements IModelLoader<TurtleModelLoader.T
         }
 
         @Override
-        public BakedModel bake( IModelConfiguration owner, ModelBakery bakery, Function<Material, TextureAtlasSprite> spriteGetter, ModelState transform, ItemOverrides overrides, ResourceLocation modelLocation )
+        public BakedModel bake( IGeometryBakingContext owner, ModelBakery bakery, Function<Material, TextureAtlasSprite> spriteGetter, ModelState transform, ItemOverrides overrides, ResourceLocation modelLocation )
         {
             return new TurtleSmartItemModel(
                 bakery.bake( family, transform, spriteGetter ),

src/main/java/dan200/computercraft/client/render/TurtleMultiModel.java

@@ -1,153 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render;
-
-import com.mojang.math.Transformation;
-import dan200.computercraft.api.client.TransformedModel;
-import net.minecraft.client.renderer.block.model.BakedQuad;
-import net.minecraft.client.renderer.block.model.ItemOverrides;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.client.resources.model.BakedModel;
-import net.minecraft.core.Direction;
-import net.minecraft.util.RandomSource;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraftforge.client.model.data.EmptyModelData;
-import net.minecraftforge.client.model.data.IModelData;
-import net.minecraftforge.client.model.pipeline.BakedQuadBuilder;
-import net.minecraftforge.client.model.pipeline.TRSRTransformer;
-
-import javax.annotation.Nonnull;
-import java.util.ArrayList;
-import java.util.EnumMap;
-import java.util.List;
-import java.util.Map;
-
-public class TurtleMultiModel implements BakedModel
-{
-    private final BakedModel baseModel;
-    private final BakedModel overlayModel;
-    private final Transformation generalTransform;
-    private final TransformedModel leftUpgradeModel;
-    private final TransformedModel rightUpgradeModel;
-    private List<BakedQuad> generalQuads = null;
-    private final Map<Direction, List<BakedQuad>> faceQuads = new EnumMap<>( Direction.class );
-
-    public TurtleMultiModel( BakedModel baseModel, BakedModel overlayModel, Transformation generalTransform, TransformedModel leftUpgradeModel, TransformedModel rightUpgradeModel )
-    {
-        // Get the models
-        this.baseModel = baseModel;
-        this.overlayModel = overlayModel;
-        this.leftUpgradeModel = leftUpgradeModel;
-        this.rightUpgradeModel = rightUpgradeModel;
-        this.generalTransform = generalTransform;
-    }
-
-    @Nonnull
-    @Override
-    @Deprecated
-    public List<BakedQuad> getQuads( BlockState state, Direction side, @Nonnull RandomSource rand )
-    {
-        return getQuads( state, side, rand, EmptyModelData.INSTANCE );
-    }
-
-    @Nonnull
-    @Override
-    public List<BakedQuad> getQuads( BlockState state, Direction side, @Nonnull RandomSource rand, @Nonnull IModelData data )
-    {
-        if( side != null )
-        {
-            if( !faceQuads.containsKey( side ) ) faceQuads.put( side, buildQuads( state, side, rand ) );
-            return faceQuads.get( side );
-        }
-        else
-        {
-            if( generalQuads == null ) generalQuads = buildQuads( state, side, rand );
-            return generalQuads;
-        }
-    }
-
-    private List<BakedQuad> buildQuads( BlockState state, Direction side, RandomSource rand )
-    {
-        ArrayList<BakedQuad> quads = new ArrayList<>();
-
-
-        transformQuadsTo( quads, baseModel.getQuads( state, side, rand, EmptyModelData.INSTANCE ), generalTransform );
-        if( overlayModel != null )
-        {
-            transformQuadsTo( quads, overlayModel.getQuads( state, side, rand, EmptyModelData.INSTANCE ), generalTransform );
-        }
-        if( leftUpgradeModel != null )
-        {
-            Transformation upgradeTransform = generalTransform.compose( leftUpgradeModel.getMatrix() );
-            transformQuadsTo( quads, leftUpgradeModel.getModel().getQuads( state, side, rand, EmptyModelData.INSTANCE ), upgradeTransform );
-        }
-        if( rightUpgradeModel != null )
-        {
-            Transformation upgradeTransform = generalTransform.compose( rightUpgradeModel.getMatrix() );
-            transformQuadsTo( quads, rightUpgradeModel.getModel().getQuads( state, side, rand, EmptyModelData.INSTANCE ), upgradeTransform );
-        }
-        quads.trimToSize();
-        return quads;
-    }
-
-    @Override
-    public boolean useAmbientOcclusion()
-    {
-        return baseModel.useAmbientOcclusion();
-    }
-
-    @Override
-    public boolean isGui3d()
-    {
-        return baseModel.isGui3d();
-    }
-
-    @Override
-    public boolean isCustomRenderer()
-    {
-        return baseModel.isCustomRenderer();
-    }
-
-    @Override
-    public boolean usesBlockLight()
-    {
-        return baseModel.usesBlockLight();
-    }
-
-    @Nonnull
-    @Override
-    @Deprecated
-    public TextureAtlasSprite getParticleIcon()
-    {
-        return baseModel.getParticleIcon();
-    }
-
-    @Nonnull
-    @Override
-    @Deprecated
-    public net.minecraft.client.renderer.block.model.ItemTransforms getTransforms()
-    {
-        return baseModel.getTransforms();
-    }
-
-    @Nonnull
-    @Override
-    public ItemOverrides getOverrides()
-    {
-        return ItemOverrides.EMPTY;
-    }
-
-    private void transformQuadsTo( List<BakedQuad> output, List<BakedQuad> quads, Transformation transform )
-    {
-        for( BakedQuad quad : quads )
-        {
-            BakedQuadBuilder builder = new BakedQuadBuilder();
-            TRSRTransformer transformer = new TRSRTransformer( builder, transform );
-            quad.pipe( transformer );
-            output.add( builder.build() );
-        }
-    }
-}

src/main/java/dan200/computercraft/client/render/TurtleSmartItemModel.java

@@ -7,35 +7,28 @@ package dan200.computercraft.client.render;
 
 import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.math.Transformation;
-import dan200.computercraft.api.client.TransformedModel;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.client.turtle.TurtleUpgradeModellers;
 import dan200.computercraft.shared.turtle.items.ItemTurtle;
 import dan200.computercraft.shared.util.Holiday;
 import dan200.computercraft.shared.util.HolidayUtil;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.client.renderer.block.model.BakedQuad;
-import net.minecraft.client.renderer.block.model.ItemOverrides;
 import net.minecraft.client.renderer.block.model.ItemTransforms;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.client.resources.model.BakedModel;
 import net.minecraft.client.resources.model.ModelManager;
 import net.minecraft.client.resources.model.ModelResourceLocation;
-import net.minecraft.core.Direction;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.util.RandomSource;
-import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.BakedModelWrapper;
 
 import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
-public class TurtleSmartItemModel implements BakedModel
+public class TurtleSmartItemModel extends BakedModelWrapper<BakedModel>
 {
     private static final Transformation identity, flip;
 
@@ -49,7 +42,7 @@ public class TurtleSmartItemModel implements BakedModel
         flip = new Transformation( stack.last().pose() );
     }
 
-    private static record TurtleModelCombination(
+    private record TurtleModelCombination(
         boolean colour,
         ITurtleUpgrade leftUpgrade,
         ITurtleUpgrade rightUpgrade,
@@ -63,112 +56,64 @@ public class TurtleSmartItemModel implements BakedModel
     private final BakedModel familyModel;
     private final BakedModel colourModel;
 
-    private final HashMap<TurtleModelCombination, BakedModel> cachedModels = new HashMap<>();
-    private final ItemOverrides overrides;
+    private final Map<TurtleModelCombination, List<BakedModel>> cachedModels = new HashMap<>();
 
     public TurtleSmartItemModel( BakedModel familyModel, BakedModel colourModel )
     {
+        super( familyModel );
         this.familyModel = familyModel;
         this.colourModel = colourModel;
-
-        overrides = new ItemOverrides()
-        {
-            @Nonnull
-            @Override
-            public BakedModel resolve( @Nonnull BakedModel originalModel, @Nonnull ItemStack stack, @Nullable ClientLevel world, @Nullable LivingEntity entity, int random )
-            {
-                ItemTurtle turtle = (ItemTurtle) stack.getItem();
-                int colour = turtle.getColour( stack );
-                ITurtleUpgrade leftUpgrade = turtle.getUpgrade( stack, TurtleSide.LEFT );
-                ITurtleUpgrade rightUpgrade = turtle.getUpgrade( stack, TurtleSide.RIGHT );
-                ResourceLocation overlay = turtle.getOverlay( stack );
-                boolean christmas = HolidayUtil.getCurrentHoliday() == Holiday.CHRISTMAS;
-                String label = turtle.getLabel( stack );
-                boolean flip = label != null && (label.equals( "Dinnerbone" ) || label.equals( "Grumm" ));
-                TurtleModelCombination combo = new TurtleModelCombination( colour != -1, leftUpgrade, rightUpgrade, overlay, christmas, flip );
-
-                BakedModel model = cachedModels.get( combo );
-                if( model == null ) cachedModels.put( combo, model = buildModel( combo ) );
-                return model;
-            }
-        };
     }
 
     @Nonnull
     @Override
-    public ItemOverrides getOverrides()
+    public BakedModel applyTransform( @Nonnull ItemTransforms.TransformType cameraTransformType, @Nonnull PoseStack poseStack, boolean applyLeftHandTransform )
     {
-        return overrides;
+        originalModel.applyTransform( cameraTransformType, poseStack, applyLeftHandTransform );
+        return this;
     }
 
-    private BakedModel buildModel( TurtleModelCombination combo )
+    @Nonnull
+    @Override
+    public List<BakedModel> getRenderPasses( ItemStack stack, boolean fabulous )
+    {
+        ItemTurtle turtle = (ItemTurtle) stack.getItem();
+
+        int colour = turtle.getColour( stack );
+        ITurtleUpgrade leftUpgrade = turtle.getUpgrade( stack, TurtleSide.LEFT );
+        ITurtleUpgrade rightUpgrade = turtle.getUpgrade( stack, TurtleSide.RIGHT );
+        ResourceLocation overlay = turtle.getOverlay( stack );
+        boolean christmas = HolidayUtil.getCurrentHoliday() == Holiday.CHRISTMAS;
+        String label = turtle.getLabel( stack );
+        boolean flip = label != null && (label.equals( "Dinnerbone" ) || label.equals( "Grumm" ));
+
+        TurtleModelCombination combo = new TurtleModelCombination( colour != -1, leftUpgrade, rightUpgrade, overlay, christmas, flip );
+        return cachedModels.computeIfAbsent( combo, this::buildModel );
+    }
+
+    private List<BakedModel> buildModel( TurtleModelCombination combo )
     {
         Minecraft mc = Minecraft.getInstance();
         ModelManager modelManager = mc.getItemRenderer().getItemModelShaper().getModelManager();
-        ModelResourceLocation overlayModelLocation = TileEntityTurtleRenderer.getTurtleOverlayModel( combo.overlay, combo.christmas );
 
-        BakedModel baseModel = combo.colour ? colourModel : familyModel;
-        BakedModel overlayModel = overlayModelLocation != null ? modelManager.getModel( overlayModelLocation ) : null;
-        Transformation transform = combo.flip ? flip : identity;
-        TransformedModel leftModel = combo.leftUpgrade != null ? combo.leftUpgrade.getModel( null, TurtleSide.LEFT ) : null;
-        TransformedModel rightModel = combo.rightUpgrade != null ? combo.rightUpgrade.getModel( null, TurtleSide.RIGHT ) : null;
-        return new TurtleMultiModel( baseModel, overlayModel, transform, leftModel, rightModel );
+        var transformation = combo.flip ? flip : identity;
+        ArrayList<BakedModel> parts = new ArrayList<>( 4 );
+        parts.add( new TransformedBakedModel( combo.colour() ? colourModel : familyModel, transformation ) );
+
+        ModelResourceLocation overlayModelLocation = TileEntityTurtleRenderer.getTurtleOverlayModel( combo.overlay(), combo.christmas() );
+        if( overlayModelLocation != null )
+        {
+            parts.add( new TransformedBakedModel( modelManager.getModel( overlayModelLocation ), transformation ) );
+        }
+        if( combo.leftUpgrade() != null )
+        {
+            parts.add( new TransformedBakedModel( TurtleUpgradeModellers.getModel( combo.leftUpgrade(), null, TurtleSide.LEFT ) ).composeWith( transformation ) );
+        }
+        if( combo.rightUpgrade() != null )
+        {
+            parts.add( new TransformedBakedModel( TurtleUpgradeModellers.getModel( combo.rightUpgrade(), null, TurtleSide.RIGHT ) ).composeWith( transformation ) );
+        }
+
+        return parts;
     }
-
-    @Nonnull
-    @Override
-    @Deprecated
-    public List<BakedQuad> getQuads( BlockState state, Direction facing, @Nonnull RandomSource rand )
-    {
-        return familyModel.getQuads( state, facing, rand );
-    }
-
-    @Nonnull
-    @Override
-    @Deprecated
-    public List<BakedQuad> getQuads( BlockState state, Direction facing, @Nonnull RandomSource rand, @Nonnull IModelData data )
-    {
-        return familyModel.getQuads( state, facing, rand, data );
-    }
-
-    @Override
-    public boolean useAmbientOcclusion()
-    {
-        return familyModel.useAmbientOcclusion();
-    }
-
-    @Override
-    public boolean isGui3d()
-    {
-        return familyModel.isGui3d();
-    }
-
-    @Override
-    public boolean isCustomRenderer()
-    {
-        return familyModel.isCustomRenderer();
-    }
-
-    @Override
-    public boolean usesBlockLight()
-    {
-        return familyModel.usesBlockLight();
-    }
-
-    @Nonnull
-    @Override
-    @Deprecated
-    public TextureAtlasSprite getParticleIcon()
-    {
-        return familyModel.getParticleIcon();
-    }
-
-    @Nonnull
-    @Override
-    @Deprecated
-    public ItemTransforms getTransforms()
-    {
-        return familyModel.getTransforms();
-    }
-
 }

src/main/java/dan200/computercraft/client/render/text/DirectFixedWidthFontRenderer.java

@@ -8,6 +8,8 @@ package dan200.computercraft.client.render.text;
 import com.mojang.blaze3d.platform.MemoryTracker;
 import com.mojang.blaze3d.vertex.DefaultVertexFormat;
 import com.mojang.blaze3d.vertex.VertexConsumer;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import dan200.computercraft.client.render.RenderTypes;
 import dan200.computercraft.core.terminal.Terminal;
 import dan200.computercraft.core.terminal.TextBuffer;
 import dan200.computercraft.shared.util.Colour;
@@ -18,17 +20,16 @@ import javax.annotation.Nonnull;
 import java.nio.ByteBuffer;
 
 import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.*;
-import static org.lwjgl.system.MemoryUtil.memPutByte;
-import static org.lwjgl.system.MemoryUtil.memPutFloat;
+import static org.lwjgl.system.MemoryUtil.*;
 
 /**
- * An optimised copy of {@link FixedWidthFontRenderer} emitter emits directly to a {@link ByteBuffer} rather than
+ * An optimised copy of {@link FixedWidthFontRenderer} emitter emits directly to a {@link QuadEmitter} rather than
  * emitting to {@link VertexConsumer}. This allows us to emit vertices very quickly, when using the VBO renderer.
  *
  * There are some limitations here:
  * <ul>
  *   <li>No transformation matrix (not needed for VBOs).</li>
- *   <li>Only works with {@link DefaultVertexFormat#POSITION_COLOR_TEX}.</li>
+ *   <li>Only works with {@link DefaultVertexFormat#POSITION_COLOR_TEX_LIGHTMAP}.</li>
  *   <li>The buffer <strong>MUST</strong> be allocated with {@link MemoryTracker}, and not through any other means.</li>
  * </ul>
  *
@@ -44,7 +45,7 @@ public final class DirectFixedWidthFontRenderer
     {
     }
 
-    private static void drawChar( ByteBuffer buffer, float x, float y, int index, byte[] colour )
+    private static void drawChar( QuadEmitter emitter, float x, float y, int index, byte[] colour )
     {
         // Short circuit to avoid the common case - the texture should be blank here after all.
         if( index == '\0' || index == ' ' ) return;
@@ -56,30 +57,30 @@ public final class DirectFixedWidthFontRenderer
         int yStart = 1 + row * (FONT_HEIGHT + 2);
 
         quad(
-            buffer, x, y, x + FONT_WIDTH, y + FONT_HEIGHT, colour,
+            emitter, x, y, x + FONT_WIDTH, y + FONT_HEIGHT, 0, colour,
             xStart / WIDTH, yStart / WIDTH, (xStart + FONT_WIDTH) / WIDTH, (yStart + FONT_HEIGHT) / WIDTH
         );
     }
 
-    private static void drawQuad( ByteBuffer emitter, float x, float y, float width, float height, Palette palette, boolean greyscale, char colourIndex )
+    private static void drawQuad( QuadEmitter emitter, float x, float y, float width, float height, Palette palette, boolean greyscale, char colourIndex )
     {
         byte[] colour = palette.getByteColour( getColour( colourIndex, Colour.BLACK ), greyscale );
-        quad( emitter, x, y, x + width, y + height, colour, BACKGROUND_START, BACKGROUND_START, BACKGROUND_END, BACKGROUND_END );
+        quad( emitter, x, y, x + width, y + height, 0f, colour, BACKGROUND_START, BACKGROUND_START, BACKGROUND_END, BACKGROUND_END );
     }
 
     private static void drawBackground(
-        @Nonnull ByteBuffer buffer, float x, float y, @Nonnull TextBuffer backgroundColour, @Nonnull Palette palette, boolean greyscale,
+        @Nonnull QuadEmitter emitter, float x, float y, @Nonnull TextBuffer backgroundColour, @Nonnull Palette palette, boolean greyscale,
         float leftMarginSize, float rightMarginSize, float height
     )
     {
         if( leftMarginSize > 0 )
         {
-            drawQuad( buffer, x - leftMarginSize, y, leftMarginSize, height, palette, greyscale, backgroundColour.charAt( 0 ) );
+            drawQuad( emitter, x - leftMarginSize, y, leftMarginSize, height, palette, greyscale, backgroundColour.charAt( 0 ) );
         }
 
         if( rightMarginSize > 0 )
         {
-            drawQuad( buffer, x + backgroundColour.length() * FONT_WIDTH, y, rightMarginSize, height, palette, greyscale, backgroundColour.charAt( backgroundColour.length() - 1 ) );
+            drawQuad( emitter, x + backgroundColour.length() * FONT_WIDTH, y, rightMarginSize, height, palette, greyscale, backgroundColour.charAt( backgroundColour.length() - 1 ) );
         }
 
         // Batch together runs of identical background cells.
@@ -92,7 +93,7 @@ public final class DirectFixedWidthFontRenderer
 
             if( blockColour != '\0' )
             {
-                drawQuad( buffer, x + blockStart * FONT_WIDTH, y, FONT_WIDTH * (i - blockStart), height, palette, greyscale, blockColour );
+                drawQuad( emitter, x + blockStart * FONT_WIDTH, y, FONT_WIDTH * (i - blockStart), height, palette, greyscale, blockColour );
             }
 
             blockColour = colourIndex;
@@ -101,11 +102,11 @@ public final class DirectFixedWidthFontRenderer
 
         if( blockColour != '\0' )
         {
-            drawQuad( buffer, x + blockStart * FONT_WIDTH, y, FONT_WIDTH * (backgroundColour.length() - blockStart), height, palette, greyscale, blockColour );
+            drawQuad( emitter, x + blockStart * FONT_WIDTH, y, FONT_WIDTH * (backgroundColour.length() - blockStart), height, palette, greyscale, blockColour );
         }
     }
 
-    private static void drawString( @Nonnull ByteBuffer buffer, float x, float y, @Nonnull TextBuffer text, @Nonnull TextBuffer textColour, @Nonnull Palette palette, boolean greyscale )
+    public static void drawString( @Nonnull QuadEmitter emitter, float x, float y, @Nonnull TextBuffer text, @Nonnull TextBuffer textColour, @Nonnull Palette palette, boolean greyscale )
     {
         for( int i = 0; i < text.length(); i++ )
         {
@@ -113,12 +114,29 @@ public final class DirectFixedWidthFontRenderer
 
             int index = text.charAt( i );
             if( index > 255 ) index = '?';
-            drawChar( buffer, x + i * FONT_WIDTH, y, index, colour );
+            drawChar( emitter, x + i * FONT_WIDTH, y, index, colour );
+        }
+
+    }
+
+    public static void drawTerminalForeground( @Nonnull QuadEmitter emitter, float x, float y, @Nonnull Terminal terminal, boolean greyscale )
+    {
+        Palette palette = terminal.getPalette();
+        int height = terminal.getHeight();
+
+        // The main text
+        for( int i = 0; i < height; i++ )
+        {
+            float rowY = y + FONT_HEIGHT * i;
+            drawString(
+                emitter, x, rowY, terminal.getLine( i ), terminal.getTextColourLine( i ),
+                palette, greyscale
+            );
         }
     }
 
-    public static void drawTerminalWithoutCursor(
-        @Nonnull ByteBuffer buffer, float x, float y, @Nonnull Terminal terminal, boolean greyscale,
+    public static void drawTerminalBackground(
+        @Nonnull QuadEmitter emitter, float x, float y, @Nonnull Terminal terminal, boolean greyscale,
         float topMarginSize, float bottomMarginSize, float leftMarginSize, float rightMarginSize
     )
     {
@@ -127,12 +145,12 @@ public final class DirectFixedWidthFontRenderer
 
         // Top and bottom margins
         drawBackground(
-            buffer, x, y - topMarginSize, terminal.getBackgroundColourLine( 0 ), palette, greyscale,
+            emitter, x, y - topMarginSize, terminal.getBackgroundColourLine( 0 ), palette, greyscale,
             leftMarginSize, rightMarginSize, topMarginSize
         );
 
         drawBackground(
-            buffer, x, y + height * FONT_HEIGHT, terminal.getBackgroundColourLine( height - 1 ), palette, greyscale,
+            emitter, x, y + height * FONT_HEIGHT, terminal.getBackgroundColourLine( height - 1 ), palette, greyscale,
             leftMarginSize, rightMarginSize, bottomMarginSize
         );
 
@@ -141,43 +159,68 @@ public final class DirectFixedWidthFontRenderer
         {
             float rowY = y + FONT_HEIGHT * i;
             drawBackground(
-                buffer, x, rowY, terminal.getBackgroundColourLine( i ), palette, greyscale,
+                emitter, x, rowY, terminal.getBackgroundColourLine( i ), palette, greyscale,
                 leftMarginSize, rightMarginSize, FONT_HEIGHT
             );
-            drawString(
-                buffer, x, rowY, terminal.getLine( i ), terminal.getTextColourLine( i ),
-                palette, greyscale
-            );
         }
     }
 
-    public static void drawCursor( @Nonnull ByteBuffer buffer, float x, float y, @Nonnull Terminal terminal, boolean greyscale )
+    public static void drawCursor( @Nonnull QuadEmitter emitter, float x, float y, @Nonnull Terminal terminal, boolean greyscale )
     {
         if( isCursorVisible( terminal ) )
         {
             byte[] colour = terminal.getPalette().getByteColour( 15 - terminal.getTextColour(), greyscale );
-            drawChar( buffer, x + terminal.getCursorX() * FONT_WIDTH, y + terminal.getCursorY() * FONT_HEIGHT, '_', colour );
+            drawChar( emitter, x + terminal.getCursorX() * FONT_WIDTH, y + terminal.getCursorY() * FONT_HEIGHT, '_', colour );
         }
     }
 
     public static int getVertexCount( Terminal terminal )
     {
-        return (1 + (terminal.getHeight() + 2) * terminal.getWidth() * 2) * 4;
+        return (terminal.getHeight() + 2) * (terminal.getWidth() + 2) * 2;
     }
 
-    private static void quad( ByteBuffer buffer, float x1, float y1, float x2, float y2, byte[] rgba, float u1, float v1, float u2, float v2 )
+    private static void quad( QuadEmitter buffer, float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2 )
+    {
+        buffer.quad( x1, y1, x2, y2, z, rgba, u1, v1, u2, v2 );
+    }
+
+    public interface QuadEmitter
+    {
+        VertexFormat format();
+
+        ByteBuffer buffer();
+
+        void quad( float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2 );
+    }
+
+    public record ByteBufferEmitter(ByteBuffer buffer) implements QuadEmitter
+    {
+        @Override
+        public VertexFormat format()
+        {
+            return RenderTypes.TERMINAL.format();
+        }
+
+        @Override
+        public void quad( float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2 )
+        {
+            DirectFixedWidthFontRenderer.quad( buffer, x1, y1, x2, y2, z, rgba, u1, v1, u2, v2 );
+        }
+    }
+
+    static void quad( ByteBuffer buffer, float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2 )
     {
         // Emit a single quad to our buffer. This uses Unsafe (well, LWJGL's MemoryUtil) to directly blit bytes to the
         // underlying buffer. This allows us to have a single bounds check up-front, rather than one for every write.
         // This provides significant performance gains, at the cost of well, using Unsafe.
-        // Each vertex is 24 bytes, giving 96 bytes in total. Vertices are of the form (xyz:FFF)(rgba:BBBB)(uv:FF),
-        // which matches the POSITION_COLOR_TEX vertex format.
+        // Each vertex is 28 bytes, giving 112 bytes in total. Vertices are of the form (xyz:FFF)(rgba:BBBB)(uv1:FF)(uv2:SS),
+        // which matches the POSITION_COLOR_TEX_LIGHTMAP vertex format.
 
         int position = buffer.position();
         long addr = MemoryUtil.memAddress( buffer );
 
         // We're doing terrible unsafe hacks below, so let's be really sure that what we're doing is reasonable.
-        if( position < 0 || 96 > buffer.limit() - position ) throw new IndexOutOfBoundsException();
+        if( position < 0 || 112 > buffer.limit() - position ) throw new IndexOutOfBoundsException();
         // Require the pointer to be aligned to a 32-bit boundary.
         if( (addr & 3) != 0 ) throw new IllegalStateException( "Memory is not aligned" );
         // Also assert the length of the array. This appears to help elide bounds checks on the array in some circumstances.
@@ -185,46 +228,54 @@ public final class DirectFixedWidthFontRenderer
 
         memPutFloat( addr + 0, x1 );
         memPutFloat( addr + 4, y1 );
-        memPutFloat( addr + 8, 0 );
+        memPutFloat( addr + 8, z );
         memPutByte( addr + 12, rgba[0] );
         memPutByte( addr + 13, rgba[1] );
         memPutByte( addr + 14, rgba[2] );
         memPutByte( addr + 15, (byte) 255 );
         memPutFloat( addr + 16, u1 );
         memPutFloat( addr + 20, v1 );
+        memPutShort( addr + 24, (short) 0xF0 );
+        memPutShort( addr + 26, (short) 0xF0 );
 
-        memPutFloat( addr + 24, x1 );
-        memPutFloat( addr + 28, y2 );
-        memPutFloat( addr + 32, 0 );
-        memPutByte( addr + 36, rgba[0] );
-        memPutByte( addr + 37, rgba[1] );
-        memPutByte( addr + 38, rgba[2] );
-        memPutByte( addr + 39, (byte) 255 );
-        memPutFloat( addr + 40, u1 );
-        memPutFloat( addr + 44, v2 );
+        memPutFloat( addr + 28, x1 );
+        memPutFloat( addr + 32, y2 );
+        memPutFloat( addr + 36, z );
+        memPutByte( addr + 40, rgba[0] );
+        memPutByte( addr + 41, rgba[1] );
+        memPutByte( addr + 42, rgba[2] );
+        memPutByte( addr + 43, (byte) 255 );
+        memPutFloat( addr + 44, u1 );
+        memPutFloat( addr + 48, v2 );
+        memPutShort( addr + 52, (short) 0xF0 );
+        memPutShort( addr + 54, (short) 0xF0 );
 
-        memPutFloat( addr + 48, x2 );
-        memPutFloat( addr + 52, y2 );
-        memPutFloat( addr + 56, 0 );
-        memPutByte( addr + 60, rgba[0] );
-        memPutByte( addr + 61, rgba[1] );
-        memPutByte( addr + 62, rgba[2] );
-        memPutByte( addr + 63, (byte) 255 );
-        memPutFloat( addr + 64, u2 );
-        memPutFloat( addr + 68, v2 );
+        memPutFloat( addr + 56, x2 );
+        memPutFloat( addr + 60, y2 );
+        memPutFloat( addr + 64, z );
+        memPutByte( addr + 68, rgba[0] );
+        memPutByte( addr + 69, rgba[1] );
+        memPutByte( addr + 70, rgba[2] );
+        memPutByte( addr + 71, (byte) 255 );
+        memPutFloat( addr + 72, u2 );
+        memPutFloat( addr + 76, v2 );
+        memPutShort( addr + 80, (short) 0xF0 );
+        memPutShort( addr + 82, (short) 0xF0 );
 
-        memPutFloat( addr + 72, x2 );
-        memPutFloat( addr + 76, y1 );
-        memPutFloat( addr + 80, 0 );
-        memPutByte( addr + 84, rgba[0] );
-        memPutByte( addr + 85, rgba[1] );
-        memPutByte( addr + 86, rgba[2] );
-        memPutByte( addr + 87, (byte) 255 );
-        memPutFloat( addr + 88, u2 );
-        memPutFloat( addr + 92, v1 );
+        memPutFloat( addr + 84, x2 );
+        memPutFloat( addr + 88, y1 );
+        memPutFloat( addr + 92, z );
+        memPutByte( addr + 96, rgba[0] );
+        memPutByte( addr + 97, rgba[1] );
+        memPutByte( addr + 98, rgba[2] );
+        memPutByte( addr + 99, (byte) 255 );
+        memPutFloat( addr + 100, u2 );
+        memPutFloat( addr + 104, v1 );
+        memPutShort( addr + 108, (short) 0xF0 );
+        memPutShort( addr + 110, (short) 0xF0 );
 
         // Finally increment the position.
-        buffer.position( position + 96 );
+        buffer.position( position + 112 );
 
         // Well done for getting to the end of this method. I recommend you take a break and go look at cute puppies.
     }

src/main/java/dan200/computercraft/client/render/text/FixedWidthFontRenderer.java

@@ -5,10 +5,11 @@
  */
 package dan200.computercraft.client.render.text;
 
+import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.blaze3d.vertex.VertexConsumer;
 import com.mojang.math.Matrix4f;
+import com.mojang.math.Vector3f;
 import dan200.computercraft.client.FrameInfo;
-import dan200.computercraft.client.render.RenderTypes;
 import dan200.computercraft.core.terminal.Terminal;
 import dan200.computercraft.core.terminal.TextBuffer;
 import dan200.computercraft.shared.util.Colour;
@@ -26,13 +27,8 @@ import static dan200.computercraft.client.render.RenderTypes.FULL_BRIGHT_LIGHTMA
  * <ul>
  * <li>{@link #drawString}: Drawing basic text without a terminal (such as for printouts). Unlike the other methods,
  * this accepts a lightmap coordinate as, unlike terminals, printed pages render fullbright.</li>
- * <li>{@link #drawTerminalWithoutCursor}/{@link #drawCursor}: Draw a terminal without a cursor and then draw the cursor
- * separately. This is used by the monitor renderer to render the terminal to a VBO and draw the cursor dynamically.
- * </li>
  * <li>{@link #drawTerminal}: Draw a terminal with a cursor. This is used by the various computer GUIs to render the
  * whole term.</li>
- * <li>{@link #drawBlocker}: When rendering a terminal using {@link RenderTypes#TERMINAL_WITHOUT_DEPTH} you need to
- * render an additional "depth blocker" on top of the monitor.</li>
  * </ul>
  *
  * <strong>IMPORTANT: </strong> When making changes to this class, please check if you need to make the same changes to
@@ -50,6 +46,7 @@ public final class FixedWidthFontRenderer
     static final float BACKGROUND_END = (WIDTH - 4.0f) / WIDTH;
 
     private static final byte[] BLACK = new byte[] { byteColour( Colour.BLACK.getR() ), byteColour( Colour.BLACK.getR() ), byteColour( Colour.BLACK.getR() ), (byte) 255 };
+    private static final float Z_OFFSET = 1e-3f;
 
     private FixedWidthFontRenderer()
     {
@@ -149,9 +146,24 @@ public final class FixedWidthFontRenderer
 
     }
 
-    public static void drawTerminalWithoutCursor(
-        @Nonnull QuadEmitter emitter, float x, float y,
-        @Nonnull Terminal terminal, boolean greyscale,
+    public static void drawTerminalForeground( @Nonnull QuadEmitter emitter, float x, float y, @Nonnull Terminal terminal, boolean greyscale )
+    {
+        Palette palette = terminal.getPalette();
+        int height = terminal.getHeight();
+
+        // The main text
+        for( int i = 0; i < height; i++ )
+        {
+            float rowY = y + FONT_HEIGHT * i;
+            drawString(
+                emitter, x, rowY, terminal.getLine( i ), terminal.getTextColourLine( i ),
+                palette, greyscale, FULL_BRIGHT_LIGHTMAP
+            );
+        }
+    }
+
+    public static void drawTerminalBackground(
+        @Nonnull QuadEmitter emitter, float x, float y, @Nonnull Terminal terminal, boolean greyscale,
         float topMarginSize, float bottomMarginSize, float leftMarginSize, float rightMarginSize
     )
     {
@@ -172,15 +184,11 @@ public final class FixedWidthFontRenderer
         // The main text
         for( int i = 0; i < height; i++ )
         {
-            float rowY = y + FixedWidthFontRenderer.FONT_HEIGHT * i;
+            float rowY = y + FONT_HEIGHT * i;
             drawBackground(
                 emitter, x, rowY, terminal.getBackgroundColourLine( i ), palette, greyscale,
                 leftMarginSize, rightMarginSize, FONT_HEIGHT, FULL_BRIGHT_LIGHTMAP
             );
-            drawString(
-                emitter, x, rowY, terminal.getLine( i ), terminal.getTextColourLine( i ),
-                palette, greyscale, FULL_BRIGHT_LIGHTMAP
-            );
         }
     }
 
@@ -208,8 +216,21 @@ public final class FixedWidthFontRenderer
         float topMarginSize, float bottomMarginSize, float leftMarginSize, float rightMarginSize
     )
     {
-        drawTerminalWithoutCursor( emitter, x, y, terminal, greyscale, topMarginSize, bottomMarginSize, leftMarginSize, rightMarginSize );
+        drawTerminalBackground(
+            emitter, x, y, terminal, greyscale,
+            topMarginSize, bottomMarginSize, leftMarginSize, rightMarginSize
+        );
+
+        // Render the foreground with a slight offset. By calling .translate() on the matrix itself, we're translating
+        // in screen space, rather than in model/view space.
+        // It's definitely not perfect, but better than z fighting!
+        var transformBackup = emitter.poseMatrix().copy();
+        emitter.poseMatrix().translate( new Vector3f( 0, 0, Z_OFFSET ) );
+
+        drawTerminalForeground( emitter, x, y, terminal, greyscale );
         drawCursor( emitter, x, y, terminal, greyscale );
+
+        emitter.poseMatrix().load( transformBackup );
     }
 
     public static void drawEmptyTerminal( @Nonnull QuadEmitter emitter, float x, float y, float width, float height )
@@ -217,27 +238,24 @@ public final class FixedWidthFontRenderer
         drawQuad( emitter, x, y, 0, width, height, BLACK, FULL_BRIGHT_LIGHTMAP );
     }
 
-    public static void drawBlocker( @Nonnull QuadEmitter emitter, float x, float y, float width, float height )
+    public record QuadEmitter(Matrix4f poseMatrix, VertexConsumer consumer)
     {
-        drawQuad( emitter, x, y, 0, width, height, BLACK, FULL_BRIGHT_LIGHTMAP );
     }
 
-    public record QuadEmitter(Matrix4f matrix4f, VertexConsumer consumer) {}
-
-    public static QuadEmitter toVertexConsumer( Matrix4f matrix, VertexConsumer consumer )
+    public static QuadEmitter toVertexConsumer( PoseStack transform, VertexConsumer consumer )
     {
-        return new QuadEmitter( matrix, consumer );
+        return new QuadEmitter( transform.last().pose(), consumer );
     }
 
     private static void quad( QuadEmitter c, float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2, int light )
     {
-        var matrix = c.matrix4f();
+        var poseMatrix = c.poseMatrix();
         var consumer = c.consumer();
         byte r = rgba[0], g = rgba[1], b = rgba[2], a = rgba[3];
 
-        consumer.vertex( matrix, x1, y1, z ).color( r, g, b, a ).uv( u1, v1 ).uv2( light ).endVertex();
-        consumer.vertex( matrix, x1, y2, z ).color( r, g, b, a ).uv( u1, v2 ).uv2( light ).endVertex();
-        consumer.vertex( matrix, x2, y2, z ).color( r, g, b, a ).uv( u2, v2 ).uv2( light ).endVertex();
-        consumer.vertex( matrix, x2, y1, z ).color( r, g, b, a ).uv( u2, v1 ).uv2( light ).endVertex();
+        consumer.vertex( poseMatrix, x1, y1, z ).color( r, g, b, a ).uv( u1, v1 ).uv2( light ).endVertex();
+        consumer.vertex( poseMatrix, x1, y2, z ).color( r, g, b, a ).uv( u1, v2 ).uv2( light ).endVertex();
+        consumer.vertex( poseMatrix, x2, y2, z ).color( r, g, b, a ).uv( u2, v2 ).uv2( light ).endVertex();
+        consumer.vertex( poseMatrix, x2, y1, z ).color( r, g, b, a ).uv( u2, v1 ).uv2( light ).endVertex();
     }
 }

src/main/java/dan200/computercraft/client/turtle/TurtleModemModeller.java

@@ -0,0 +1,59 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+package dan200.computercraft.client.turtle;
+
+import dan200.computercraft.api.client.TransformedModel;
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
+import dan200.computercraft.api.turtle.ITurtleAccess;
+import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.shared.turtle.upgrades.TurtleModem;
+import net.minecraft.client.resources.model.ModelResourceLocation;
+import net.minecraft.nbt.CompoundTag;
+import org.jetbrains.annotations.Nullable;
+
+import javax.annotation.Nonnull;
+
+public class TurtleModemModeller implements TurtleUpgradeModeller<TurtleModem>
+{
+    private final ModelResourceLocation leftOffModel;
+    private final ModelResourceLocation rightOffModel;
+    private final ModelResourceLocation leftOnModel;
+    private final ModelResourceLocation rightOnModel;
+
+    public TurtleModemModeller( boolean advanced )
+    {
+        if( advanced )
+        {
+            leftOffModel = new ModelResourceLocation( "computercraft:turtle_modem_advanced_off_left", "inventory" );
+            rightOffModel = new ModelResourceLocation( "computercraft:turtle_modem_advanced_off_right", "inventory" );
+            leftOnModel = new ModelResourceLocation( "computercraft:turtle_modem_advanced_on_left", "inventory" );
+            rightOnModel = new ModelResourceLocation( "computercraft:turtle_modem_advanced_on_right", "inventory" );
+        }
+        else
+        {
+            leftOffModel = new ModelResourceLocation( "computercraft:turtle_modem_normal_off_left", "inventory" );
+            rightOffModel = new ModelResourceLocation( "computercraft:turtle_modem_normal_off_right", "inventory" );
+            leftOnModel = new ModelResourceLocation( "computercraft:turtle_modem_normal_on_left", "inventory" );
+            rightOnModel = new ModelResourceLocation( "computercraft:turtle_modem_normal_on_right", "inventory" );
+        }
+    }
+
+    @Nonnull
+    @Override
+    public TransformedModel getModel( @Nonnull TurtleModem upgrade, @Nullable ITurtleAccess turtle, @Nonnull TurtleSide side )
+    {
+        boolean active = false;
+        if( turtle != null )
+        {
+            CompoundTag turtleNBT = turtle.getUpgradeNBTData( side );
+            active = turtleNBT.contains( "active" ) && turtleNBT.getBoolean( "active" );
+        }
+
+        return side == TurtleSide.LEFT
+            ? TransformedModel.of( active ? leftOnModel : leftOffModel )
+            : TransformedModel.of( active ? rightOnModel : rightOffModel );
+    }
+}

src/main/java/dan200/computercraft/client/turtle/TurtleUpgradeModellers.java

@@ -0,0 +1,72 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+package dan200.computercraft.client.turtle;
+
+import com.mojang.math.Transformation;
+import dan200.computercraft.api.client.TransformedModel;
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
+import dan200.computercraft.api.turtle.ITurtleAccess;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
+import dan200.computercraft.shared.TurtleUpgrades;
+import dan200.computercraft.shared.UpgradeManager;
+import net.minecraft.client.Minecraft;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentHashMap;
+
+public final class TurtleUpgradeModellers
+{
+    private static final TurtleUpgradeModeller<ITurtleUpgrade> NULL_TURTLE_MODELLER = ( upgrade, turtle, side ) ->
+        new TransformedModel( Minecraft.getInstance().getModelManager().getMissingModel(), Transformation.identity() );
+
+    private static final Map<TurtleUpgradeSerialiser<?>, TurtleUpgradeModeller<?>> turtleModels = new ConcurrentHashMap<>();
+
+    /**
+     * In order to avoid a double lookup of {@link ITurtleUpgrade} to {@link UpgradeManager.UpgradeWrapper} to
+     * {@link TurtleUpgradeModeller}, we maintain a cache here.
+     * <p>
+     * Turtle upgrades may be removed as part of datapack reloads, so we use a weak map to avoid the memory leak.
+     */
+    private static final WeakHashMap<ITurtleUpgrade, TurtleUpgradeModeller<?>> modelCache = new WeakHashMap<>();
+
+    private TurtleUpgradeModellers()
+    {
+    }
+
+    public static <T extends ITurtleUpgrade> void register( @Nonnull TurtleUpgradeSerialiser<T> serialiser, @Nonnull TurtleUpgradeModeller<T> modeller )
+    {
+        synchronized( turtleModels )
+        {
+            if( turtleModels.containsKey( serialiser ) )
+            {
+                throw new IllegalStateException( "Modeller already registered for serialiser" );
+            }
+
+            turtleModels.put( serialiser, modeller );
+        }
+    }
+
+    public static TransformedModel getModel( @Nonnull ITurtleUpgrade upgrade, @Nullable ITurtleAccess access, @Nonnull TurtleSide side )
+    {
+        @SuppressWarnings( "unchecked" )
+        var modeller = (TurtleUpgradeModeller<ITurtleUpgrade>) modelCache.computeIfAbsent( upgrade, TurtleUpgradeModellers::getModeller );
+        return modeller.getModel( upgrade, access, side );
+    }
+
+    private static TurtleUpgradeModeller<?> getModeller( ITurtleUpgrade upgradeA )
+    {
+        var wrapper = TurtleUpgrades.instance().getWrapper( upgradeA );
+        if( wrapper == null ) return NULL_TURTLE_MODELLER;
+
+        var modeller = turtleModels.get( wrapper.serialiser() );
+        return modeller == null ? NULL_TURTLE_MODELLER : modeller;
+    }
+}

src/main/java/dan200/computercraft/client/util/DirectVertexBuffer.java

@@ -50,6 +50,7 @@ public class DirectVertexBuffer extends VertexBuffer
         if( format != this.format )
         {
             if( this.format != null ) this.format.clearBufferState();
+            this.format = format;
 
             GL15C.glBindBuffer( GL15C.GL_ARRAY_BUFFER, vertexBufferId );
             format.setupBufferState();

src/main/java/dan200/computercraft/core/apis/LuaDateTime.java

@@ -24,7 +24,7 @@ final class LuaDateTime
     {
     }
 
-    static void format( DateTimeFormatterBuilder formatter, String format, ZoneOffset offset ) throws LuaException
+    static void format( DateTimeFormatterBuilder formatter, String format ) throws LuaException
     {
         for( int i = 0; i < format.length(); )
         {
@@ -61,7 +61,7 @@ final class LuaDateTime
                             formatter.appendText( ChronoField.MONTH_OF_YEAR, TextStyle.FULL );
                             break;
                         case 'c':
-                            format( formatter, "%a %b %e %H:%M:%S %Y", offset );
+                            format( formatter, "%a %b %e %H:%M:%S %Y" );
                             break;
                         case 'C':
                             formatter.appendValueReduced( CENTURY, 2, 2, 0 );
@@ -71,13 +71,13 @@ final class LuaDateTime
                             break;
                         case 'D':
                         case 'x':
-                            format( formatter, "%m/%d/%y", offset );
+                            format( formatter, "%m/%d/%y" );
                             break;
                         case 'e':
                             formatter.padNext( 2 ).appendValue( ChronoField.DAY_OF_MONTH );
                             break;
                         case 'F':
-                            format( formatter, "%Y-%m-%d", offset );
+                            format( formatter, "%Y-%m-%d" );
                             break;
                         case 'g':
                             formatter.appendValueReduced( IsoFields.WEEK_BASED_YEAR, 2, 2, 0 );
@@ -107,10 +107,10 @@ final class LuaDateTime
                             formatter.appendText( ChronoField.AMPM_OF_DAY );
                             break;
                         case 'r':
-                            format( formatter, "%I:%M:%S %p", offset );
+                            format( formatter, "%I:%M:%S %p" );
                             break;
                         case 'R':
-                            format( formatter, "%H:%M", offset );
+                            format( formatter, "%H:%M" );
                             break;
                         case 'S':
                             formatter.appendValue( ChronoField.SECOND_OF_MINUTE, 2 );
@@ -120,7 +120,7 @@ final class LuaDateTime
                             break;
                         case 'T':
                         case 'X':
-                            format( formatter, "%H:%M:%S", offset );
+                            format( formatter, "%H:%M:%S" );
                             break;
                         case 'u':
                             formatter.appendValue( ChronoField.DAY_OF_WEEK );
@@ -212,15 +212,13 @@ final class LuaDateTime
         throw new LuaException( "field \"" + field + "\" missing in date table" );
     }
 
-    private static final TemporalField CENTURY = map( ChronoField.YEAR, ValueRange.of( 0, 6 ), x -> (x / 100) % 100 );
+    private static final TemporalField CENTURY = map( ChronoField.YEAR, ValueRange.of( 0, 99 ), x -> (x / 100) % 100 );
     private static final TemporalField ZERO_WEEK = map( WeekFields.SUNDAY_START.dayOfWeek(), ValueRange.of( 0, 6 ), x -> x - 1 );
 
     private static TemporalField map( TemporalField field, ValueRange range, LongUnaryOperator convert )
     {
         return new TemporalField()
         {
-            private final ValueRange range = ValueRange.of( 0, 99 );
-
             @Override
             public TemporalUnit getBaseUnit()
             {

src/main/java/dan200/computercraft/core/apis/OSAPI.java

@@ -316,7 +316,7 @@ public class OSAPI implements ILuaAPI
      * Returns the current time depending on the string passed in. This will
      * always be in the range [0.0, 24.0).
      *
-     * * If called with {@code dan200.computercraft.ingame}, the current world time will be returned.
+     * * If called with {@code ingame}, the current world time will be returned.
      * This is the default if nothing is passed.
      * * If called with {@code utc}, returns the hour of the day in UTC time.
      * * If called with {@code local}, returns the hour of the day in the
@@ -326,10 +326,10 @@ public class OSAPI implements ILuaAPI
      * which will convert the date fields into a UNIX timestamp (number of
      * seconds since 1 January 1970).
      *
-     * @param args The locale of the time, or a table filled by {@code os.date("*t")} to decode. Defaults to {@code dan200.computercraft.ingame} locale if not specified.
+     * @param args The locale of the time, or a table filled by {@code os.date("*t")} to decode. Defaults to {@code ingame} locale if not specified.
      * @return The hour of the selected locale, or a UNIX timestamp from the table, depending on the argument passed in.
      * @throws LuaException If an invalid locale is passed.
-     * @cc.tparam [opt] string|table locale The locale of the time, or a table filled by {@code os.date("*t")} to decode. Defaults to {@code dan200.computercraft.ingame} locale if not specified.
+     * @cc.tparam [opt] string|table locale The locale of the time, or a table filled by {@code os.date("*t")} to decode. Defaults to {@code ingame} locale if not specified.
      * @cc.see textutils.formatTime To convert times into a user-readable string.
      * @cc.usage Print the current in-game time.
      * <pre>{@code
@@ -347,14 +347,14 @@ public class OSAPI implements ILuaAPI
         Object value = args.get( 0 );
         if( value instanceof Map ) return LuaDateTime.fromTable( (Map<?, ?>) value );
 
-        String param = args.optString( 0, "dan200.computercraft.ingame" );
+        String param = args.optString( 0, "ingame" );
         switch( param.toLowerCase( Locale.ROOT ) )
         {
             case "utc": // Get Hour of day (UTC)
                 return getTimeForCalendar( Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) ) );
             case "local": // Get Hour of day (local time)
                 return getTimeForCalendar( Calendar.getInstance() );
-            case "dan200.computercraft.ingame": // Get in-game hour
+            case "ingame": // Get in-game hour
                 return time;
             default:
                 throw new LuaException( "Unsupported operation" );
@@ -364,14 +364,14 @@ public class OSAPI implements ILuaAPI
     /**
      * Returns the day depending on the locale specified.
      *
-     * * If called with {@code dan200.computercraft.ingame}, returns the number of days since the
+     * * If called with {@code ingame}, returns the number of days since the
      * world was created. This is the default.
      * * If called with {@code utc}, returns the number of days since 1 January
      * 1970 in the UTC timezone.
      * * If called with {@code local}, returns the number of days since 1
      * January 1970 in the server's local timezone.
      *
-     * @param args The locale to get the day for. Defaults to {@code dan200.computercraft.ingame} if not set.
+     * @param args The locale to get the day for. Defaults to {@code ingame} if not set.
      * @return The day depending on the selected locale.
      * @throws LuaException If an invalid locale is passed.
      * @cc.since 1.48
@@ -380,13 +380,13 @@ public class OSAPI implements ILuaAPI
     @LuaFunction
     public final int day( Optional<String> args ) throws LuaException
     {
-        switch( args.orElse( "dan200.computercraft.ingame" ).toLowerCase( Locale.ROOT ) )
+        switch( args.orElse( "ingame" ).toLowerCase( Locale.ROOT ) )
         {
             case "utc":     // Get numbers of days since 1970-01-01 (utc)
                 return getDayForCalendar( Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) ) );
             case "local": // Get numbers of days since 1970-01-01 (local time)
                 return getDayForCalendar( Calendar.getInstance() );
-            case "dan200.computercraft.ingame":// Get game day
+            case "ingame":// Get game day
                 return day;
             default:
                 throw new LuaException( "Unsupported operation" );
@@ -396,14 +396,14 @@ public class OSAPI implements ILuaAPI
     /**
      * Returns the number of milliseconds since an epoch depending on the locale.
      *
-     * * If called with {@code dan200.computercraft.ingame}, returns the number of milliseconds since the
+     * * If called with {@code ingame}, returns the number of milliseconds since the
      * world was created. This is the default.
      * * If called with {@code utc}, returns the number of milliseconds since 1
      * January 1970 in the UTC timezone.
      * * If called with {@code local}, returns the number of milliseconds since 1
      * January 1970 in the server's local timezone.
      *
-     * @param args The locale to get the milliseconds for. Defaults to {@code dan200.computercraft.ingame} if not set.
+     * @param args The locale to get the milliseconds for. Defaults to {@code ingame} if not set.
      * @return The milliseconds since the epoch depending on the selected locale.
      * @throws LuaException If an invalid locale is passed.
      * @cc.since 1.80pr1
@@ -418,7 +418,7 @@ public class OSAPI implements ILuaAPI
     @LuaFunction
     public final long epoch( Optional<String> args ) throws LuaException
     {
-        switch( args.orElse( "dan200.computercraft.ingame" ).toLowerCase( Locale.ROOT ) )
+        switch( args.orElse( "ingame" ).toLowerCase( Locale.ROOT ) )
         {
             case "utc":
             {
@@ -432,7 +432,7 @@ public class OSAPI implements ILuaAPI
                 Calendar c = Calendar.getInstance();
                 return getEpochForCalendar( c );
             }
-            case "dan200.computercraft.ingame":
+            case "ingame":
                 // Get in-game epoch
                 synchronized( alarms )
                 {
@@ -493,7 +493,7 @@ public class OSAPI implements ILuaAPI
         if( format.equals( "*t" ) ) return LuaDateTime.toTable( date, offset, instant );
 
         DateTimeFormatterBuilder formatter = new DateTimeFormatterBuilder();
-        LuaDateTime.format( formatter, format, offset );
+        LuaDateTime.format( formatter, format );
         return formatter.toFormatter( Locale.ROOT ).format( date );
     }
 

src/main/java/dan200/computercraft/core/terminal/TextBuffer.java

@@ -47,13 +47,15 @@ public class TextBuffer
     public void write( ByteBuffer text, int start )
     {
         int pos = start;
+        int bufferPos = text.position();
+
         start = Math.max( start, 0 );
         int length = text.remaining();
         int end = Math.min( start + length, pos + length );
         end = Math.min( end, this.text.length );
         for( int i = start; i < end; i++ )
         {
-            this.text[i] = (char) (text.get( i - pos ) & 0xFF);
+            this.text[i] = (char) (text.get( bufferPos + i - pos ) & 0xFF);
         }
     }
 

src/main/java/dan200/computercraft/data/Generators.java

@@ -8,9 +8,9 @@ package dan200.computercraft.data;
 import dan200.computercraft.shared.Registry;
 import net.minecraft.data.DataGenerator;
 import net.minecraftforge.common.data.ExistingFileHelper;
+import net.minecraftforge.data.event.GatherDataEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.forge.event.lifecycle.GatherDataEvent;
 
 @Mod.EventBusSubscriber( bus = Mod.EventBusSubscriber.Bus.MOD )
 public class Generators

src/main/java/dan200/computercraft/internal/upgrades/SerialiserWithCraftingItem.java

@@ -21,10 +21,9 @@ import java.util.function.BiFunction;
  *
  * Do <strong>NOT</strong> directly reference this class. It exists for internal use by the API.
  *
- * @param <R> The serialiser for this upgrade category, either {@code TurtleUpgradeSerialiser<?>} or {@code PocketUpgradeSerialiser<?>}.
  * @param <T> The upgrade that this class can serialise and deserialise.
  */
-public abstract class SerialiserWithCraftingItem<T extends IUpgradeBase, R extends UpgradeSerialiser<?, R>> implements UpgradeSerialiser<T, R>
+public abstract class SerialiserWithCraftingItem<T extends IUpgradeBase> implements UpgradeSerialiser<T>
 {
     private final BiFunction<ResourceLocation, ItemStack, T> factory;
 

src/main/java/dan200/computercraft/internal/upgrades/SimpleSerialiser.java

@@ -19,10 +19,9 @@ import java.util.function.Function;
  *
  * Do <strong>NOT</strong> directly reference this class. It exists for internal use by the API.
  *
- * @param <R> The serialiser for this upgrade category, either {@code TurtleUpgradeSerialiser<?>} or {@code PocketUpgradeSerialiser<?>}.
  * @param <T> The upgrade that this class can serialise and deserialise.
  */
-public abstract class SimpleSerialiser<T extends IUpgradeBase, R extends UpgradeSerialiser<?, R>> implements UpgradeSerialiser<T, R>
+public abstract class SimpleSerialiser<T extends IUpgradeBase> implements UpgradeSerialiser<T>
 {
     private final Function<ResourceLocation, T> constructor;
 

src/main/java/dan200/computercraft/mixin/BlockRenderDispatcherMixin.java

@@ -24,7 +24,7 @@ import net.minecraft.world.level.BlockAndTintGetter;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
-import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.data.ModelData;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -35,7 +35,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 /**
  * Provides custom block breaking progress for modems, so it only applies to the current part.
  *
- * @see BlockRenderDispatcher#renderBreakingTexture(BlockState, BlockPos, BlockAndTintGetter, PoseStack, VertexConsumer, IModelData)
+ * @see BlockRenderDispatcher#renderBreakingTexture(BlockState, BlockPos, BlockAndTintGetter, PoseStack, VertexConsumer, ModelData)
  */
 @Mixin( BlockRenderDispatcher.class )
 public class BlockRenderDispatcherMixin
@@ -53,13 +53,13 @@ public class BlockRenderDispatcherMixin
     private ModelBlockRenderer modelRenderer;
 
     @Inject(
-        method = "name=/^renderBreakingTexture/ desc=/IModelData;\\)V$/",
+        method = "name=/^renderBreakingTexture/ desc=/ModelData;\\)V$/",
         at = @At( "HEAD" ),
         cancellable = true,
         require = 0 // This isn't critical functionality, so don't worry if we can't apply it.
     )
     public void renderBlockDamage(
-        BlockState state, BlockPos pos, BlockAndTintGetter world, PoseStack pose, VertexConsumer buffers, IModelData modelData,
+        BlockState state, BlockPos pos, BlockAndTintGetter world, PoseStack pose, VertexConsumer buffers, ModelData modelData,
         CallbackInfo info
     )
     {
@@ -85,6 +85,6 @@ public class BlockRenderDispatcherMixin
 
         BakedModel model = blockModelShaper.getBlockModel( newState );
         long seed = newState.getSeed( pos );
-        modelRenderer.tesselateBlock( world, model, newState, pos, pose, buffers, true, random, seed, OverlayTexture.NO_OVERLAY, modelData );
+        modelRenderer.tesselateBlock( world, model, newState, pos, pose, buffers, true, random, seed, OverlayTexture.NO_OVERLAY, modelData, null );
     }
 }

src/main/java/dan200/computercraft/shared/CommonHooks.java

@@ -73,7 +73,7 @@ public final class CommonHooks
             IComputer computer = ((IContainerComputer) container).getComputer();
             if( computer instanceof ServerComputer )
             {
-                ((ServerComputer) computer).sendTerminalState( event.getPlayer() );
+                ((ServerComputer) computer).sendTerminalState( event.getEntity() );
             }
         }
     }

src/main/java/dan200/computercraft/shared/Config.java

@@ -5,11 +5,7 @@
  */
 package dan200.computercraft.shared;
 
-import com.electronwill.nightconfig.core.CommentedConfig;
 import com.electronwill.nightconfig.core.UnmodifiableConfig;
-import com.electronwill.nightconfig.core.file.CommentedFileConfig;
-import com.google.common.base.CaseFormat;
-import com.google.common.base.Converter;
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.core.apis.http.NetworkUtils;
 import dan200.computercraft.core.apis.http.options.Action;
@@ -150,7 +146,7 @@ public final class Config
             builder.push( "http" );
 
             httpEnabled = builder
-                .comment( "Enable the \"http\" API on Computers (see \"rules\" for more fine grained control than this)." )
+                .comment( "Enable the \"http\" API on Computers. This also disables the \"pastebin\" and \"wget\"\nprograms, that many users rely on. It's recommended to leave this on and use the\n\"rules\" config option to impose more fine-grained control." )
                 .define( "enabled", ComputerCraft.httpEnabled );
 
             httpWebsocketEnabled = builder
@@ -291,7 +287,7 @@ public final class Config
         ModLoadingContext.get().registerConfig( ModConfig.Type.CLIENT, clientSpec );
     }
 
-    public static void sync()
+    private static void syncServer()
     {
         // General
         ComputerCraft.computerSpaceLimit = computerSpaceLimit.get();
@@ -343,27 +339,30 @@ public final class Config
         ComputerCraft.pocketTermHeight = pocketTermHeight.get();
         ComputerCraft.monitorWidth = monitorWidth.get();
         ComputerCraft.monitorHeight = monitorHeight.get();
+    }
 
-        // Client
+    private static void syncClient()
+    {
         ComputerCraft.monitorRenderer = monitorRenderer.get();
         ComputerCraft.monitorDistance = monitorDistance.get();
     }
 
+    private static void sync( ModConfig config )
+    {
+        if( !config.getModId().equals( ComputerCraft.MOD_ID ) ) return;
+        if( config.getType() == ModConfig.Type.SERVER ) syncServer();
+        if( config.getType() == ModConfig.Type.CLIENT ) syncClient();
+    }
+
     @SubscribeEvent
     public static void sync( ModConfigEvent.Loading event )
     {
-        sync();
+        sync( event.getConfig() );
     }
 
     @SubscribeEvent
     public static void sync( ModConfigEvent.Reloading event )
     {
-        // Ensure file configs are reloaded. Forge should probably do this, so worth checking in the future.
-        CommentedConfig config = event.getConfig().getConfigData();
-        if( config instanceof CommentedFileConfig loadable ) loadable.load();
-
-        sync();
+        sync( event.getConfig() );
     }
-
-    private static final Converter<String, String> converter = CaseFormat.LOWER_CAMEL.converterTo( CaseFormat.UPPER_UNDERSCORE );
 }

src/main/java/dan200/computercraft/shared/Registry.java

@@ -13,7 +13,10 @@ import dan200.computercraft.api.network.wired.IWiredElement;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.pocket.PocketUpgradeSerialiser;
 import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import dan200.computercraft.shared.command.arguments.*;
+import dan200.computercraft.shared.command.arguments.ComputerArgumentType;
+import dan200.computercraft.shared.command.arguments.ComputersArgumentType;
+import dan200.computercraft.shared.command.arguments.RepeatArgumentType;
+import dan200.computercraft.shared.command.arguments.TrackingFieldArgumentType;
 import dan200.computercraft.shared.common.ColourableRecipe;
 import dan200.computercraft.shared.common.ContainerHeldItem;
 import dan200.computercraft.shared.common.DefaultBundledRedstoneProvider;
@@ -164,7 +167,7 @@ public final class Registry
 
     public static class ModBlockEntities
     {
-        static final DeferredRegister<BlockEntityType<?>> TILES = DeferredRegister.create( ForgeRegistries.BLOCK_ENTITIES, ComputerCraft.MOD_ID );
+        static final DeferredRegister<BlockEntityType<?>> TILES = DeferredRegister.create( ForgeRegistries.BLOCK_ENTITY_TYPES, ComputerCraft.MOD_ID );
 
         private static <T extends BlockEntity> RegistryObject<BlockEntityType<T>> ofBlock( RegistryObject<? extends Block> block, FixedPointTileEntityType.FixedPointBlockEntitySupplier<T> factory )
         {
@@ -283,7 +286,7 @@ public final class Registry
 
     public static class ModContainers
     {
-        static final DeferredRegister<MenuType<?>> CONTAINERS = DeferredRegister.create( ForgeRegistries.CONTAINERS, ComputerCraft.MOD_ID );
+        static final DeferredRegister<MenuType<?>> CONTAINERS = DeferredRegister.create( ForgeRegistries.MENU_TYPES, ComputerCraft.MOD_ID );
 
         public static final RegistryObject<MenuType<ContainerComputerBase>> COMPUTER = CONTAINERS.register( "computer",
             () -> ContainerData.toType( ComputerContainerData::new, ComputerMenuWithoutInventory::new ) );
@@ -317,7 +320,7 @@ public final class Registry
         @SuppressWarnings( "unchecked" )
         private static <T extends ArgumentType<?>> void registerUnsafe( String name, Class<T> type, ArgumentTypeInfo<?, ?> serializer )
         {
-            ARGUMENT_TYPES.register( name, () -> ArgumentTypeInfos.registerByClass( type, (ArgumentTypeInfo<T, ?>)serializer ) );
+            ARGUMENT_TYPES.register( name, () -> ArgumentTypeInfos.registerByClass( type, (ArgumentTypeInfo<T, ?>) serializer ) );
         }
 
         private static <T extends ArgumentType<?>> void register( String name, Class<T> type, ArgumentTypeInfo<T, ?> serializer )

src/main/java/dan200/computercraft/shared/UpgradeManager.java

@@ -37,12 +37,12 @@ import java.util.stream.Collectors;
  * @see TurtleUpgrades
  * @see PocketUpgrades
  */
-public class UpgradeManager<R extends UpgradeSerialiser<? extends T, R>, T extends IUpgradeBase> extends SimpleJsonResourceReloadListener
+public class UpgradeManager<R extends UpgradeSerialiser<? extends T>, T extends IUpgradeBase> extends SimpleJsonResourceReloadListener
 {
     private static final Logger LOGGER = LogManager.getLogger();
-    private static final Gson GSON = (new GsonBuilder()).setPrettyPrinting().disableHtmlEscaping().create();
+    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
 
-    public static record UpgradeWrapper<R extends UpgradeSerialiser<? extends T, R>, T extends IUpgradeBase>(
+    public record UpgradeWrapper<R extends UpgradeSerialiser<? extends T>, T extends IUpgradeBase>(
         @Nonnull String id, @Nonnull T upgrade, @Nonnull R serialiser, @Nonnull String modId
     ) {}
 
@@ -66,6 +66,12 @@ public class UpgradeManager<R extends UpgradeSerialiser<? extends T, R>, T exten
         return wrapper == null ? null : wrapper.upgrade();
     }
 
+    @Nullable
+    public UpgradeWrapper<R, T> getWrapper( @Nonnull T upgrade )
+    {
+        return currentWrappers.get( upgrade );
+    }
+
     @Nullable
     public String getOwner( @Nonnull T upgrade )
     {

src/main/java/dan200/computercraft/shared/command/CommandComputerCraft.java

@@ -56,10 +56,6 @@ public final class CommandComputerCraft
 {
     public static final UUID SYSTEM_UUID = new UUID( 0, 0 );
 
-    private static final int DUMP_LIST_ID = 5373952;
-    private static final int DUMP_SINGLE_ID = 1844510720;
-    private static final int TRACK_ID = 373882880;
-
     private CommandComputerCraft()
     {
     }
@@ -70,7 +66,7 @@ public final class CommandComputerCraft
             .then( literal( "dump" )
                 .requires( UserLevel.OWNER_OP )
                 .executes( context -> {
-                    TableBuilder table = new TableBuilder( DUMP_LIST_ID, "Computer", "On", "Position" );
+                    TableBuilder table = new TableBuilder( "DumpAll", "Computer", "On", "Position" );
 
                     CommandSourceStack source = context.getSource();
                     List<ServerComputer> computers = new ArrayList<>( ComputerCraft.serverComputerRegistry.getComputers() );
@@ -115,7 +111,7 @@ public final class CommandComputerCraft
                     .executes( context -> {
                         ServerComputer computer = getComputerArgument( context, "computer" );
 
-                        TableBuilder table = new TableBuilder( DUMP_SINGLE_ID );
+                        TableBuilder table = new TableBuilder( "Dump" );
                         table.row( header( "Instance" ), text( Integer.toString( computer.getInstanceID() ) ) );
                         table.row( header( "Id" ), text( Integer.toString( computer.getID() ) ) );
                         table.row( header( "Label" ), text( computer.getLabel() ) );
@@ -392,7 +388,7 @@ public final class CommandComputerCraft
         Component[] headers = new Component[1 + fields.size()];
         headers[0] = translate( "commands.computercraft.track.dump.computer" );
         for( int i = 0; i < fields.size(); i++ ) headers[i + 1] = translate( fields.get( i ).translationKey() );
-        TableBuilder table = new TableBuilder( TRACK_ID, headers );
+        TableBuilder table = new TableBuilder( "Metrics", headers );
 
         for( ComputerTracker entry : timings )
         {

src/main/java/dan200/computercraft/shared/command/arguments/ArgumentUtils.java

@@ -10,9 +10,9 @@ import com.mojang.brigadier.Message;
 import com.mojang.brigadier.arguments.ArgumentType;
 import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
 import net.minecraft.commands.synchronization.ArgumentTypeInfo;
-import net.minecraft.core.Registry;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
+import net.minecraftforge.registries.ForgeRegistries;
 
 import java.util.Objects;
 
@@ -27,7 +27,7 @@ public class ArgumentUtils
     {
         JsonObject object = new JsonObject();
         object.addProperty( "type", "argument" );
-        object.addProperty( "parser", Registry.COMMAND_ARGUMENT_TYPE.getKey( template.type() ).toString() );
+        object.addProperty( "parser", ForgeRegistries.COMMAND_ARGUMENT_TYPES.getKey( template.type() ).toString() );
 
         var properties = new JsonObject();
         serializeToJson( properties, template.type(), template );
@@ -50,13 +50,13 @@ public class ArgumentUtils
     @SuppressWarnings( "unchecked" )
     private static <A extends ArgumentType<?>, T extends ArgumentTypeInfo.Template<A>> void serializeToNetwork( FriendlyByteBuf buffer, ArgumentTypeInfo<A, T> type, ArgumentTypeInfo.Template<A> template )
     {
-        buffer.writeVarInt( Registry.COMMAND_ARGUMENT_TYPE.getId( type ) );
+        buffer.writeRegistryIdUnsafe( ForgeRegistries.COMMAND_ARGUMENT_TYPES, type );
         type.serializeToNetwork( (T) template, buffer );
     }
 
     public static ArgumentTypeInfo.Template<?> deserialize( FriendlyByteBuf buffer )
     {
-        var type = Registry.COMMAND_ARGUMENT_TYPE.byId( buffer.readVarInt() );
+        var type = buffer.readRegistryIdUnsafe( ForgeRegistries.COMMAND_ARGUMENT_TYPES );
         Objects.requireNonNull( type, "Unknown argument type" );
         return type.deserializeFromNetwork( buffer );
     }

src/main/java/dan200/computercraft/shared/command/arguments/RepeatArgumentType.java

@@ -145,6 +145,7 @@ public final class RepeatArgumentType<T, U> implements ArgumentType<List<T>>
             return new RepeatArgumentType.Template( this, child, isList, new SimpleCommandExceptionType( message ) );
         }
 
+        @Nonnull
         @Override
         public RepeatArgumentType.Template unpack( RepeatArgumentType<?, ?> argumentType )
         {
@@ -164,6 +165,7 @@ public final class RepeatArgumentType<T, U> implements ArgumentType<List<T>>
         Info info, ArgumentTypeInfo.Template<?> child, boolean flatten, SimpleCommandExceptionType some
     ) implements ArgumentTypeInfo.Template<RepeatArgumentType<?, ?>>
     {
+        @Nonnull
         @Override
         @SuppressWarnings( { "unchecked", "rawtypes" } )
         public RepeatArgumentType<?, ?> instantiate( @NotNull CommandBuildContext commandBuildContext )
@@ -172,6 +174,7 @@ public final class RepeatArgumentType<T, U> implements ArgumentType<List<T>>
             return flatten ? RepeatArgumentType.someFlat( (ArgumentType) child, some() ) : RepeatArgumentType.some( child, some() );
         }
 
+        @Nonnull
         @Override
         public ArgumentTypeInfo<RepeatArgumentType<?, ?>, ?> type()
         {

src/main/java/dan200/computercraft/shared/command/text/ServerTableFormatter.java

@@ -42,7 +42,7 @@ public class ServerTableFormatter implements TableFormatter
     }
 
     @Override
-    public void writeLine( int id, Component component )
+    public void writeLine( String label, Component component )
     {
         source.sendSuccess( component, false );
     }

src/main/java/dan200/computercraft/shared/command/text/TableBuilder.java

@@ -19,30 +19,27 @@ import java.util.List;
 
 public class TableBuilder
 {
-    private final int id;
+    private final String id;
     private int columns = -1;
     private final Component[] headers;
     private final ArrayList<Component[]> rows = new ArrayList<>();
     private int additional;
 
-    public TableBuilder( int id, @Nonnull Component... headers )
+    public TableBuilder( @Nonnull String id, @Nonnull Component... headers )
     {
-        if( id < 0 ) throw new IllegalArgumentException( "ID must be positive" );
         this.id = id;
         this.headers = headers;
         columns = headers.length;
     }
 
-    public TableBuilder( int id )
+    public TableBuilder( @Nonnull String id )
     {
-        if( id < 0 ) throw new IllegalArgumentException( "ID must be positive" );
         this.id = id;
         headers = null;
     }
 
-    public TableBuilder( int id, @Nonnull String... headers )
+    public TableBuilder( @Nonnull String id, @Nonnull String... headers )
     {
-        if( id < 0 ) throw new IllegalArgumentException( "ID must be positive" );
         this.id = id;
         this.headers = new Component[headers.length];
         columns = headers.length;
@@ -65,7 +62,7 @@ public class TableBuilder
      *
      * @return This table's type.
      */
-    public int getId()
+    public String getId()
     {
         return id;
     }

src/main/java/dan200/computercraft/shared/command/text/TableFormatter.java

@@ -39,13 +39,13 @@ public interface TableFormatter
 
     int getWidth( Component component );
 
-    void writeLine( int id, Component component );
+    void writeLine( String label, Component component );
 
-    default int display( TableBuilder table )
+    default void display( TableBuilder table )
     {
-        if( table.getColumns() <= 0 ) return 0;
+        if( table.getColumns() <= 0 ) return;
 
-        int rowId = table.getId();
+        String id = table.getId();
         int columns = table.getColumns();
         int[] maxWidths = new int[columns];
 
@@ -86,13 +86,13 @@ public interface TableFormatter
             }
             line.append( headers[columns - 1] );
 
-            writeLine( rowId++, line );
+            writeLine( id, line );
 
             // Write a separator line. We round the width up rather than down to make
             // it a tad prettier.
             int rowCharWidth = getWidth( HEADER );
             int rowWidth = totalWidth / rowCharWidth + (totalWidth % rowCharWidth == 0 ? 0 : 1);
-            writeLine( rowId++, coloured( StringUtils.repeat( HEADER.getString(), rowWidth ), ChatFormatting.GRAY ) );
+            writeLine( id, coloured( StringUtils.repeat( HEADER.getString(), rowWidth ), ChatFormatting.GRAY ) );
         }
 
         for( Component[] row : table.getRows() )
@@ -106,14 +106,12 @@ public interface TableFormatter
                 line.append( SEPARATOR );
             }
             line.append( row[columns - 1] );
-            writeLine( rowId++, line );
+            writeLine( id, line );
         }
 
         if( table.getAdditional() > 0 )
         {
-            writeLine( rowId++, coloured( translate( "commands.computercraft.generic.additional_rows", table.getAdditional() ), ChatFormatting.AQUA ) );
+            writeLine( id, coloured( translate( "commands.computercraft.generic.additional_rows", table.getAdditional() ), ChatFormatting.AQUA ) );
         }
-
-        return rowId - table.getId();
     }
 }

src/main/java/dan200/computercraft/shared/computer/apis/CommandAPI.java

@@ -63,7 +63,7 @@ public class CommandAPI implements ILuaAPI
         try
         {
             receiver.clearOutput();
-            int result = commandManager.performCommand( computer.getSource(), command );
+            int result = commandManager.performPrefixedCommand( computer.getSource(), command );
             return new Object[] { result > 0, receiver.copyOutput(), result };
         }
         catch( Throwable t )

src/main/java/dan200/computercraft/shared/integration/ShaderMod.java

@@ -0,0 +1,96 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+package dan200.computercraft.shared.integration;
+
+import com.mojang.blaze3d.vertex.VertexFormat;
+import dan200.computercraft.client.render.RenderTypes;
+import dan200.computercraft.client.render.text.DirectFixedWidthFontRenderer;
+import net.irisshaders.iris.api.v0.IrisApi;
+import net.irisshaders.iris.api.v0.IrisTextVertexSink;
+import net.minecraftforge.fml.ModList;
+
+import java.nio.ByteBuffer;
+import java.util.function.IntFunction;
+
+public class ShaderMod
+{
+    public static final ShaderMod INSTANCE
+        = ModList.get().isLoaded( "oculus" ) ? new IrisImpl()
+        : new ShaderMod();
+
+    public boolean isShaderMod()
+    {
+        return Optifine.isLoaded();
+    }
+
+    public boolean isRenderingShadowPass()
+    {
+        return false;
+    }
+
+    public DirectFixedWidthFontRenderer.QuadEmitter getQuadEmitter( int vertexCount, IntFunction<ByteBuffer> makeBuffer )
+    {
+        return new DirectFixedWidthFontRenderer.ByteBufferEmitter(
+            makeBuffer.apply( RenderTypes.TERMINAL.format().getVertexSize() * vertexCount * 4 )
+        );
+    }
+
+    private static final class IrisImpl extends ShaderMod
+    {
+        @Override
+        public boolean isRenderingShadowPass()
+        {
+            return IrisApi.getInstance().isRenderingShadowPass();
+        }
+
+        @Override
+        public boolean isShaderMod()
+        {
+            return true;
+        }
+
+        @Override
+        public DirectFixedWidthFontRenderer.QuadEmitter getQuadEmitter( int vertexCount, IntFunction<ByteBuffer> makeBuffer )
+        {
+            return IrisApi.getInstance().getMinorApiRevision() >= 1
+                ? new IrisQuadEmitter( vertexCount, makeBuffer )
+                : super.getQuadEmitter( vertexCount, makeBuffer );
+        }
+
+        private static final class IrisQuadEmitter implements DirectFixedWidthFontRenderer.QuadEmitter
+        {
+            private final IrisTextVertexSink sink;
+
+            private IrisQuadEmitter( int vertexCount, IntFunction<ByteBuffer> makeBuffer )
+            {
+                sink = IrisApi.getInstance().createTextVertexSink( vertexCount, makeBuffer );
+            }
+
+            @Override
+            public VertexFormat format()
+            {
+                return sink.getUnderlyingVertexFormat();
+            }
+
+            @Override
+            public ByteBuffer buffer()
+            {
+                return sink.getUnderlyingByteBuffer();
+            }
+
+            @Override
+            public void quad( float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2 )
+            {
+                sink.quad( x1, y1, x2, y2, z, pack( rgba[0], rgba[1], rgba[2], rgba[3] ), u1, v1, u2, v2, RenderTypes.FULL_BRIGHT_LIGHTMAP );
+            }
+
+            private static int pack( int r, int g, int b, int a )
+            {
+                return (a & 255) << 24 | (b & 255) << 16 | (g & 255) << 8 | r & 255;
+            }
+        }
+    }
+}

src/main/java/dan200/computercraft/shared/integration/jei/JEIComputerCraft.java

@@ -20,21 +20,22 @@ import dan200.computercraft.shared.turtle.items.ITurtleItem;
 import dan200.computercraft.shared.turtle.items.TurtleItemFactory;
 import mezz.jei.api.IModPlugin;
 import mezz.jei.api.JeiPlugin;
-import mezz.jei.api.constants.VanillaRecipeCategoryUid;
+import mezz.jei.api.constants.RecipeTypes;
 import mezz.jei.api.constants.VanillaTypes;
 import mezz.jei.api.ingredients.subtypes.IIngredientSubtypeInterpreter;
+import mezz.jei.api.recipe.IRecipeLookup;
 import mezz.jei.api.recipe.IRecipeManager;
-import mezz.jei.api.recipe.category.IRecipeCategory;
 import mezz.jei.api.registration.IAdvancedRegistration;
 import mezz.jei.api.registration.ISubtypeRegistration;
 import mezz.jei.api.runtime.IJeiRuntime;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.crafting.Recipe;
+import net.minecraft.world.item.crafting.CraftingRecipe;
 
 import javax.annotation.Nonnull;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import static dan200.computercraft.shared.integration.jei.RecipeResolver.MAIN_FAMILIES;
@@ -52,13 +53,13 @@ public class JEIComputerCraft implements IModPlugin
     @Override
     public void registerItemSubtypes( ISubtypeRegistration subtypeRegistry )
     {
-        subtypeRegistry.registerSubtypeInterpreter( Registry.ModItems.TURTLE_NORMAL.get(), turtleSubtype );
-        subtypeRegistry.registerSubtypeInterpreter( Registry.ModItems.TURTLE_ADVANCED.get(), turtleSubtype );
+        subtypeRegistry.registerSubtypeInterpreter( VanillaTypes.ITEM_STACK, Registry.ModItems.TURTLE_NORMAL.get(), turtleSubtype );
+        subtypeRegistry.registerSubtypeInterpreter( VanillaTypes.ITEM_STACK, Registry.ModItems.TURTLE_ADVANCED.get(), turtleSubtype );
 
-        subtypeRegistry.registerSubtypeInterpreter( Registry.ModItems.POCKET_COMPUTER_NORMAL.get(), pocketSubtype );
-        subtypeRegistry.registerSubtypeInterpreter( Registry.ModItems.POCKET_COMPUTER_ADVANCED.get(), pocketSubtype );
+        subtypeRegistry.registerSubtypeInterpreter( VanillaTypes.ITEM_STACK, Registry.ModItems.POCKET_COMPUTER_NORMAL.get(), pocketSubtype );
+        subtypeRegistry.registerSubtypeInterpreter( VanillaTypes.ITEM_STACK, Registry.ModItems.POCKET_COMPUTER_ADVANCED.get(), pocketSubtype );
 
-        subtypeRegistry.registerSubtypeInterpreter( Registry.ModItems.DISK.get(), diskSubtype );
+        subtypeRegistry.registerSubtypeInterpreter( VanillaTypes.ITEM_STACK, Registry.ModItems.DISK.get(), diskSubtype );
     }
 
     @Override
@@ -89,27 +90,22 @@ public class JEIComputerCraft implements IModPlugin
 
         if( !upgradeItems.isEmpty() )
         {
-            runtime.getIngredientManager().addIngredientsAtRuntime( VanillaTypes.ITEM, upgradeItems );
+            runtime.getIngredientManager().addIngredientsAtRuntime( VanillaTypes.ITEM_STACK, upgradeItems );
         }
 
         // Hide all upgrade recipes
-        IRecipeCategory<?> category = registry.getRecipeCategory( VanillaRecipeCategoryUid.CRAFTING, false );
-        if( category != null )
-        {
-            for( Object wrapper : registry.getRecipes( category, List.of(), false ) )
-            {
-                if( !(wrapper instanceof Recipe) ) continue;
-                ResourceLocation id = ((Recipe<?>) wrapper).getId();
-                if( !id.getNamespace().equals( ComputerCraft.MOD_ID ) ) continue;
+        IRecipeLookup<CraftingRecipe> category = registry.createRecipeLookup( RecipeTypes.CRAFTING );
+        category.get().forEach( wrapper -> {
+            ResourceLocation id = wrapper.getId();
+            if( !id.getNamespace().equals( ComputerCraft.MOD_ID ) ) return;
 
-                String path = id.getPath();
-                if( path.startsWith( "turtle_normal/" ) || path.startsWith( "turtle_advanced/" )
-                    || path.startsWith( "pocket_normal/" ) || path.startsWith( "pocket_advanced/" ) )
-                {
-                    registry.hideRecipe( wrapper, VanillaRecipeCategoryUid.CRAFTING );
-                }
+            String path = id.getPath();
+            if( path.startsWith( "turtle_normal/" ) || path.startsWith( "turtle_advanced/" )
+                || path.startsWith( "pocket_normal/" ) || path.startsWith( "pocket_advanced/" ) )
+            {
+                registry.hideRecipes( RecipeTypes.CRAFTING, Collections.singleton( wrapper ) );
             }
-        }
+        } );
     }
 
     /**

src/main/java/dan200/computercraft/shared/integration/jei/RecipeResolver.java

@@ -6,10 +6,10 @@
 package dan200.computercraft.shared.integration.jei;
 
 import dan200.computercraft.ComputerCraft;
-import dan200.computercraft.api.upgrades.IUpgradeBase;
 import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
+import dan200.computercraft.api.upgrades.IUpgradeBase;
 import dan200.computercraft.shared.PocketUpgrades;
 import dan200.computercraft.shared.TurtleUpgrades;
 import dan200.computercraft.shared.computer.core.ComputerFamily;
@@ -17,8 +17,9 @@ import dan200.computercraft.shared.pocket.items.ItemPocketComputer;
 import dan200.computercraft.shared.pocket.items.PocketComputerItemFactory;
 import dan200.computercraft.shared.turtle.items.ITurtleItem;
 import dan200.computercraft.shared.turtle.items.TurtleItemFactory;
-import mezz.jei.api.constants.VanillaRecipeCategoryUid;
+import mezz.jei.api.constants.RecipeTypes;
 import mezz.jei.api.recipe.IFocus;
+import mezz.jei.api.recipe.RecipeType;
 import mezz.jei.api.recipe.advanced.IRecipeManagerPlugin;
 import mezz.jei.api.recipe.category.IRecipeCategory;
 import net.minecraft.core.NonNullList;
@@ -95,7 +96,7 @@ class RecipeResolver implements IRecipeManagerPlugin
 
     @Nonnull
     @Override
-    public <V> List<ResourceLocation> getRecipeCategoryUids( @Nonnull IFocus<V> focus )
+    public <V> List<RecipeType<?>> getRecipeTypes( @Nonnull IFocus<V> focus )
     {
         V value = focus.getTypedValue().getIngredient();
         if( !(value instanceof ItemStack stack) ) return Collections.emptyList();
@@ -105,11 +106,11 @@ class RecipeResolver implements IRecipeManagerPlugin
             case INPUT:
                 return stack.getItem() instanceof ITurtleItem || stack.getItem() instanceof ItemPocketComputer ||
                     hasUpgrade( stack )
-                    ? Collections.singletonList( VanillaRecipeCategoryUid.CRAFTING )
+                    ? Collections.singletonList( RecipeTypes.CRAFTING )
                     : Collections.emptyList();
             case OUTPUT:
                 return stack.getItem() instanceof ITurtleItem || stack.getItem() instanceof ItemPocketComputer
-                    ? Collections.singletonList( VanillaRecipeCategoryUid.CRAFTING )
+                    ? Collections.singletonList( RecipeTypes.CRAFTING )
                     : Collections.emptyList();
             default:
                 return Collections.emptyList();
@@ -120,7 +121,7 @@ class RecipeResolver implements IRecipeManagerPlugin
     @Override
     public <T, V> List<T> getRecipes( @Nonnull IRecipeCategory<T> recipeCategory, @Nonnull IFocus<V> focus )
     {
-        if( !(focus.getTypedValue().getIngredient() instanceof ItemStack stack) || !recipeCategory.getUid().equals( VanillaRecipeCategoryUid.CRAFTING ) )
+        if( !(focus.getTypedValue().getIngredient() instanceof ItemStack stack) || recipeCategory.getRecipeType() != RecipeTypes.CRAFTING )
         {
             return Collections.emptyList();
         }

src/main/java/dan200/computercraft/shared/network/NetworkHandler.java

@@ -9,6 +9,8 @@ import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.shared.network.client.*;
 import dan200.computercraft.shared.network.server.*;
+import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import it.unimi.dsi.fastutil.ints.IntSet;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
@@ -26,7 +28,8 @@ import java.util.function.Function;
 
 public final class NetworkHandler
 {
-    public static SimpleChannel network;
+    private static SimpleChannel network;
+    private static final IntSet usedIds = new IntOpenHashSet();
 
     private NetworkHandler()
     {
@@ -61,7 +64,7 @@ public final class NetworkHandler
         registerMainThread( 18, NetworkDirection.PLAY_TO_CLIENT, SpeakerPlayClientMessage.class, SpeakerPlayClientMessage::new );
         registerMainThread( 19, NetworkDirection.PLAY_TO_CLIENT, SpeakerStopClientMessage.class, SpeakerStopClientMessage::new );
         registerMainThread( 20, NetworkDirection.PLAY_TO_CLIENT, UploadResultMessage.class, UploadResultMessage::new );
-        registerMainThread( 20, NetworkDirection.PLAY_TO_CLIENT, UpgradesLoadedMessage.class, UpgradesLoadedMessage::new );
+        registerMainThread( 21, NetworkDirection.PLAY_TO_CLIENT, UpgradesLoadedMessage.class, UpgradesLoadedMessage::new );
     }
 
     public static void sendToPlayer( Player player, NetworkMessage packet )
@@ -101,10 +104,11 @@ public final class NetworkHandler
      */
     private static <T extends NetworkMessage> void registerMainThread( int id, NetworkDirection direction, Class<T> type, Function<FriendlyByteBuf, T> decoder )
     {
+        if( !usedIds.add( id ) ) throw new IllegalStateException( "Duplicate message kind for for id " + id );
         network.messageBuilder( type, id, direction )
             .encoder( NetworkMessage::toBytes )
             .decoder( decoder )
-            .consumer( ( packet, contextSup ) -> {
+            .consumerMainThread( ( packet, contextSup ) -> {
                 NetworkEvent.Context context = contextSup.get();
                 context.enqueueWork( () -> packet.handle( context ) );
                 context.setPacketHandled( true );

src/main/java/dan200/computercraft/shared/network/client/ChatTableClientMessage.java

@@ -16,6 +16,7 @@ import javax.annotation.Nonnull;
 
 public class ChatTableClientMessage implements NetworkMessage
 {
+    private static final int MAX_LEN = 16;
     private final TableBuilder table;
 
     public ChatTableClientMessage( TableBuilder table )
@@ -26,7 +27,7 @@ public class ChatTableClientMessage implements NetworkMessage
 
     public ChatTableClientMessage( @Nonnull FriendlyByteBuf buf )
     {
-        int id = buf.readVarInt();
+        String id = buf.readUtf( MAX_LEN );
         int columns = buf.readVarInt();
         TableBuilder table;
         if( buf.readBoolean() )
@@ -55,7 +56,7 @@ public class ChatTableClientMessage implements NetworkMessage
     @Override
     public void toBytes( @Nonnull FriendlyByteBuf buf )
     {
-        buf.writeVarInt( table.getId() );
+        buf.writeUtf( table.getId(), MAX_LEN );
         buf.writeVarInt( table.getColumns() );
         buf.writeBoolean( table.getHeaders() != null );
         if( table.getHeaders() != null )

src/main/java/dan200/computercraft/shared/network/client/UpgradesLoadedMessage.java

@@ -46,7 +46,7 @@ public class UpgradesLoadedMessage implements NetworkMessage
         pocketUpgrades = fromBytes( buf, RegistryManager.ACTIVE.getRegistry( PocketUpgradeSerialiser.REGISTRY_ID ) );
     }
 
-    private <R extends UpgradeSerialiser<? extends T, R>, T extends IUpgradeBase> Map<String, UpgradeManager.UpgradeWrapper<R, T>> fromBytes(
+    private <R extends UpgradeSerialiser<? extends T>, T extends IUpgradeBase> Map<String, UpgradeManager.UpgradeWrapper<R, T>> fromBytes(
         @Nonnull FriendlyByteBuf buf, @Nonnull IForgeRegistry<R> registry
     )
     {
@@ -76,7 +76,7 @@ public class UpgradesLoadedMessage implements NetworkMessage
         toBytes( buf, PocketUpgradeSerialiser.registry(), pocketUpgrades );
     }
 
-    private <R extends UpgradeSerialiser<? extends T, R>, T extends IUpgradeBase> void toBytes(
+    private <R extends UpgradeSerialiser<? extends T>, T extends IUpgradeBase> void toBytes(
         @Nonnull FriendlyByteBuf buf, IForgeRegistry<R> registry, Map<String, UpgradeManager.UpgradeWrapper<R, T>> upgrades
     )
     {
@@ -87,7 +87,7 @@ public class UpgradesLoadedMessage implements NetworkMessage
 
             var serialiser = entry.getValue().serialiser();
             @SuppressWarnings( "unchecked" )
-            var unwrapedSerialiser = (UpgradeSerialiser<T, R>) serialiser;
+            var unwrapedSerialiser = (UpgradeSerialiser<T>) serialiser;
 
             buf.writeResourceLocation( Objects.requireNonNull( registry.getKey( serialiser ), "Serialiser is not registered!" ) );
             unwrapedSerialiser.toNetwork( buf, entry.getValue().upgrade() );

src/main/java/dan200/computercraft/shared/network/container/ContainerData.java

@@ -30,7 +30,7 @@ public interface ContainerData
 
     default void open( Player player, MenuProvider owner )
     {
-        NetworkHooks.openGui( (ServerPlayer) player, owner, this::toBytes );
+        NetworkHooks.openScreen( (ServerPlayer) player, owner, this::toBytes );
     }
 
     static <C extends AbstractContainerMenu, T extends ContainerData> MenuType<C> toType( Function<FriendlyByteBuf, T> reader, Factory<C, T> factory )

src/main/java/dan200/computercraft/shared/peripheral/diskdrive/TileDiskDrive.java

@@ -58,7 +58,7 @@ public final class TileDiskDrive extends TileGeneric implements DefaultInventory
     }
 
     Component customName;
-    private LockCode lockCode;
+    private LockCode lockCode = LockCode.NO_LOCK;
 
     private final Map<IComputerAccess, MountInfo> computers = new HashMap<>();
 
@@ -120,7 +120,7 @@ public final class TileDiskDrive extends TileGeneric implements DefaultInventory
             // Open the GUI
             if( !getLevel().isClientSide && isUsable( player ) )
             {
-                NetworkHooks.openGui( (ServerPlayer) player, this );
+                NetworkHooks.openScreen( (ServerPlayer) player, this );
             }
             return InteractionResult.SUCCESS;
         }

src/main/java/dan200/computercraft/shared/peripheral/generic/GenericPeripheral.java

@@ -30,7 +30,7 @@ class GenericPeripheral implements IDynamicPeripheral
 
     GenericPeripheral( BlockEntity tile, String name, Set<String> additionalTypes, List<SaturatedMethod> methods )
     {
-        ResourceLocation type = ForgeRegistries.BLOCK_ENTITIES.getKey( tile.getType() );
+        ResourceLocation type = ForgeRegistries.BLOCK_ENTITY_TYPES.getKey( tile.getType() );
         this.tile = tile;
         this.type = name != null ? name : (type != null ? type.toString() : "unknown");
         this.additionalTypes = additionalTypes;

src/main/java/dan200/computercraft/shared/peripheral/generic/data/ItemData.java

@@ -67,6 +67,7 @@ public class ItemData
         }
 
         data.put( "tags", DataHelpers.getTags( stack.getTags() ) );
+        data.put( "itemGroups", getItemGroups( stack ) );
 
         CompoundTag tag = stack.getTag();
         if( tag != null && tag.contains( "display", Tag.TAG_COMPOUND ) )
@@ -116,6 +117,30 @@ public class ItemData
         }
     }
 
+    /**
+     * Retrieve all item groups an item stack pertains to.
+     *
+     * @param stack Stack to analyse
+     * @return A filled list that contains pairs of item group IDs and their display names.
+     */
+    @Nonnull
+    private static List<Map<String, Object>> getItemGroups( @Nonnull ItemStack stack )
+    {
+        List<Map<String, Object>> groups = new ArrayList<>( 1 );
+
+        for( var group : stack.getItem().getCreativeTabs() )
+        {
+            if( group == null ) continue;
+
+            Map<String, Object> groupData = new HashMap<>( 2 );
+            groupData.put( "id", group.langId );
+            groupData.put( "displayName", group.getDisplayName().getString() );
+            groups.add( groupData );
+        }
+
+        return groups;
+    }
+
     /**
      * Retrieve all visible enchantments from given stack. Try to follow all tooltip rules : order and visibility.
      *

src/main/java/dan200/computercraft/shared/peripheral/generic/methods/InventoryMethods.java

@@ -109,7 +109,9 @@ public class InventoryMethods implements GenericPeripheral
      *
      * The returned information contains the same information as each item in
      * {@link #list}, as well as additional details like the display name
-     * (`displayName`) and item durability (`damage`, `maxDamage`, `durability`).
+     * (`displayName`), item groups (`itemGroups`), which are the creative tabs
+     * an item will appear under, and item and item durability (`damage`,
+     * `maxDamage`, `durability`).
      *
      * Some items include more information (such as enchantments) - it is
      * recommended to print it out using @{textutils.serialize} or in the Lua
@@ -129,6 +131,11 @@ public class InventoryMethods implements GenericPeripheral
      *
      * print(("%s (%s)"):format(item.displayName, item.name))
      * print(("Count: %d/%d"):format(item.count, item.maxCount))
+     *
+     * for _, group in pairs(item.itemGroups) do
+     *   print(("Group: %s"):format(group.displayName))
+     * end
+     *
      * if item.damage then
      *   print(("Damage: %d/%d"):format(item.damage, item.maxDamage))
      * end
@@ -168,7 +175,7 @@ public class InventoryMethods implements GenericPeripheral
     public static int getItemLimit( IItemHandler inventory, int slot ) throws LuaException
     {
         assertBetween( slot, 1, inventory.getSlots(), "Slot out of range (%s)" );
-        return inventory.getSlotLimit( slot );
+        return inventory.getSlotLimit( slot - 1 );
     }
 
     /**

src/main/java/dan200/computercraft/shared/peripheral/monitor/ClientMonitor.java

@@ -33,7 +33,8 @@ public final class ClientMonitor extends ClientTerminal
     public int tboBuffer;
     public int tboTexture;
     public int tboUniform;
-    public DirectVertexBuffer buffer;
+    public DirectVertexBuffer backgroundBuffer;
+    public DirectVertexBuffer foregroundBuffer;
 
     public ClientMonitor( boolean colour, TileMonitor origin )
     {
@@ -79,10 +80,11 @@ public final class ClientMonitor extends ClientTerminal
             }
 
             case VBO:
-                if( buffer != null ) return false;
+                if( backgroundBuffer != null ) return false;
 
                 deleteBuffers();
-                buffer = new DirectVertexBuffer();
+                backgroundBuffer = new DirectVertexBuffer();
+                foregroundBuffer = new DirectVertexBuffer();
                 addMonitor();
                 return true;
 
@@ -120,17 +122,23 @@ public final class ClientMonitor extends ClientTerminal
             tboUniform = 0;
         }
 
-        if( buffer != null )
+        if( backgroundBuffer != null )
         {
-            buffer.close();
-            buffer = null;
+            backgroundBuffer.close();
+            backgroundBuffer = null;
+        }
+
+        if( foregroundBuffer != null )
+        {
+            foregroundBuffer.close();
+            foregroundBuffer = null;
         }
     }
 
     @OnlyIn( Dist.CLIENT )
     public void destroy()
     {
-        if( tboBuffer != 0 || buffer != null )
+        if( tboBuffer != 0 || backgroundBuffer != null )
         {
             synchronized( allMonitors )
             {

src/main/java/dan200/computercraft/shared/peripheral/monitor/MonitorRenderer.java

@@ -7,7 +7,7 @@ package dan200.computercraft.shared.peripheral.monitor;
 
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.client.render.TileEntityMonitorRenderer;
-import dan200.computercraft.shared.integration.Optifine;
+import dan200.computercraft.shared.integration.ShaderMod;
 import org.lwjgl.opengl.GL;
 
 import javax.annotation.Nonnull;
@@ -60,7 +60,7 @@ public enum MonitorRenderer
             return VBO;
         }
 
-        if( Optifine.isLoaded() )
+        if( ShaderMod.INSTANCE.isShaderMod() )
         {
             ComputerCraft.log.warn( "Optifine is loaded, assuming shaders are being used. Falling back to VBO monitor renderer." );
             return VBO;

src/main/java/dan200/computercraft/shared/peripheral/monitor/MonitorWatcher.java

@@ -11,13 +11,11 @@ import dan200.computercraft.shared.network.client.MonitorClientMessage;
 import dan200.computercraft.shared.network.client.TerminalState;
 import net.minecraft.core.BlockPos;
 import net.minecraft.server.level.ServerLevel;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.level.ChunkPos;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.chunk.LevelChunk;
 import net.minecraftforge.event.TickEvent;
-import net.minecraftforge.event.world.ChunkWatchEvent;
+import net.minecraftforge.event.level.ChunkWatchEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
 
@@ -28,7 +26,6 @@ import java.util.Queue;
 public final class MonitorWatcher
 {
     private static final Queue<TileMonitor> watching = new ArrayDeque<>();
-    private static final Queue<PlayerUpdate> playerUpdates = new ArrayDeque<>();
 
     private MonitorWatcher()
     {
@@ -46,47 +43,28 @@ public final class MonitorWatcher
     @SubscribeEvent
     public static void onWatch( ChunkWatchEvent.Watch event )
     {
-        // Get the current chunk if it has been loaded. This is safe as, if the chunk hasn't been loaded yet, then the
-        // monitor will have no contents, and so we won't need to send an update anyway.
-        ChunkPos chunkPos = event.getPos();
-        LevelChunk chunk = event.getWorld().getChunkSource().getChunkNow( chunkPos.x, chunkPos.z );
-        if( chunk == null ) return;
-
-        for( BlockEntity te : chunk.getBlockEntities().values() )
+        // Find all origin monitors who are not already on the queue and send the
+        // monitor data to the player.
+        for( BlockEntity te : event.getChunk().getBlockEntities().values() )
         {
-            // Find all origin monitors who are not already on the queue.
             if( !(te instanceof TileMonitor monitor) ) continue;
 
             ServerMonitor serverMonitor = getMonitor( monitor );
             if( serverMonitor == null || monitor.enqueued ) continue;
 
-            // The chunk hasn't been sent to the client yet, so we can't send an update. Do it on tick end.
-            playerUpdates.add( new PlayerUpdate( event.getPlayer(), monitor ) );
+            TerminalState state = monitor.cached;
+            if( state == null ) state = monitor.cached = serverMonitor.write();
+            NetworkHandler.sendToPlayer( event.getPlayer(), new MonitorClientMessage( monitor.getBlockPos(), state ) );
         }
     }
 
     @SubscribeEvent
     public static void onTick( TickEvent.ServerTickEvent event )
     {
+        // Find all enqueued monitors and send their contents to all nearby players.
+
         if( event.phase != TickEvent.Phase.END ) return;
 
-        PlayerUpdate playerUpdate;
-        while( (playerUpdate = playerUpdates.poll()) != null )
-        {
-            TileMonitor tile = playerUpdate.monitor;
-            if( tile.enqueued || tile.isRemoved() ) continue;
-
-            ServerMonitor monitor = getMonitor( tile );
-            if( monitor == null ) continue;
-
-            // Some basic sanity checks to the player. It's possible they're no longer within range, but that's harder
-            // to track efficiently.
-            ServerPlayer player = playerUpdate.player;
-            if( !player.isAlive() || player.getLevel() != tile.getLevel() ) continue;
-
-            NetworkHandler.sendToPlayer( playerUpdate.player, new MonitorClientMessage( tile.getBlockPos(), getState( tile, monitor ) ) );
-        }
-
         long limit = ComputerCraft.monitorBandwidth;
         boolean obeyLimit = limit > 0;
 
@@ -125,16 +103,4 @@ public final class MonitorWatcher
         if( state == null ) state = tile.cached = monitor.write();
         return state;
     }
-
-    private static final class PlayerUpdate
-    {
-        final ServerPlayer player;
-        final TileMonitor monitor;
-
-        private PlayerUpdate( ServerPlayer player, TileMonitor monitor )
-        {
-            this.player = player;
-            this.monitor = monitor;
-        }
-    }
 }

src/main/java/dan200/computercraft/shared/peripheral/printer/TilePrinter.java

@@ -55,7 +55,7 @@ public final class TilePrinter extends TileGeneric implements DefaultSidedInvent
     private static final int[] SIDE_SLOTS = new int[] { 0 };
 
     Component customName;
-    private LockCode lockCode;
+    private LockCode lockCode = LockCode.NO_LOCK;
 
     private final NonNullList<ItemStack> inventory = NonNullList.withSize( SLOTS, ItemStack.EMPTY );
     private final SidedCaps<IItemHandler> itemHandlerCaps =
@@ -99,7 +99,7 @@ public final class TilePrinter extends TileGeneric implements DefaultSidedInvent
 
         if( !getLevel().isClientSide && isUsable( player ) )
         {
-            NetworkHooks.openGui( (ServerPlayer) player, this );
+            NetworkHooks.openScreen( (ServerPlayer) player, this );
         }
         return InteractionResult.SUCCESS;
     }

src/main/java/dan200/computercraft/shared/turtle/FurnaceRefuelHandler.java

@@ -37,7 +37,7 @@ public final class FurnaceRefuelHandler implements TurtleRefuelEvent.Handler
         ItemStack stack = turtle.getItemHandler().extractItem( slot, limit, false );
         int fuelToGive = fuelPerItem * stack.getCount();
         // Store the replacement item in the inventory
-        ItemStack replacementStack = stack.getItem().getContainerItem( stack );
+        ItemStack replacementStack = ForgeHooks.getCraftingRemainingItem( stack );
         if( !replacementStack.isEmpty() )
         {
             ItemStack remainder = InventoryUtil.storeItems( replacementStack, turtle.getItemHandler(), turtle.getSelectedSlot() );

src/main/java/dan200/computercraft/shared/turtle/apis/TurtleAPI.java

@@ -26,7 +26,7 @@ import java.util.Optional;
  * an internal inventory of 16 slots, allowing them to store blocks they have broken or would like to place.
  *
  * ## Movement
- * Turtles are capable of moving throug the world. As turtles are blocks themselves, they are confined to Minecraft's
+ * Turtles are capable of moving through the world. As turtles are blocks themselves, they are confined to Minecraft's
  * grid, moving a single block at a time.
  *
  * {@literal @}{turtle.forward} and @{turtle.back} move the turtle in the direction it is facing, while @{turtle.up} and

src/main/java/dan200/computercraft/shared/turtle/core/TurtleBrain.java

@@ -323,8 +323,9 @@ public class TurtleBrain implements ITurtleAccess
 
         try
         {
-            // Create a new turtle
-            if( world.setBlock( pos, newState, 0 ) )
+            // We use Block.UPDATE_CLIENTS here to ensure that neighbour updates caused in Block.updateNeighbourShapes
+            // are sent to the client. We want to avoid doing a full block update until the turtle state is copied over.
+            if( world.setBlock( pos, newState, 2 ) )
             {
                 Block block = world.getBlockState( pos ).getBlock();
                 if( block == oldBlock.getBlock() )