A couple of minor cleanups on the last commit

- Remove a redundant logger
 - Provide a getter for the ComputerCraft thread group. This allows us
   to monitor child threads within prometheus.
 - Replace a deprecated call with a fastutils alternative.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,16 @@
+---
+name: Bug report
+about: Report some misbehaviour in the mod
+
+---
+
+<!--
+## Before reporting
+ - Search for the bug both here and [on the ComputerCraft issues page](https://github.com/dan200/ComputerCraft/issues?utf8=%E2%9C%93&q=is%3Aissue+)
+ - If possible, try to reproduce on vanilla ComputerCraft. If it still occurs, [report on the ComputerCraft repo](https://github.com/dan200/ComputerCraft/issues/new) instead.
+-->
+
+## Useful information to include:
+ - Minecraft version
+ - CC: Tweaked version
+ - Detailed reproduction steps!** Sometimes I can spot a bug pretty easily, but often it's much more obscure. Anything you can give which will help reproduce it means it'll get fixed quicker.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,15 @@
+---
+name: Feature request
+about: Suggest an idea or improvement
+
+---
+
+<!--
+## Before reporting
+ - Search for the suggestion both here and [on the ComputerCraft issues page](https://github.com/dan200/ComputerCraft/issues?utf8=%E2%9C%93&q=is%3Aissue+). It's possible someone's suggested it before!
+ - Unless something is specific to CC:Tweaked, try to [suggest them on the ComputerCraft repo](https://github.com/dan200/ComputerCraft/issues/new). There's a lot more people watching it, so it allows the wider community to contribute.
+-->
+
+## Useful information to include:
+ - Explanation of how the feature/change chould work.
+ - Some rationale/use case for a feature. I'd like to keep CC:T as minimal

.github/pull_request_template.md

@@ -0,0 +1,9 @@
+<!--
+Unless this feature is specific to CC:Tweaked, try to [target the original ComputerCraft repo](https://github.com/dan200/ComputerCraft/) instead. There's a lot more people watching it, so it allows the wider community to contribute.
+-->
+
+## Useful information to include:
+ - Brief explanation of the changes you've made.
+ - Rationale of why this change has been made/reasoning behind it.
+
+The more information you can provide, the easier it is to review something now _and_ to see why a change was made, when the code needs updating in the future.

.gitignore

@@ -1,12 +1,12 @@
-build
-out
-run
-deploy
+/build
+/out
+/run
 *.ipr
 *.iws
 *.iml
 .idea
 .gradle
-luaj-2.0.3/lib
-luaj-2.0.3/*.jar
+/luaj-2.0.3/lib
+/luaj-2.0.3/*.jar
 *.DS_Store
+/test-files

README.md

@@ -6,26 +6,44 @@ features of the mod. For a more stable experience, I recommend checking out the
 [original mod](https://github.com/dan200/ComputerCraft).
 
 ## What?
-CC: Tweaked does not aim to create a competing fork of ComputerCraft, nor am I planning to take it in in a vastly
-different direction to the original mod. In fact, CC: Tweaked aims to be a nurturing ground for various features, with
-a pull request against the original mod being the end goal.
+CC: Tweaked (or CC:T for short) does not aim to create a competing fork of ComputerCraft, nor am I planning to take it
+in in a vastly different direction to the original mod. In fact, CC:T aims to be a nurturing ground for various
+features, with a pull request against the original mod being the end goal.
 
-CC: Tweaked also includes many pull requests from the community which have not yet been merged, offering a large number
+CC:T also includes many pull requests from the community which have not yet been merged, offering a large number
 of additional bug fixes and features over the original mod.
 
+## Features
+CC: Tweaked contains the all features of the latest alpha, as well as numerous fixes, performance improvements and
+several additional features. I'd recommend checking out [the releases page](https://github.com/SquidDev-CC/CC-Tweaked/releases)
+to see the full changes, but here's a couple of the more interesting changes:
+
+ - Replace LuaJ with Cobalt.
+ - Allow running multiple computers at the same time.
+ - Websocket support in the HTTP library.
+ - Wired modems and cables act more like multiparts.
+ - Add map-like rendering for pocket computers and printed pages/books.
+ - Adds the `/computercraft` command, offering various diagnostic tools for server owners. This allows operators to
+   track which computers are hogging resources, turn on and shutdown multiple computers at once and interact with
+   computers remotely.
+ - Add full-block wired modems, allowing one to wrap non-solid peripherals (such as turtles, or chests if Plethora is
+   installed).
+ - Extended binary file handles. They support file seeking, and reading new lines, allowing full (and accurate)
+   emulation of the standard Lua `io` library.
+
 ## Relation to CCTweaks?
-This mod has nothing to do with CCTweaks, though there is no denying the name is a throwback to it. However, I do plan
-to migrate some features of CCTweaks into CC: Tweaked.
+This mod has nothing to do with CCTweaks, though there is no denying the name is a throwback to it. That being said,
+several features have been included, such as full block modems, the Cobalt runtime and map-like rendering for pocket
+computers.
 
 ## Contributing
 Any contribution is welcome, be that using the mod, reporting bugs or contributing code. If you do wish to contribute
-code, do consider submitting it to the ComputerCraft repository instead.
+code, do consider submitting it to the ComputerCraft repository first.
 
-That being said, in order to start helping develop CC: Tweaked, you'll need to follow these steps:
+That being said, in order to start helping develop CC:T, you'll need to follow these steps:
 
  - **Clone the repository:** `git clone https://github.com/SquidDev-CC/CC-Tweaked.git && cd CC-Tweaked`
  - **Setup Forge:** `./gradlew setupDecompWorkspace`
  - **Test your changes:** `./gradlew runClient` (or run the `GradleStart` class from your IDE).
 
-If you want to run CC: Tweaked in a normal Minecraft instance, run `./gradlew build` and copy the `.jar` from 
-`build/libs`.
+If you want to run CC:T in a normal Minecraft instance, run `./gradlew build` and copy the `.jar` from `build/libs`.

build.gradle

@@ -23,12 +23,12 @@ apply plugin: 'org.ajoberstar.grgit'
 apply plugin: 'maven-publish'
 apply plugin: 'maven'
 
-version = "1.80pr1.6"
+version = "1.80pr1.11"
 group = "org.squiddev"
 archivesBaseName = "cc-tweaked"
 
 minecraft {
-    version = "1.12.2-14.23.2.2634"
+    version = "1.12.2-14.23.4.2749"
     runDir = "run"
     replace '${version}', project.version
 
@@ -37,7 +37,7 @@ minecraft {
     // stable_#            stables are built at the discretion of the MCP team.
     // Use non-default mappings at your own risk. they may not allways work.
     // simply re-run your setup task after changing the mappings to update your workspace.
-    mappings = "snapshot_20180324"
+    mappings = "snapshot_20180724"
     // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
 }
 
@@ -50,6 +50,8 @@ repositories {
         name = "squiddev"
         url = "https://dl.bintray.com/squiddev/maven"
     }
+
+    ivy { artifactPattern "https://asie.pl/files/mods/Charset/LibOnly/[module]-[revision](-[classifier]).[ext]" }
 }
 
 configurations {
@@ -60,8 +62,11 @@ configurations {
 
 dependencies {
     deobfProvided "mezz.jei:jei_1.12.2:4.8.5.159:api"
+    deobfProvided "pl.asie:Charset-Lib:0.5.4.6"
+
     runtime "mezz.jei:jei_1.12.2:4.8.5.159"
-    shade 'org.squiddev:Cobalt:0.3.1'
+
+    shade 'org.squiddev:Cobalt:0.4.0'
 
     testCompile 'junit:junit:4.11'
 
@@ -126,7 +131,7 @@ curseforge {
     project {
         id = '282001'
         releaseType = 'beta'
-        changelog = ''
+        changelog = "Release notes can be found on the GitHub repository (https://github.com/SquidDev-CC/CC-Tweaked/releases/tag/v${project.version})."
     }
 }
 

build_luaj.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-cd luaj-2.0.3
-echo "Building LuaJ..."
-ant clean
-ant
-
-echo "Copying output to libs..."
-rm ../libs/luaj-jse-2.0.3.jar
-cp luaj-jse-2.0.3.jar ../libs
-
-echo "Done."
-cd ..

codesize.sh

@@ -1,10 +0,0 @@
-#!/bin/sh
-echo "Java code:"
-cat `find src | grep \\.java$` | wc
-
-echo "Lua code:"
-cat `find src/main/resources/assets/computercraft/lua | grep \\.lua$` | wc
-
-echo "JSON:"
-cat `find src/main/resources/assets/computercraft | grep \\.json$` | wc
-

deploy.sh

@@ -1,21 +0,0 @@
-#!/bin/sh
-
-echo "Building with gradle..."
-rm -rf build/libs
-rm -rf build/resources
-rm -rf build/classes
-chmod -R +rw src/main/resources
-chmod +x gradlew
-./gradlew build
-
-echo "Deleting old deployment..."
-rm -rf deploy
-mkdir deploy
-
-echo "Making new deployment..."
-INPUTJAR=`ls -1 build/libs | grep -v sources`
-OUTPUTJAR=`ls -1 build/libs | grep -v sources | sed s/\-//g`
-FRIENDLYNAME=`ls -1 build/libs | grep -v sources | sed s/\-/\ /g | sed s/\.jar//g`
-cp build/libs/$INPUTJAR deploy/$OUTPUTJAR
-
-echo "Done."

setup.bat

@@ -1,7 +0,0 @@
-echo "Setting up IntelliJ development environment with gradle..."
-rmdir /s /q .\build
-call gradlew.bat --stacktrace setupDecompWorkspace --refresh-dependencies
-call gradlew.bat --stacktrace cleanIdea idea
-
-echo "Done."
-pause

setup.sh

@@ -1,14 +0,0 @@
-#!/bin/sh
-
-echo "Setting permissions..."
-chmod +x codesize.sh
-chmod +x build_luaj.sh
-chmod +x deploy.sh
-chmod +x gradlew
-
-echo "Setting up IntelliJ development environment with gradle..."
-rm -rf build
-./gradlew --stacktrace setupDecompWorkspace --refresh-dependencies
-./gradlew --stacktrace cleanIdea idea
-
-echo "Done."

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

@@ -26,11 +26,9 @@ import dan200.computercraft.api.turtle.event.TurtleAction;
 import dan200.computercraft.core.apis.AddressPredicate;
 import dan200.computercraft.core.filesystem.ComboMount;
 import dan200.computercraft.core.filesystem.FileMount;
-import dan200.computercraft.core.filesystem.JarMount;
+import dan200.computercraft.core.filesystem.FileSystemMount;
 import dan200.computercraft.core.terminal.Terminal;
 import dan200.computercraft.core.tracking.Tracking;
-import dan200.computercraft.shared.command.CommandComputer;
-import dan200.computercraft.shared.command.CommandComputerCraft;
 import dan200.computercraft.shared.common.DefaultBundledRedstoneProvider;
 import dan200.computercraft.shared.computer.blocks.BlockCommandComputer;
 import dan200.computercraft.shared.computer.blocks.BlockComputer;
@@ -60,7 +58,10 @@ import dan200.computercraft.shared.proxy.IComputerCraftProxy;
 import dan200.computercraft.shared.turtle.blocks.BlockTurtle;
 import dan200.computercraft.shared.turtle.blocks.TileTurtle;
 import dan200.computercraft.shared.turtle.upgrades.*;
-import dan200.computercraft.shared.util.*;
+import dan200.computercraft.shared.util.CreativeTabMain;
+import dan200.computercraft.shared.util.IDAssigner;
+import dan200.computercraft.shared.util.InventoryUtil;
+import dan200.computercraft.shared.util.WorldUtil;
 import dan200.computercraft.shared.wired.CapabilityWiredElement;
 import dan200.computercraft.shared.wired.WiredNode;
 import io.netty.buffer.Unpooled;
@@ -97,7 +98,10 @@ import java.io.*;
 import java.net.MalformedURLException;
 import java.net.URISyntaxException;
 import java.net.URL;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
 import java.util.*;
+import java.util.function.Function;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
@@ -107,12 +111,12 @@ import java.util.zip.ZipFile;
 
 @Mod(
     modid = ComputerCraft.MOD_ID, name = "CC: Tweaked", version = "${version}",
-    guiFactory = "dan200.computercraft.client.gui.GuiConfigCC$Factory"
+    guiFactory = "dan200.computercraft.client.gui.GuiConfigCC$Factory",
+    dependencies = "required:forge@[14.23.4.2746,)"
 )
 public class ComputerCraft
 {
     public static final String MOD_ID = "computercraft";
-    public static final String LOWER_ID = "computercraft";
 
     // GUI IDs
     public static final int diskDriveGUIID = 100;
@@ -921,11 +925,12 @@ public class ComputerCraft
         {
             try
             {
-                IMount jarMount = new JarMount( modJar, subPath );
-                mounts.add( jarMount );
+                FileSystem fs = FileSystems.newFileSystem( modJar.toPath(), ComputerCraft.class.getClassLoader() );
+                mounts.add( new FileSystemMount( fs, subPath ) );
             }
-            catch( IOException e )
+            catch( IOException | RuntimeException | ServiceConfigurationError e )
             {
+                ComputerCraft.log.error( "Could not load mount from mod jar", e );
                 // Ignore
             }
         }
@@ -935,16 +940,16 @@ public class ComputerCraft
         if( resourcePackDir.exists() && resourcePackDir.isDirectory() )
         {
             String[] resourcePacks = resourcePackDir.list();
-            for( String resourcePack1 : resourcePacks )
+            for( String resourcePackName : resourcePacks )
             {
                 try
                 {
-                    File resourcePack = new File( resourcePackDir, resourcePack1 );
+                    File resourcePack = new File( resourcePackDir, resourcePackName );
                     if( !resourcePack.isDirectory() )
                     {
                         // Mount a resource pack from a jar
-                        IMount resourcePackMount = new JarMount( resourcePack, subPath );
-                        mounts.add( resourcePackMount );
+                        FileSystem fs = FileSystems.newFileSystem( resourcePack.toPath(), ComputerCraft.class.getClassLoader() );
+                        mounts.add( new FileSystemMount( fs, subPath ) );
                     }
                     else
                     {
@@ -957,9 +962,9 @@ public class ComputerCraft
                         }
                     }
                 }
-                catch( IOException e )
+                catch( IOException | RuntimeException | ServiceConfigurationError e )
                 {
-                    // Ignore
+                    ComputerCraft.log.error( "Could not load resource pack '" + resourcePackName + "'", e );
                 }
             }
         }
@@ -1124,13 +1129,18 @@ public class ComputerCraft
         turtleProxy.addAllUpgradedTurtles( list );
     }
 
-    public static void setEntityDropConsumer( Entity entity, IEntityDropConsumer consumer )
+    public static void setDropConsumer( Entity entity, Function<ItemStack, ItemStack> consumer )
     {
-        turtleProxy.setEntityDropConsumer( entity, consumer );
+        turtleProxy.setDropConsumer( entity, consumer );
     }
 
-    public static void clearEntityDropConsumer( Entity entity )
+    public static void setDropConsumer( World world, BlockPos pos, Function<ItemStack, ItemStack> consumer )
     {
-        turtleProxy.clearEntityDropConsumer( entity );
+        turtleProxy.setDropConsumer( world, pos, consumer );
+    }
+
+    public static List<ItemStack> clearDropConsumer( )
+    {
+        return turtleProxy.clearDropConsumer();
     }
 }

src/main/java/dan200/computercraft/api/filesystem/IMount.java

@@ -13,6 +13,8 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
 import java.util.List;
 
 /**
@@ -72,7 +74,25 @@ public interface IMount
      * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
      * @return A stream representing the contents of the file.
      * @throws IOException If the file does not exist, or could not be opened.
+     * @deprecated Use {@link #openChannelForRead(String)} instead
      */
     @Nonnull
+    @Deprecated
     InputStream openForRead( @Nonnull String path ) throws IOException;
+
+    /**
+     * Opens a file with a given path, and returns an {@link ReadableByteChannel} representing its contents.
+     *
+     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
+     * @return A channel representing the contents of the file. If the channel implements
+     * {@link java.nio.channels.SeekableByteChannel}, one will be able to seek to arbitrary positions when using binary
+     * mode.
+     * @throws IOException If the file does not exist, or could not be opened.
+     */
+    @Nonnull
+    @SuppressWarnings("deprecation")
+    default ReadableByteChannel openChannelForRead( @Nonnull String path ) throws IOException
+    {
+        return Channels.newChannel( openForRead( path ) );
+    }
 }

src/main/java/dan200/computercraft/api/filesystem/IWritableMount.java

@@ -13,6 +13,8 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.nio.channels.Channels;
+import java.nio.channels.WritableByteChannel;
 
 /**
  * Represents a part of a virtual filesystem that can be mounted onto a computer using {@link IComputerAccess#mount(String, IMount)}
@@ -50,20 +52,54 @@ public interface IWritableMount extends IMount
      * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
      * @return A stream for writing to
      * @throws IOException If the file could not be opened for writing.
+     * @deprecated Use {@link #openChannelForWrite(String)} instead.
      */
     @Nonnull
+    @Deprecated
     OutputStream openForWrite( @Nonnull String path ) throws IOException;
 
+    /**
+     * Opens a file with a given path, and returns an {@link OutputStream} for writing to it.
+     *
+     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
+     * @return A stream for writing to. If the channel implements {@link java.nio.channels.SeekableByteChannel}, one
+     * will be able to seek to arbitrary positions when using binary mode.
+     * @throws IOException If the file could not be opened for writing.
+     */
+    @Nonnull
+    @SuppressWarnings("deprecation")
+    default WritableByteChannel openChannelForWrite( @Nonnull String path ) throws IOException
+    {
+        return Channels.newChannel( openForWrite( path ) );
+    }
+
     /**
      * Opens a file with a given path, and returns an {@link OutputStream} for appending to it.
      *
      * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
      * @return A stream for writing to.
      * @throws IOException If the file could not be opened for writing.
+     * @deprecated Use {@link #openChannelForAppend(String)} instead.
      */
     @Nonnull
+    @Deprecated
     OutputStream openForAppend( @Nonnull String path ) throws IOException;
 
+    /**
+     * Opens a file with a given path, and returns an {@link OutputStream} for appending to it.
+     *
+     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
+     * @return A stream for writing to. If the channel implements {@link java.nio.channels.SeekableByteChannel}, one
+     * will be able to seek to arbitrary positions when using binary mode.
+     * @throws IOException If the file could not be opened for writing.
+     */
+    @Nonnull
+    @SuppressWarnings("deprecation")
+    default WritableByteChannel openChannelForAppend( @Nonnull String path ) throws IOException
+    {
+        return Channels.newChannel( openForAppend( path ) );
+    }
+
     /**
      * Get the amount of free space on the mount, in bytes. You should decrease this value as the user writes to the
      * mount, and write operations should fail once it reaches zero.

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

@@ -6,25 +6,19 @@
 
 package dan200.computercraft.client.gui;
 
-import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.core.terminal.TextBuffer;
 import dan200.computercraft.shared.media.inventory.ContainerHeldItem;
 import dan200.computercraft.shared.media.items.ItemPrintout;
-import dan200.computercraft.shared.util.Palette;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.renderer.GlStateManager;
-import net.minecraft.util.ResourceLocation;
 import org.lwjgl.input.Mouse;
 
 import java.io.IOException;
 
+import static dan200.computercraft.client.render.PrintoutRenderer.*;
+
 public class GuiPrintout extends GuiContainer
 {
-    private static final ResourceLocation background = new ResourceLocation( "computercraft", "textures/gui/printout.png" );
-    
-    private static final int xSize = 172;
-    private static final int ySize = 209;
-    
     private final boolean m_book;
     private final int m_pages;
     private final TextBuffer[] m_text;
@@ -34,23 +28,18 @@ public class GuiPrintout extends GuiContainer
     public GuiPrintout( ContainerHeldItem container )
     {
         super( container );
-        m_book = (ItemPrintout.getType( container.getStack() ) == ItemPrintout.Type.Book);
 
         String[] text = ItemPrintout.getText( container.getStack() );
         m_text = new TextBuffer[ text.length ];
-        for( int i=0; i<m_text.length; ++i )
-        {
-            m_text[i] = new TextBuffer( text[i] );
-        }
+        for( int i = 0; i < m_text.length; ++i ) m_text[ i ] = new TextBuffer( text[ i ] );
+
         String[] colours = ItemPrintout.getColours( container.getStack() );
         m_colours = new TextBuffer[ colours.length ];
-        for( int i=0; i<m_colours.length; ++i )
-        {
-            m_colours[i] = new TextBuffer( colours[i] );
-        }
+        for( int i = 0; i < m_colours.length; ++i ) m_colours[ i ] = new TextBuffer( colours[ i ] );
 
-        m_pages = Math.max( m_text.length / ItemPrintout.LINES_PER_PAGE, 1 );
         m_page = 0;
+        m_pages = Math.max( m_text.length / ItemPrintout.LINES_PER_PAGE, 1 );
+        m_book = ItemPrintout.getType( container.getStack() ) == ItemPrintout.Type.Book;
     }
 
     @Override
@@ -78,25 +67,19 @@ public class GuiPrintout extends GuiContainer
     }
 
     @Override
-    protected void keyTyped(char c, int k) throws IOException
+    protected void keyTyped( char c, int k ) throws IOException
     {
         super.keyTyped( c, k );
 
         if( k == 205 )
         {
             // Right
-            if( m_page < m_pages - 1 )
-            {
-                m_page = m_page + 1;
-            }
+            if( m_page < m_pages - 1 ) m_page++;
         }
         else if( k == 203 )
         {
-             // Left
-            if( m_page > 0 )
-            {
-                m_page = m_page - 1;
-            }
+            // Left
+            if( m_page > 0 ) m_page--;
         }
     }
 
@@ -106,21 +89,15 @@ public class GuiPrintout extends GuiContainer
         super.handleMouseInput();
 
         int mouseWheelChange = Mouse.getEventDWheel();
-        if (mouseWheelChange < 0)
+        if( mouseWheelChange < 0 )
         {
             // Up
-            if( m_page < m_pages - 1 )
-            {
-                m_page = m_page + 1;
-            }
+            if( m_page < m_pages - 1 ) m_page++;
         }
-        else if (mouseWheelChange > 0) 
+        else if( mouseWheelChange > 0 )
         {
             // Down
-            if( m_page > 0 )
-            {
-                m_page = m_page - 1;
-            }
+            if( m_page > 0 ) m_page--;
         }
     }
 
@@ -135,78 +112,20 @@ public class GuiPrintout extends GuiContainer
     }
 
     @Override
-    public void drawScreen(int mouseX, int mouseY, float f)
+    public void drawScreen( int mouseX, int mouseY, float f )
     {
         // Draw background
+        zLevel = zLevel - 1;
         drawDefaultBackground();
+        zLevel = zLevel + 1;
 
         // Draw the printout
         GlStateManager.color( 1.0f, 1.0f, 1.0f, 1.0f );
-        this.mc.getTextureManager().bindTexture( background );
 
-        int startY = (height - ySize) / 2;
-        //int startX = (width - xSize) / 2 - (m_page * 8);
-        int startX = (width - (xSize + (m_pages - 1)*8)) / 2;
+        int startY = (height - Y_SIZE) / 2;
+        int startX = (width - X_SIZE) / 2;
 
-        if( m_book )
-        {
-            // Border
-            drawTexturedModalRect( startX - 8, startY - 8, xSize + 48, 0, 12, ySize + 24);
-            drawTexturedModalRect( startX + xSize + (m_pages - 1)*8 - 4, startY - 8, xSize + 48 + 12, 0, 12, ySize + 24);
-            
-            drawTexturedModalRect( startX, startY - 8, 0, ySize, xSize, 12);
-            drawTexturedModalRect( startX, startY + ySize - 4, 0, ySize + 12, xSize, 12);
-            for( int n=1; n<m_pages; ++n )
-            {
-                drawTexturedModalRect( startX + xSize + (n-1)*8, startY - 8, 0, ySize, 8, 12);
-                drawTexturedModalRect( startX + xSize + (n-1)*8, startY + ySize - 4, 0, ySize + 12, 8, 12);
-            }
-        }
-            
-        // Left half
-        if( m_page == 0 )
-        {            
-            drawTexturedModalRect( startX, startY, 24, 0, xSize / 2, ySize);
-            drawTexturedModalRect( startX, startY, 0, 0, 12, ySize);
-        }
-        else
-        {
-            drawTexturedModalRect( startX, startY, 0, 0, 12, ySize);
-            for( int n=1; n<m_page; ++n )
-            {
-                drawTexturedModalRect( startX + n*8, startY, 12, 0, 12, ySize);                
-            }
-            drawTexturedModalRect( startX + m_page*8, startY, 24, 0, xSize / 2, ySize);
-        }
-        
-        // Right half
-        if( m_page == (m_pages - 1) )
-        {
-            drawTexturedModalRect( startX + m_page*8 + xSize/2, startY, 24 + xSize / 2, 0, xSize / 2, ySize);
-            drawTexturedModalRect( startX + m_page*8 + (xSize - 12), startY, 24 + xSize + 12, 0, 12, ySize);
-        }
-        else 
-        {
-            drawTexturedModalRect( startX + (m_pages - 1)*8 + (xSize - 12), startY, 24 + xSize + 12, 0, 12, ySize);
-            for( int n=m_pages-2; n>=m_page; --n )
-            {
-                drawTexturedModalRect( startX + n*8 + (xSize - 12), startY, 24 + xSize, 0, 12, ySize);
-            }
-            drawTexturedModalRect( startX + m_page*8 + xSize/2, startY, 24 + xSize / 2, 0, xSize / 2, ySize);
-        }
-
-        // Draw the text
-        FixedWidthFontRenderer fontRenderer = (FixedWidthFontRenderer)ComputerCraft.getFixedWidthFontRenderer();
-        int x = startX + m_page * 8 + 13;
-        int y = startY + 11;
-        for( int line=0; line<ItemPrintout.LINES_PER_PAGE; ++line )
-        {
-            int lineIdx = ItemPrintout.LINES_PER_PAGE * m_page + line;
-            if( lineIdx >= 0 && lineIdx < m_text.length )
-            {
-                fontRenderer.drawString( m_text[lineIdx], x, y, m_colours[lineIdx], null, 0, 0, false, Palette.DEFAULT );
-            }
-            y = y + FixedWidthFontRenderer.FONT_HEIGHT;
-        }
+        drawBorder( startX, startY, zLevel, m_page, m_pages, m_book );
+        drawText( startX + X_TEXT_MARGIN, startY + Y_TEXT_MARGIN, ItemPrintout.LINES_PER_PAGE * m_page, m_text, m_colours );
     }
 }

src/main/java/dan200/computercraft/client/proxy/ComputerCraftProxyClient.java

@@ -8,10 +8,7 @@ package dan200.computercraft.client.proxy;
 
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.client.gui.*;
-import dan200.computercraft.client.render.ItemPocketRenderer;
-import dan200.computercraft.client.render.RenderOverlayCable;
-import dan200.computercraft.client.render.TileEntityCableRenderer;
-import dan200.computercraft.client.render.TileEntityMonitorRenderer;
+import dan200.computercraft.client.render.*;
 import dan200.computercraft.shared.command.ContainerViewComputer;
 import dan200.computercraft.shared.computer.blocks.ComputerState;
 import dan200.computercraft.shared.computer.blocks.TileComputer;
@@ -34,7 +31,7 @@ import dan200.computercraft.shared.proxy.ComputerCraftProxyCommon;
 import dan200.computercraft.shared.turtle.blocks.TileTurtle;
 import dan200.computercraft.shared.turtle.entity.TurtleVisionCamera;
 import dan200.computercraft.shared.util.Colour;
-import gnu.trove.map.hash.TIntIntHashMap;
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
 import net.minecraft.block.Block;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiNewChat;
@@ -74,7 +71,7 @@ import java.util.List;
 
 public class ComputerCraftProxyClient extends ComputerCraftProxyCommon
 {
-    private static TIntIntHashMap lastCounts = new TIntIntHashMap();
+    private static Int2IntOpenHashMap lastCounts = new Int2IntOpenHashMap();
 
     private long m_tick;
     private long m_renderFrame;
@@ -497,6 +494,7 @@ public class ComputerCraftProxyClient extends ComputerCraftProxyCommon
         MinecraftForge.EVENT_BUS.register( handlers );
         MinecraftForge.EVENT_BUS.register( new RenderOverlayCable() );
         MinecraftForge.EVENT_BUS.register( new ItemPocketRenderer() );
+        MinecraftForge.EVENT_BUS.register( new ItemPrintoutRenderer() );
     }
 
     public class ForgeHandlers

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

@@ -0,0 +1,197 @@
+package dan200.computercraft.client.render;
+
+import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.shared.media.items.ItemPrintout;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.ItemRenderer;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.EnumHandSide;
+import net.minecraft.util.math.MathHelper;
+import net.minecraftforge.client.event.RenderItemInFrameEvent;
+import net.minecraftforge.client.event.RenderSpecificHandEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+import static dan200.computercraft.client.gui.FixedWidthFontRenderer.FONT_HEIGHT;
+import static dan200.computercraft.client.gui.FixedWidthFontRenderer.FONT_WIDTH;
+import static dan200.computercraft.client.render.PrintoutRenderer.*;
+import static dan200.computercraft.shared.media.items.ItemPrintout.LINES_PER_PAGE;
+import static dan200.computercraft.shared.media.items.ItemPrintout.LINE_MAX_LENGTH;
+
+public class ItemPrintoutRenderer
+{
+    @SubscribeEvent
+    public void onRenderInHand( RenderSpecificHandEvent event )
+    {
+        ItemStack stack = event.getItemStack();
+        if( stack.getItem() != ComputerCraft.Items.printout ) return;
+
+        event.setCanceled( true );
+
+        EntityPlayer player = Minecraft.getMinecraft().player;
+
+        GlStateManager.pushMatrix();
+        if( event.getHand() == EnumHand.MAIN_HAND && player.getHeldItemOffhand().isEmpty() )
+        {
+            renderPrintoutFirstPersonCentre(
+                event.getInterpolatedPitch(),
+                event.getEquipProgress(),
+                event.getSwingProgress(),
+                stack
+            );
+        }
+        else
+        {
+            renderPrintoutFirstPersonSide(
+                event.getHand() == EnumHand.MAIN_HAND ? player.getPrimaryHand() : player.getPrimaryHand().opposite(),
+                event.getEquipProgress(),
+                event.getSwingProgress(),
+                stack
+            );
+        }
+        GlStateManager.popMatrix();
+    }
+
+    /**
+     * Renders a pocket computer to one side of the player.
+     *
+     * @param side          The side to render on
+     * @param equipProgress The equip progress of this item
+     * @param swingProgress The swing progress of this item
+     * @param stack         The stack to render
+     * @see ItemRenderer#renderMapFirstPersonSide(float, EnumHandSide, float, ItemStack)
+     */
+    private void renderPrintoutFirstPersonSide( EnumHandSide side, float equipProgress, float swingProgress, ItemStack stack )
+    {
+        Minecraft minecraft = Minecraft.getMinecraft();
+        float offset = side == EnumHandSide.RIGHT ? 1f : -1f;
+        GlStateManager.translate( offset * 0.125f, -0.125f, 0f );
+
+        // If the player is not invisible then render a single arm
+        if( !minecraft.player.isInvisible() )
+        {
+            GlStateManager.pushMatrix();
+            GlStateManager.rotate( offset * 10f, 0f, 0f, 1f );
+            minecraft.getItemRenderer().renderArmFirstPerson( equipProgress, swingProgress, side );
+            GlStateManager.popMatrix();
+        }
+
+        // Setup the appropriate transformations. This is just copied from the
+        // corresponding method in ItemRenderer. 
+        GlStateManager.pushMatrix();
+        GlStateManager.translate( offset * 0.51f, -0.08f + equipProgress * -1.2f, -0.75f );
+        float f1 = MathHelper.sqrt( swingProgress );
+        float f2 = MathHelper.sin( f1 * (float) Math.PI );
+        float f3 = -0.5f * f2;
+        float f4 = 0.4f * MathHelper.sin( f1 * ((float) Math.PI * 2f) );
+        float f5 = -0.3f * MathHelper.sin( swingProgress * (float) Math.PI );
+        GlStateManager.translate( offset * f3, f4 - 0.3f * f2, f5 );
+        GlStateManager.rotate( f2 * -45f, 1f, 0f, 0f );
+        GlStateManager.rotate( offset * f2 * -30f, 0f, 1f, 0f );
+
+        renderPrintoutFirstPerson( stack );
+
+        GlStateManager.popMatrix();
+    }
+
+    /**
+     * Render an item in the middle of the screen
+     *
+     * @param pitch         The pitch of the player
+     * @param equipProgress The equip progress of this item
+     * @param swingProgress The swing progress of this item
+     * @param stack         The stack to render
+     * @see ItemRenderer#renderMapFirstPerson(float, float, float)
+     */
+    private void renderPrintoutFirstPersonCentre( float pitch, float equipProgress, float swingProgress, ItemStack stack )
+    {
+        ItemRenderer itemRenderer = Minecraft.getMinecraft().getItemRenderer();
+
+        // Setup the appropriate transformations. This is just copied from the
+        // corresponding method in ItemRenderer.
+        float swingRt = MathHelper.sqrt( swingProgress );
+        float tX = -0.2f * MathHelper.sin( swingProgress * (float) Math.PI );
+        float tZ = -0.4f * MathHelper.sin( swingRt * (float) Math.PI );
+        GlStateManager.translate( 0f, -tX / 2f, tZ );
+        float pitchAngle = itemRenderer.getMapAngleFromPitch( pitch );
+        GlStateManager.translate( 0f, 0.04f + equipProgress * -1.2f + pitchAngle * -0.5f, -0.72f );
+        GlStateManager.rotate( pitchAngle * -85f, 1f, 0f, 0f );
+        itemRenderer.renderArms();
+        float rX = MathHelper.sin( swingRt * (float) Math.PI );
+        GlStateManager.rotate( rX * 20f, 1f, 0f, 0f );
+        GlStateManager.scale( 2f, 2f, 2f );
+
+        renderPrintoutFirstPerson( stack );
+    }
+
+
+    private static void renderPrintoutFirstPerson( ItemStack stack )
+    {
+        // Setup various transformations. Note that these are partially adapated from the corresponding method
+        // in ItemRenderer.renderMapFirstPerson
+        GlStateManager.disableLighting();
+
+        GlStateManager.rotate( 180f, 0f, 1f, 0f );
+        GlStateManager.rotate( 180f, 0f, 0f, 1f );
+        GlStateManager.scale( 0.42f, 0.42f, -0.42f );
+        GlStateManager.translate( -0.5f, -0.48f, 0.0f );
+
+        drawPrintout( stack );
+
+        GlStateManager.enableLighting();
+    }
+
+    @SubscribeEvent
+    public void onRenderInFrame( RenderItemInFrameEvent event )
+    {
+        ItemStack stack = event.getItem();
+        if( stack.getItem() != ComputerCraft.Items.printout ) return;
+
+        event.setCanceled( true );
+
+        GlStateManager.disableLighting();
+
+        // Move a little bit forward to ensure we're not clipping with the frame
+        GlStateManager.translate( 0.0f, 0.0f, -0.001f );
+        GlStateManager.rotate( 180f, 0f, 0f, 1f );
+        GlStateManager.scale( 0.95f, 0.95f, -0.95f );
+        GlStateManager.translate( -0.5f, -0.5f, 0.0f );
+
+        drawPrintout( stack );
+
+        GlStateManager.enableLighting();
+    }
+
+    private static void drawPrintout( ItemStack stack )
+    {
+        int pages = ItemPrintout.getPageCount( stack );
+        boolean book = ItemPrintout.getType( stack ) == ItemPrintout.Type.Book;
+
+        double width = LINE_MAX_LENGTH * FONT_WIDTH + X_TEXT_MARGIN * 2;
+        double height = LINES_PER_PAGE * FONT_HEIGHT + Y_TEXT_MARGIN * 2;
+
+        // Non-books will be left aligned
+        if( !book ) width += offsetAt( pages );
+
+        double visualWidth = width, visualHeight = height;
+
+        // Meanwhile books will be centred
+        if( book )
+        {
+            visualWidth += 2 * COVER_SIZE + 2 * offsetAt( pages );
+            visualHeight += 2 * COVER_SIZE;
+        }
+
+        double max = Math.max( visualHeight, visualWidth );
+
+        // Scale the printout to fit correctly.
+        double scale = 1.0 / max;
+        GlStateManager.scale( scale, scale, scale );
+        GlStateManager.translate( (max - width) / 2.0f, (max - height) / 2.0f, 0.0f );
+
+        drawBorder( 0, 0, -0.01, 0, pages, book );
+        drawText( X_TEXT_MARGIN, Y_TEXT_MARGIN, 0, ItemPrintout.getText( stack ), ItemPrintout.getColours( stack ) );
+    }
+}

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

@@ -0,0 +1,169 @@
+package dan200.computercraft.client.render;
+
+import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.client.gui.FixedWidthFontRenderer;
+import dan200.computercraft.core.terminal.TextBuffer;
+import dan200.computercraft.shared.util.Palette;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
+
+import static dan200.computercraft.client.gui.FixedWidthFontRenderer.FONT_HEIGHT;
+import static dan200.computercraft.shared.media.items.ItemPrintout.LINES_PER_PAGE;
+
+public class PrintoutRenderer
+{
+    private static final ResourceLocation BG = new ResourceLocation( "computercraft", "textures/gui/printout.png" );
+    private static final double BG_SIZE = 256.0;
+
+    /**
+     * Width of a page
+     */
+    public static final int X_SIZE = 172;
+
+    /**
+     * Height of a page
+     */
+    public static final int Y_SIZE = 209;
+
+    /**
+     * Padding between the left and right of a page and the text
+     */
+    public static final int X_TEXT_MARGIN = 13;
+
+    /**
+     * Padding between the top and bottom of a page and the text
+     */
+    public static final int Y_TEXT_MARGIN = 11;
+
+    /**
+     * Width of the extra page texture
+     */
+    private static final int X_FOLD_SIZE = 12;
+
+    /**
+     * Size of the leather cover
+     */
+    public static final int COVER_SIZE = 12;
+
+    private static final int COVER_Y = Y_SIZE;
+    private static final int COVER_X = X_SIZE + 4 * X_FOLD_SIZE;
+
+    public static void drawText( int x, int y, int start, TextBuffer[] text, TextBuffer[] colours )
+    {
+        FixedWidthFontRenderer fontRenderer = (FixedWidthFontRenderer) ComputerCraft.getFixedWidthFontRenderer();
+
+        for( int line = 0; line < LINES_PER_PAGE && line < text.length; ++line )
+        {
+            fontRenderer.drawString( text[ start + line ], x, y + line * FONT_HEIGHT, colours[ start + line ], null, 0, 0, false, Palette.DEFAULT );
+        }
+    }
+
+    public static void drawText( int x, int y, int start, String[] text, String[] colours )
+    {
+        GlStateManager.color( 1.0f, 1.0f, 1.0f, 1.0f );
+        GlStateManager.enableBlend();
+        GlStateManager.enableTexture2D();
+
+        FixedWidthFontRenderer fontRenderer = (FixedWidthFontRenderer) ComputerCraft.getFixedWidthFontRenderer();
+
+        for( int line = 0; line < LINES_PER_PAGE && line < text.length; ++line )
+        {
+            fontRenderer.drawString( new TextBuffer( text[ start + line ] ), x, y + line * FONT_HEIGHT, new TextBuffer( colours[ start + line ] ), null, 0, 0, false, Palette.DEFAULT );
+        }
+    }
+
+    public static void drawBorder( double x, double y, double z, int page, int pages, boolean isBook )
+    {
+        GlStateManager.color( 1.0f, 1.0f, 1.0f, 1.0f );
+        GlStateManager.enableBlend();
+        GlStateManager.enableTexture2D();
+
+        Minecraft.getMinecraft().getTextureManager().bindTexture( BG );
+
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder buffer = tessellator.getBuffer();
+        buffer.begin( GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX );
+
+        int leftPages = page;
+        int rightPages = pages - page - 1;
+
+        if( isBook )
+        {
+            // Border
+            double offset = offsetAt( pages );
+            final double left = x - 4 - offset;
+            final double right = x + X_SIZE + offset - 4;
+
+            // Left and right border
+            drawTexture( buffer, left - 4, y - 8, z - 0.02, COVER_X, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2 );
+            drawTexture( buffer, right, y - 8, z - 0.02, COVER_X + COVER_SIZE, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2 );
+
+            // Draw centre panel (just stretched texture, sorry).
+            drawTexture( buffer,
+                x - offset, y, z - 0.02, X_SIZE + offset * 2, Y_SIZE,
+                COVER_X + COVER_SIZE / 2, COVER_SIZE, COVER_SIZE, Y_SIZE
+            );
+
+            double borderX = left;
+            while( borderX < right )
+            {
+                double thisWidth = Math.min( right - borderX, X_SIZE );
+                drawTexture( buffer, borderX, y - 8, z - 0.02, 0, COVER_Y, thisWidth, COVER_SIZE );
+                drawTexture( buffer, borderX, y + Y_SIZE - 4, z - 0.02, 0, COVER_Y + COVER_SIZE, thisWidth, COVER_SIZE );
+                borderX += thisWidth;
+            }
+        }
+
+        // Left half
+        drawTexture( buffer, x, y, z, X_FOLD_SIZE * 2, 0, X_SIZE / 2, Y_SIZE );
+        for( int n = 0; n <= leftPages; n++ )
+        {
+            drawTexture( buffer,
+                x - offsetAt( n ), y, z - 1e-3 * n,
+                // Use the left "bold" fold for the outermost page
+                n == leftPages ? 0 : X_FOLD_SIZE, 0,
+                X_FOLD_SIZE, Y_SIZE
+            );
+        }
+
+        // Right half
+        drawTexture( buffer, x + X_SIZE / 2, y, z, X_FOLD_SIZE * 2 + X_SIZE / 2, 0, X_SIZE / 2, Y_SIZE );
+        for( int n = 0; n <= rightPages; n++ )
+        {
+            drawTexture( buffer,
+                x + (X_SIZE - X_FOLD_SIZE) + offsetAt( n ), y, z - 1e-3 * 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,
+                X_FOLD_SIZE, Y_SIZE
+            );
+        }
+
+        tessellator.draw();
+    }
+
+    private static void drawTexture( BufferBuilder buffer, double x, double y, double z, double u, double v, double width, double height )
+    {
+        buffer.pos( x, y + height, z ).tex( u / BG_SIZE, (v + height) / BG_SIZE ).endVertex();
+        buffer.pos( x + width, y + height, z ).tex( (u + width) / BG_SIZE, (v + height) / BG_SIZE ).endVertex();
+        buffer.pos( x + width, y, z ).tex( (u + width) / BG_SIZE, v / BG_SIZE ).endVertex();
+        buffer.pos( x, y, z ).tex( u / BG_SIZE, v / BG_SIZE ).endVertex();
+    }
+
+    private static void drawTexture( BufferBuilder buffer, double x, double y, double z, double width, double height, double u, double v, double tWidth, double tHeight )
+    {
+        buffer.pos( x, y + height, z ).tex( u / BG_SIZE, (v + tHeight) / BG_SIZE ).endVertex();
+        buffer.pos( x + width, y + height, z ).tex( (u + tWidth) / BG_SIZE, (v + tHeight) / BG_SIZE ).endVertex();
+        buffer.pos( x + width, y, z ).tex( (u + tWidth) / BG_SIZE, v / BG_SIZE ).endVertex();
+        buffer.pos( x, y, z ).tex( u / BG_SIZE, v / BG_SIZE ).endVertex();
+    }
+
+    public static double offsetAt( int page )
+    {
+        return 32 * (1 - Math.pow( 1.2, -page ));
+    }
+}

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

@@ -71,7 +71,7 @@ public class TileEntityCableRenderer extends TileEntitySpecialRenderer<TileCable
         buffer.setTranslation( x - pos.getX(), y - pos.getY(), z - pos.getZ() );
         buffer.noColor();
 
-        ForgeHooksClient.setRenderLayer( block.getBlockLayer() );
+        ForgeHooksClient.setRenderLayer( block.getRenderLayer() );
 
         // See BlockRendererDispatcher#renderBlockDamage
         TextureAtlasSprite breakingTexture = mc.getTextureMapBlocks().getAtlasSprite( "minecraft:blocks/destroy_stage_" + destroyStage );

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

@@ -18,12 +18,14 @@ import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.block.model.*;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.client.resources.IResourceManager;
-import net.minecraft.client.resources.IResourceManagerReloadListener;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.world.World;
+import net.minecraftforge.client.resource.IResourceType;
+import net.minecraftforge.client.resource.ISelectiveResourceReloadListener;
+import net.minecraftforge.client.resource.VanillaResourceType;
 import org.apache.commons.lang3.tuple.Pair;
 
 import javax.annotation.Nonnull;
@@ -32,8 +34,9 @@ import javax.vecmath.Matrix4f;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.function.Predicate;
 
-public class TurtleSmartItemModel implements IBakedModel, IResourceManagerReloadListener
+public class TurtleSmartItemModel implements IBakedModel, ISelectiveResourceReloadListener
 {
     private static final Matrix4f s_identity, s_flip;
 
@@ -155,9 +158,9 @@ public class TurtleSmartItemModel implements IBakedModel, IResourceManagerReload
     }
 
     @Override
-    public void onResourceManagerReload( @Nonnull IResourceManager resourceManager )
+    public void onResourceManagerReload( @Nonnull IResourceManager resourceManager, @Nonnull Predicate<IResourceType> resourcePredicate )
     {
-        m_cachedModels.clear();
+        if( resourcePredicate.test( VanillaResourceType.MODELS ) ) m_cachedModels.clear();
     }
 
     private IBakedModel buildModel( TurtleModelCombination combo )

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

@@ -3,14 +3,17 @@ package dan200.computercraft.core.apis;
 import dan200.computercraft.api.filesystem.IMount;
 import dan200.computercraft.api.filesystem.IWritableMount;
 import dan200.computercraft.api.peripheral.IComputerAccess;
+import dan200.computercraft.core.computer.Computer;
+import dan200.computercraft.core.computer.IComputerOwned;
 import dan200.computercraft.core.filesystem.FileSystem;
 import dan200.computercraft.core.filesystem.FileSystemException;
 
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import java.util.HashSet;
 import java.util.Set;
 
-public abstract class ComputerAccess implements IComputerAccess
+public abstract class ComputerAccess implements IComputerAccess, IComputerOwned
 {
     private final IAPIEnvironment m_environment;
     private final Set<String> m_mounts = new HashSet<>();
@@ -133,6 +136,13 @@ public abstract class ComputerAccess implements IComputerAccess
         m_environment.queueEvent( event, arguments );
     }
 
+    @Nullable
+    @Override
+    public Computer getComputer()
+    {
+        return m_environment.getComputer();
+    }
+
     private String findFreeLocation( String desiredLoc )
     {
         try

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

@@ -9,19 +9,23 @@ package dan200.computercraft.core.apis;
 import dan200.computercraft.api.lua.ILuaAPI;
 import dan200.computercraft.api.lua.ILuaContext;
 import dan200.computercraft.api.lua.LuaException;
-import dan200.computercraft.core.apis.handles.BinaryInputHandle;
-import dan200.computercraft.core.apis.handles.BinaryOutputHandle;
-import dan200.computercraft.core.apis.handles.EncodedInputHandle;
-import dan200.computercraft.core.apis.handles.EncodedOutputHandle;
+import dan200.computercraft.core.apis.handles.BinaryReadableHandle;
+import dan200.computercraft.core.apis.handles.BinaryWritableHandle;
+import dan200.computercraft.core.apis.handles.EncodedReadableHandle;
+import dan200.computercraft.core.apis.handles.EncodedWritableHandle;
 import dan200.computercraft.core.filesystem.FileSystem;
 import dan200.computercraft.core.filesystem.FileSystemException;
+import dan200.computercraft.core.filesystem.FileSystemWrapper;
 import dan200.computercraft.core.tracking.TrackingField;
 
 import javax.annotation.Nonnull;
-import java.io.InputStream;
-import java.io.OutputStream;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.Function;
 
 import static dan200.computercraft.core.apis.ArgumentHelper.getString;
 
@@ -221,38 +225,38 @@ public class FSAPI implements ILuaAPI
                         case "r":
                         {
                             // Open the file for reading, then create a wrapper around the reader
-                            InputStream reader = m_fileSystem.openForRead( path );
-                            return new Object[] { new EncodedInputHandle( reader ) };
+                            FileSystemWrapper<BufferedReader> reader = m_fileSystem.openForRead( path, EncodedReadableHandle::openUtf8 );
+                            return new Object[] { new EncodedReadableHandle( reader.get(), reader ) };
                         }
                         case "w":
                         {
                             // Open the file for writing, then create a wrapper around the writer
-                            OutputStream writer = m_fileSystem.openForWrite( path, false );
-                            return new Object[] { new EncodedOutputHandle( writer ) };
+                            FileSystemWrapper<BufferedWriter> writer = m_fileSystem.openForWrite( path, false, EncodedWritableHandle::openUtf8 );
+                            return new Object[] { new EncodedWritableHandle( writer.get(), writer ) };
                         }
                         case "a":
                         {
                             // Open the file for appending, then create a wrapper around the writer
-                            OutputStream writer = m_fileSystem.openForWrite( path, true );
-                            return new Object[] { new EncodedOutputHandle( writer ) };
+                            FileSystemWrapper<BufferedWriter> writer = m_fileSystem.openForWrite( path, true, EncodedWritableHandle::openUtf8 );
+                            return new Object[] { new EncodedWritableHandle( writer.get(), writer ) };
                         }
                         case "rb":
                         {
                             // Open the file for binary reading, then create a wrapper around the reader
-                            InputStream reader = m_fileSystem.openForRead( path );
-                            return new Object[] { new BinaryInputHandle( reader ) };
+                            FileSystemWrapper<ReadableByteChannel> reader = m_fileSystem.openForRead( path, Function.identity() );
+                            return new Object[] { new BinaryReadableHandle( reader.get(), reader ) };
                         }
                         case "wb":
                         {
                             // Open the file for binary writing, then create a wrapper around the writer
-                            OutputStream writer = m_fileSystem.openForWrite( path, false );
-                            return new Object[] { new BinaryOutputHandle( writer ) };
+                            FileSystemWrapper<WritableByteChannel> writer = m_fileSystem.openForWrite( path, false, Function.identity() );
+                            return new Object[] { new BinaryWritableHandle( writer.get(), writer ) };
                         }
                         case "ab":
                         {
                             // Open the file for binary appending, then create a wrapper around the reader
-                            OutputStream writer = m_fileSystem.openForWrite( path, true );
-                            return new Object[] { new BinaryOutputHandle( writer ) };
+                            FileSystemWrapper<WritableByteChannel> writer = m_fileSystem.openForWrite( path, true, Function.identity() );
+                            return new Object[] { new BinaryWritableHandle( writer.get(), writer ) };
                         }
                         default:
                             throw new LuaException( "Unsupported mode" );

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

@@ -9,17 +9,19 @@ package dan200.computercraft.core.apis;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.core.computer.Computer;
 import dan200.computercraft.core.computer.IComputerEnvironment;
+import dan200.computercraft.core.computer.IComputerOwned;
 import dan200.computercraft.core.filesystem.FileSystem;
 import dan200.computercraft.core.terminal.Terminal;
 import dan200.computercraft.core.tracking.TrackingField;
 
-public interface IAPIEnvironment
+public interface IAPIEnvironment extends IComputerOwned
 {
     interface IPeripheralChangeListener
     {
         void onPeripheralChanged( int side, IPeripheral newPeripheral );
     }
 
+    @Override
     Computer getComputer();
     int getComputerID();
     IComputerEnvironment getComputerEnvironment();

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

@@ -64,7 +64,8 @@ public class TermAPI implements ILuaAPI
             "setPaletteColour",
             "setPaletteColor",
             "getPaletteColour",
-            "getPaletteColor"
+            "getPaletteColor",
+            "getCursorBlink",
         };
     }
     
@@ -284,6 +285,9 @@ public class TermAPI implements ILuaAPI
                 }
                 return null;
             }
+            case 23:
+                // getCursorBlink
+                return new Object[] { m_terminal.getCursorBlink() };
             default:
             {
                 return null;

src/main/java/dan200/computercraft/core/apis/handles/ArrayByteChannel.java

@@ -0,0 +1,91 @@
+package dan200.computercraft.core.apis.handles;
+
+import com.google.common.base.Preconditions;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.ClosedChannelException;
+import java.nio.channels.NonWritableChannelException;
+import java.nio.channels.SeekableByteChannel;
+
+/**
+ * A seekable, readable byte channel which is backed by a simple byte array.
+ */
+public class ArrayByteChannel implements SeekableByteChannel
+{
+    private boolean closed = false;
+    private int position = 0;
+
+    private final byte[] backing;
+
+    public ArrayByteChannel( byte[] backing )
+    {
+        this.backing = backing;
+    }
+
+    @Override
+    public int read( ByteBuffer destination ) throws IOException
+    {
+        if( closed ) throw new ClosedChannelException();
+        Preconditions.checkNotNull( destination, "destination" );
+
+        if( position >= backing.length ) return -1;
+
+        int remaining = Math.min( backing.length - position, destination.remaining() );
+        destination.put( backing, position, remaining );
+        position += remaining;
+        return remaining;
+    }
+
+    @Override
+    public int write( ByteBuffer src ) throws IOException
+    {
+        if( closed ) throw new ClosedChannelException();
+        throw new NonWritableChannelException();
+    }
+
+    @Override
+    public long position() throws IOException
+    {
+        if( closed ) throw new ClosedChannelException();
+        return position;
+    }
+
+    @Override
+    public SeekableByteChannel position( long newPosition ) throws IOException
+    {
+        if( closed ) throw new ClosedChannelException();
+        if( newPosition < 0 || newPosition > Integer.MAX_VALUE )
+        {
+            throw new IllegalArgumentException( "Position out of bounds" );
+        }
+        position = (int) newPosition;
+        return this;
+    }
+
+    @Override
+    public long size() throws IOException
+    {
+        if( closed ) throw new ClosedChannelException();
+        return backing.length;
+    }
+
+    @Override
+    public SeekableByteChannel truncate( long size ) throws IOException
+    {
+        if( closed ) throw new ClosedChannelException();
+        throw new NonWritableChannelException();
+    }
+
+    @Override
+    public boolean isOpen()
+    {
+        return !closed;
+    }
+
+    @Override
+    public void close()
+    {
+        closed = true;
+    }
+}

src/main/java/dan200/computercraft/core/apis/handles/BinaryInputHandle.java

@@ -1,122 +0,0 @@
-package dan200.computercraft.core.apis.handles;
-
-import com.google.common.io.ByteStreams;
-import dan200.computercraft.api.lua.ILuaContext;
-import dan200.computercraft.api.lua.LuaException;
-
-import javax.annotation.Nonnull;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Arrays;
-
-import static dan200.computercraft.core.apis.ArgumentHelper.getInt;
-
-public class BinaryInputHandle extends HandleGeneric
-{
-    private static final int BUFFER_SIZE = 8192;
-
-    private final InputStream m_stream;
-
-    public BinaryInputHandle( InputStream reader )
-    {
-        super( reader );
-        this.m_stream = reader;
-    }
-
-    @Nonnull
-    @Override
-    public String[] getMethodNames()
-    {
-        return new String[] {
-            "read",
-            "readAll",
-            "close",
-        };
-    }
-
-    @Override
-    public Object[] callMethod( @Nonnull ILuaContext context, int method, @Nonnull Object[] args ) throws LuaException
-    {
-        switch( method )
-        {
-            case 0:
-                // read
-                checkOpen();
-                try
-                {
-                    if( args.length > 0 && args[ 0 ] != null )
-                    {
-                        int count = getInt( args, 0 );
-                        if( count < 0 )
-                        {
-                            // Whilst this may seem absurd to allow reading 0 bytes, PUC Lua it so 
-                            // it seems best to remain somewhat consistent.
-                            throw new LuaException( "Cannot read a negative number of bytes" );
-                        }
-                        else if( count <= BUFFER_SIZE )
-                        {
-                            // If we've got a small count, then allocate that and read it.
-                            byte[] bytes = new byte[ count ];
-                            int read = m_stream.read( bytes );
-
-                            if( read < 0 ) return null;
-                            if( read < count ) bytes = Arrays.copyOf( bytes, read );
-                            return new Object[] { bytes };
-                        }
-                        else
-                        {
-                            byte[] buffer = new byte[ BUFFER_SIZE ];
-
-                            // Read the initial set of bytes, failing if none are read.
-                            int read = m_stream.read( buffer, 0, Math.min( buffer.length, count ) );
-                            if( read == -1 ) return null;
-
-                            ByteArrayOutputStream out = new ByteArrayOutputStream( read );
-                            count -= read;
-                            out.write( buffer, 0, read );
-
-                            // Otherwise read until we either reach the limit or we no longer consume
-                            // the full buffer.
-                            while( read >= buffer.length && count > 0 )
-                            {
-                                read = m_stream.read( buffer, 0, Math.min( BUFFER_SIZE, count ) );
-                                if( read == -1 ) break;
-                                count -= read;
-                                out.write( buffer, 0, read );
-                            }
-
-                            return new Object[] { out.toByteArray() };
-                        }
-                    }
-                    else
-                    {
-                        int b = m_stream.read();
-                        return b == -1 ? null : new Object[] { b };
-                    }
-                }
-                catch( IOException e )
-                {
-                    return null;
-                }
-            case 1:
-                // readAll
-                checkOpen();
-                try
-                {
-                    byte[] out = ByteStreams.toByteArray( m_stream );
-                    return out == null ? null : new Object[] { out };
-                }
-                catch( IOException e )
-                {
-                    return null;
-                }
-            case 2:
-                //close
-                close();
-                return null;
-            default:
-                return null;
-        }
-    }
-}

src/main/java/dan200/computercraft/core/apis/handles/BinaryReadableHandle.java

@@ -0,0 +1,205 @@
+package dan200.computercraft.core.apis.handles;
+
+import com.google.common.collect.ObjectArrays;
+import dan200.computercraft.api.lua.ILuaContext;
+import dan200.computercraft.api.lua.LuaException;
+
+import javax.annotation.Nonnull;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.SeekableByteChannel;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static dan200.computercraft.core.apis.ArgumentHelper.getInt;
+import static dan200.computercraft.core.apis.ArgumentHelper.optBoolean;
+
+public class BinaryReadableHandle extends HandleGeneric
+{
+    private static final int BUFFER_SIZE = 8192;
+
+    private static final String[] METHOD_NAMES = new String[] { "read", "readAll", "readLine", "close" };
+    private static final String[] METHOD_SEEK_NAMES = ObjectArrays.concat( METHOD_NAMES, new String[] { "seek" }, String.class );
+
+    private final ReadableByteChannel m_reader;
+    private final SeekableByteChannel m_seekable;
+    private final ByteBuffer single = ByteBuffer.allocate( 1 );
+
+    public BinaryReadableHandle( ReadableByteChannel channel, Closeable closeable )
+    {
+        super( closeable );
+        this.m_reader = channel;
+        this.m_seekable = asSeekable( channel );
+    }
+
+    public BinaryReadableHandle( ReadableByteChannel channel )
+    {
+        this( channel, channel );
+    }
+
+    @Nonnull
+    @Override
+    public String[] getMethodNames()
+    {
+        return m_seekable == null ? METHOD_NAMES : METHOD_SEEK_NAMES;
+    }
+
+    @Override
+    public Object[] callMethod( @Nonnull ILuaContext context, int method, @Nonnull Object[] args ) throws LuaException
+    {
+        switch( method )
+        {
+            case 0:
+                // read
+                checkOpen();
+                try
+                {
+                    if( args.length > 0 && args[ 0 ] != null )
+                    {
+                        int count = getInt( args, 0 );
+                        if( count < 0 )
+                        {
+                            throw new LuaException( "Cannot read a negative number of bytes" );
+                        }
+                        else if( count == 0 && m_seekable != null )
+                        {
+                            return m_seekable.position() >= m_seekable.size() ? null : new Object[] { "" };
+                        }
+
+                        if( count <= BUFFER_SIZE )
+                        {
+                            ByteBuffer buffer = ByteBuffer.allocate( count );
+                            
+                            int read = m_reader.read( buffer );
+                            if( read < 0 ) return null;
+                            return new Object[] { read < count ? Arrays.copyOf( buffer.array(), read ) : buffer.array() };
+                        }
+                        else
+                        {
+                            ByteBuffer buffer = ByteBuffer.allocate( BUFFER_SIZE );
+
+                            int read = m_reader.read( buffer );
+                            if( read < 0 ) return null;
+                            int totalRead = read;
+
+                            // If we failed to read "enough" here, let's just abort
+                            if( totalRead >= count || read < BUFFER_SIZE )
+                            {
+                                return new Object[] { Arrays.copyOf( buffer.array(), read ) };
+                            }
+
+                            // Build up an array of ByteBuffers. Hopefully this means we can perform less allocation 
+                            // than doubling up the buffer each time.
+                            List<ByteBuffer> parts = new ArrayList<>( 4 );
+                            parts.add( buffer );
+                            while( totalRead < count && read >= BUFFER_SIZE )
+                            {
+                                buffer = ByteBuffer.allocate( BUFFER_SIZE );
+                                totalRead += read = m_reader.read( buffer );
+                                parts.add( buffer );
+                            }
+
+                            // Now just copy all the bytes across!
+                            byte[] bytes = new byte[ totalRead ];
+                            int pos = 0;
+                            for( ByteBuffer part : parts )
+                            {
+                                System.arraycopy( part.array(), 0, bytes, pos, part.position() );
+                                pos += part.position();
+                            }
+                            return new Object[] { bytes };
+                        }
+                    }
+                    else
+                    {
+                        single.clear();
+                        int b = m_reader.read( single );
+                        return b == -1 ? null : new Object[] { single.get( 0 ) & 0xFF };
+                    }
+                }
+                catch( IOException e )
+                {
+                    return null;
+                }
+            case 1:
+                // readAll
+                checkOpen();
+                try
+                {
+                    int expected = 32;
+                    if( m_seekable != null )
+                    {
+                        expected = Math.max( expected, (int) (m_seekable.size() - m_seekable.position()) );
+                    }
+                    ByteArrayOutputStream stream = new ByteArrayOutputStream( expected );
+
+                    ByteBuffer buf = ByteBuffer.allocate( 8192 );
+                    boolean readAnything = false;
+                    while( true )
+                    {
+                        buf.clear();
+                        int r = m_reader.read( buf );
+                        if( r == -1 ) break;
+
+                        readAnything = true;
+                        stream.write( buf.array(), 0, r );
+                    }
+                    return readAnything ? new Object[] { stream.toByteArray() } : null;
+                }
+                catch( IOException e )
+                {
+                    return null;
+                }
+            case 2:
+            {
+                // readLine
+                checkOpen();
+                boolean withTrailing = optBoolean( args, 0, false );
+                try
+                {
+                    ByteArrayOutputStream stream = new ByteArrayOutputStream();
+
+                    boolean readAnything = false;
+                    while( true )
+                    {
+                        single.clear();
+                        int r = m_reader.read( single );
+                        if( r == -1 ) break;
+
+                        readAnything = true;
+                        byte b = single.get( 0 );
+                        if( b == '\n' )
+                        {
+                            if( withTrailing ) stream.write( b );
+                            break;
+                        }
+                        else
+                        {
+                            stream.write( b );
+                        }
+                    }
+
+                    return readAnything ? new Object[] { stream.toByteArray() } : null;
+                }
+                catch( IOException e )
+                {
+                    return null;
+                }
+            }
+            case 3:
+                //close
+                close();
+                return null;
+            case 4:
+                // seek
+                checkOpen();
+                return handleSeek( m_seekable, args );
+            default:
+                return null;
+        }
+    }
+}

src/main/java/dan200/computercraft/core/apis/handles/BinaryWritableHandle.java

@@ -1,33 +1,45 @@
 package dan200.computercraft.core.apis.handles;
 
+import com.google.common.collect.ObjectArrays;
 import dan200.computercraft.api.lua.ILuaContext;
 import dan200.computercraft.api.lua.LuaException;
 import dan200.computercraft.core.apis.ArgumentHelper;
 import dan200.computercraft.shared.util.StringUtil;
 
 import javax.annotation.Nonnull;
+import java.io.Closeable;
 import java.io.IOException;
-import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.SeekableByteChannel;
+import java.nio.channels.WritableByteChannel;
 
-public class BinaryOutputHandle extends HandleGeneric
+public class BinaryWritableHandle extends HandleGeneric
 {
-    private final OutputStream m_writer;
+    private static final String[] METHOD_NAMES = new String[] { "write", "flush", "close" };
+    private static final String[] METHOD_SEEK_NAMES = ObjectArrays.concat( METHOD_NAMES, new String[] { "seek" }, String.class );
 
-    public BinaryOutputHandle( OutputStream writer )
+    private final WritableByteChannel m_writer;
+    private final SeekableByteChannel m_seekable;
+    private final ByteBuffer single = ByteBuffer.allocate( 1 );
+
+    public BinaryWritableHandle( WritableByteChannel channel, Closeable closeable )
     {
-        super( writer );
-        this.m_writer = writer;
+        super( closeable );
+        this.m_writer = channel;
+        this.m_seekable = asSeekable( channel );
+    }
+
+    public BinaryWritableHandle( WritableByteChannel channel )
+    {
+        this( channel, channel );
     }
 
     @Nonnull
     @Override
     public String[] getMethodNames()
     {
-        return new String[] {
-            "write",
-            "flush",
-            "close",
-        };
+        return m_seekable == null ? METHOD_NAMES : METHOD_SEEK_NAMES;
     }
 
     @Override
@@ -43,12 +55,16 @@ public class BinaryOutputHandle extends HandleGeneric
                     if( args.length > 0 && args[ 0 ] instanceof Number )
                     {
                         int number = ((Number) args[ 0 ]).intValue();
-                        m_writer.write( number );
+                        single.clear();
+                        single.put( (byte) number );
+                        single.flip();
+
+                        m_writer.write( single );
                     }
                     else if( args.length > 0 && args[ 0 ] instanceof String )
                     {
                         String value = (String) args[ 0 ];
-                        m_writer.write( StringUtil.encodeString( value ) );
+                        m_writer.write( ByteBuffer.wrap( StringUtil.encodeString( value ) ) );
                     }
                     else
                     {
@@ -65,7 +81,9 @@ public class BinaryOutputHandle extends HandleGeneric
                 checkOpen();
                 try
                 {
-                    m_writer.flush();
+                    // Technically this is not needed
+                    if( m_writer instanceof FileChannel ) ((FileChannel) m_writer).force( false );
+
                     return null;
                 }
                 catch( IOException e )
@@ -76,6 +94,10 @@ public class BinaryOutputHandle extends HandleGeneric
                 //close
                 close();
                 return null;
+            case 3:
+                // seek
+                checkOpen();
+                return handleSeek( m_seekable, args );
             default:
                 return null;
         }

src/main/java/dan200/computercraft/core/apis/handles/EncodedReadableHandle.java

@@ -4,45 +4,34 @@ import dan200.computercraft.api.lua.ILuaContext;
 import dan200.computercraft.api.lua.LuaException;
 
 import javax.annotation.Nonnull;
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.IOException;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.StandardCharsets;
 
+import static dan200.computercraft.core.apis.ArgumentHelper.optBoolean;
 import static dan200.computercraft.core.apis.ArgumentHelper.optInt;
 
-public class EncodedInputHandle extends HandleGeneric
+public class EncodedReadableHandle extends HandleGeneric
 {
     private static final int BUFFER_SIZE = 8192;
 
-    private final BufferedReader m_reader;
+    private BufferedReader m_reader;
 
-    public EncodedInputHandle( BufferedReader reader )
+    public EncodedReadableHandle( @Nonnull BufferedReader reader, @Nonnull Closeable closable )
     {
-        super( reader );
+        super( closable );
         this.m_reader = reader;
     }
 
-    public EncodedInputHandle( InputStream stream )
+    public EncodedReadableHandle( @Nonnull BufferedReader reader )
     {
-        this( stream, "UTF-8" );
-    }
-
-    public EncodedInputHandle( InputStream stream, String encoding )
-    {
-        this( makeReader( stream, encoding ) );
-    }
-
-    private static BufferedReader makeReader( InputStream stream, String encoding )
-    {
-        if( encoding == null ) encoding = "UTF-8";
-        InputStreamReader streamReader;
-        try
-        {
-            streamReader = new InputStreamReader( stream, encoding );
-        }
-        catch( UnsupportedEncodingException e )
-        {
-            streamReader = new InputStreamReader( stream );
-        }
-        return new BufferedReader( streamReader );
+        this( reader, reader );
     }
 
     @Nonnull
@@ -63,13 +52,17 @@ public class EncodedInputHandle extends HandleGeneric
         switch( method )
         {
             case 0:
+            {
                 // readLine
                 checkOpen();
+                boolean withTrailing = optBoolean( args, 0, false );
                 try
                 {
                     String line = m_reader.readLine();
                     if( line != null )
                     {
+                        // While this is technically inaccurate, it's better than nothing
+                        if( withTrailing ) line += "\n";
                         return new Object[] { line };
                     }
                     else
@@ -81,6 +74,7 @@ public class EncodedInputHandle extends HandleGeneric
                 {
                     return null;
                 }
+            }
             case 1:
                 // readAll
                 checkOpen();
@@ -108,7 +102,6 @@ public class EncodedInputHandle extends HandleGeneric
                 close();
                 return null;
             case 3:
-                // read
                 checkOpen();
                 try
                 {
@@ -161,4 +154,19 @@ public class EncodedInputHandle extends HandleGeneric
                 return null;
         }
     }
+
+    public static BufferedReader openUtf8( ReadableByteChannel channel )
+    {
+        return open( channel, StandardCharsets.UTF_8 );
+    }
+
+    public static BufferedReader open( ReadableByteChannel channel, Charset charset )
+    {
+        // Create a charset decoder with the same properties as StreamDecoder does for 
+        // InputStreams: namely, replace everything instead of erroring.
+        CharsetDecoder decoder = charset.newDecoder()
+            .onMalformedInput( CodingErrorAction.REPLACE )
+            .onUnmappableCharacter( CodingErrorAction.REPLACE );
+        return new BufferedReader( Channels.newReader( channel, decoder, -1 ) );
+    }
 }

src/main/java/dan200/computercraft/core/apis/handles/EncodedWritableHandle.java

@@ -4,41 +4,29 @@ import dan200.computercraft.api.lua.ILuaContext;
 import dan200.computercraft.api.lua.LuaException;
 
 import javax.annotation.Nonnull;
-import java.io.*;
+import java.io.BufferedWriter;
+import java.io.Closeable;
+import java.io.IOException;
+import java.nio.channels.Channels;
+import java.nio.channels.WritableByteChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.StandardCharsets;
 
-public class EncodedOutputHandle extends HandleGeneric
+public class EncodedWritableHandle extends HandleGeneric
 {
-    private final BufferedWriter m_writer;
+    private BufferedWriter m_writer;
 
-    public EncodedOutputHandle( BufferedWriter writer )
+    public EncodedWritableHandle( @Nonnull BufferedWriter writer, @Nonnull Closeable closable )
     {
-        super( writer );
+        super( closable );
         this.m_writer = writer;
     }
 
-    public EncodedOutputHandle( OutputStream stream )
+    public EncodedWritableHandle( @Nonnull BufferedWriter writer )
     {
-        this( stream, "UTF-8" );
-    }
-
-    public EncodedOutputHandle( OutputStream stream, String encoding )
-    {
-        this( makeWriter( stream, encoding ) );
-    }
-
-    private static BufferedWriter makeWriter( OutputStream stream, String encoding )
-    {
-        if( encoding == null ) encoding = "UTF-8";
-        OutputStreamWriter streamWriter;
-        try
-        {
-            streamWriter = new OutputStreamWriter( stream, encoding );
-        }
-        catch( UnsupportedEncodingException e )
-        {
-            streamWriter = new OutputStreamWriter( stream );
-        }
-        return new BufferedWriter( streamWriter );
+        this( writer, writer );
     }
 
     @Nonnull
@@ -125,4 +113,20 @@ public class EncodedOutputHandle extends HandleGeneric
                 return null;
         }
     }
+
+
+    public static BufferedWriter openUtf8( WritableByteChannel channel )
+    {
+        return open( channel, StandardCharsets.UTF_8 );
+    }
+
+    public static BufferedWriter open( WritableByteChannel channel, Charset charset )
+    {
+        // Create a charset encoder with the same properties as StreamEncoder does for 
+        // OutputStreams: namely, replace everything instead of erroring.
+        CharsetEncoder encoder = charset.newEncoder()
+            .onMalformedInput( CodingErrorAction.REPLACE)
+            .onUnmappableCharacter(CodingErrorAction.REPLACE);
+        return new BufferedWriter( Channels.newWriter( channel, encoder, -1 ) );
+    }
 }

src/main/java/dan200/computercraft/core/apis/handles/HandleGeneric.java

@@ -3,17 +3,23 @@ package dan200.computercraft.core.apis.handles;
 import dan200.computercraft.api.lua.ILuaObject;
 import dan200.computercraft.api.lua.LuaException;
 
+import javax.annotation.Nonnull;
 import java.io.Closeable;
 import java.io.IOException;
+import java.nio.channels.Channel;
+import java.nio.channels.SeekableByteChannel;
+
+import static dan200.computercraft.core.apis.ArgumentHelper.optInt;
+import static dan200.computercraft.core.apis.ArgumentHelper.optString;
 
 public abstract class HandleGeneric implements ILuaObject
 {
-    protected final Closeable m_closable;
-    protected boolean m_open = true;
+    private Closeable m_closable;
+    private boolean m_open = true;
 
-    public HandleGeneric( Closeable m_closable )
+    protected HandleGeneric( @Nonnull Closeable closable )
     {
-        this.m_closable = m_closable;
+        this.m_closable = closable;
     }
 
     protected void checkOpen() throws LuaException
@@ -21,7 +27,7 @@ public abstract class HandleGeneric implements ILuaObject
         if( !m_open ) throw new LuaException( "attempt to use a closed file" );
     }
 
-    protected void close()
+    protected final void close()
     {
         try
         {
@@ -31,5 +37,64 @@ public abstract class HandleGeneric implements ILuaObject
         catch( IOException ignored )
         {
         }
+        m_closable = null;
+    }
+
+    /**
+     * Shared implementation for various file handle types
+     *
+     * @param channel The channel to seek in
+     * @param args    The Lua arguments to process, like Lua's {@code file:seek}.
+     * @return The new position of the file, or null if some error occured.
+     * @throws LuaException If the arguments were invalid
+     * @see <a href="https://www.lua.org/manual/5.1/manual.html#pdf-file:seek">{@code file:seek} in the Lua manual.</a>
+     */
+    protected static Object[] handleSeek( SeekableByteChannel channel, Object[] args ) throws LuaException
+    {
+        try
+        {
+            String whence = optString( args, 0, "cur" );
+            long offset = optInt( args, 1, 0 );
+            switch( whence )
+            {
+                case "set":
+                    channel.position( offset );
+                    break;
+                case "cur":
+                    channel.position( channel.position() + offset );
+                    break;
+                case "end":
+                    channel.position( channel.size() + offset );
+                    break;
+                default:
+                    throw new LuaException( "bad argument #1 to 'seek' (invalid option '" + whence + "'" );
+            }
+
+            return new Object[]{ channel.position() };
+        }
+        catch( IllegalArgumentException e )
+        {
+            return new Object[]{ false, "Position is negative" };
+        }
+        catch( IOException e )
+        {
+            return null;
+        }
+    }
+
+    protected static SeekableByteChannel asSeekable( Channel channel )
+    {
+        if( !(channel instanceof SeekableByteChannel) ) return null;
+
+        SeekableByteChannel seekable = (SeekableByteChannel) channel;
+        try
+        {
+            seekable.position( seekable.position() );
+            return seekable;
+        }
+        catch( IOException | UnsupportedOperationException e )
+        {
+            return null;
+        }
     }
 }

src/main/java/dan200/computercraft/core/apis/http/HTTPExecutor.java

@@ -8,7 +8,7 @@ package dan200.computercraft.core.apis.http;
 
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import dan200.computercraft.shared.util.ThreadUtils;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.nio.NioEventLoopGroup;
 
@@ -24,18 +24,14 @@ public final class HTTPExecutor
     public static final ListeningExecutorService EXECUTOR = MoreExecutors.listeningDecorator( new ThreadPoolExecutor(
         4, Integer.MAX_VALUE,
         60L, TimeUnit.SECONDS,
-        new SynchronousQueue<Runnable>(),
-        new ThreadFactoryBuilder()
-            .setDaemon( true )
+        new SynchronousQueue<>(),
+        ThreadUtils.builder( "HTTP" )
             .setPriority( Thread.MIN_PRIORITY + (Thread.NORM_PRIORITY - Thread.MIN_PRIORITY) / 2 )
-            .setNameFormat( "ComputerCraft-HTTP-%d" )
             .build()
     ) );
 
-    public static final EventLoopGroup LOOP_GROUP = new NioEventLoopGroup( 4, new ThreadFactoryBuilder()
-        .setDaemon( true )
+    public static final EventLoopGroup LOOP_GROUP = new NioEventLoopGroup( 4, ThreadUtils.builder( "Netty" )
         .setPriority( Thread.MIN_PRIORITY + (Thread.NORM_PRIORITY - Thread.MIN_PRIORITY) / 2 )
-        .setNameFormat( "ComputerCraft-Netty-%d" )
         .build()
     );
 

src/main/java/dan200/computercraft/core/apis/http/HTTPRequest.java

@@ -13,13 +13,17 @@ import dan200.computercraft.api.lua.ILuaContext;
 import dan200.computercraft.api.lua.ILuaObject;
 import dan200.computercraft.api.lua.LuaException;
 import dan200.computercraft.core.apis.IAPIEnvironment;
-import dan200.computercraft.core.apis.handles.BinaryInputHandle;
-import dan200.computercraft.core.apis.handles.EncodedInputHandle;
+import dan200.computercraft.core.apis.handles.ArrayByteChannel;
+import dan200.computercraft.core.apis.handles.BinaryReadableHandle;
+import dan200.computercraft.core.apis.handles.EncodedReadableHandle;
 import dan200.computercraft.core.tracking.TrackingField;
 
 import javax.annotation.Nonnull;
 import java.io.*;
 import java.net.*;
+import java.nio.channels.SeekableByteChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -182,6 +186,10 @@ public class HTTPRequest implements Runnable
             byte[] result = ByteStreams.toByteArray( is );
             is.close();
 
+            String encoding = connection.getContentEncoding();
+            Charset charset = encoding != null && Charset.isSupported( encoding )
+                ? Charset.forName( encoding ) : StandardCharsets.UTF_8;
+
             // We've got some sort of response, so let's build a resulting object.
             Joiner joiner = Joiner.on( ',' );
             Map<String, String> headers = new HashMap<>();
@@ -193,9 +201,11 @@ public class HTTPRequest implements Runnable
             m_environment.addTrackingChange( TrackingField.HTTP_DOWNLOAD,
                 getHeaderSize( connection.getHeaderFields() ) + result.length );
 
-            InputStream contents = new ByteArrayInputStream( result );
+            SeekableByteChannel contents = new ArrayByteChannel( result );
             ILuaObject stream = wrapStream(
-                m_binary ? new BinaryInputHandle( contents ) : new EncodedInputHandle( contents, connection.getContentEncoding() ),
+                m_binary
+                    ? new BinaryReadableHandle( contents )
+                    : new EncodedReadableHandle( EncodedReadableHandle.open( contents, charset ) ),
                 connection.getResponseCode(), headers
             );
 

src/main/java/dan200/computercraft/core/apis/http/WebsocketConnection.java

@@ -13,7 +13,9 @@ import dan200.computercraft.api.lua.LuaException;
 import dan200.computercraft.core.apis.HTTPAPI;
 import dan200.computercraft.core.apis.IAPIEnvironment;
 import dan200.computercraft.core.tracking.TrackingField;
+import dan200.computercraft.shared.util.StringUtil;
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
@@ -26,6 +28,8 @@ import javax.annotation.Nullable;
 import java.io.Closeable;
 import java.io.IOException;
 
+import static dan200.computercraft.core.apis.ArgumentHelper.optBoolean;
+
 public class WebsocketConnection extends SimpleChannelInboundHandler<Object> implements ILuaObject, Closeable
 {
     public static final String SUCCESS_EVENT = "websocket_success";
@@ -174,8 +178,11 @@ public class WebsocketConnection extends SimpleChannelInboundHandler<Object> imp
             {
                 checkOpen();
                 String text = arguments.length > 0 && arguments[0] != null ? arguments[0].toString() : "";
+                boolean binary = optBoolean(arguments, 1, false);
                 computer.addTrackingChange( TrackingField.WEBSOCKET_OUTGOING, text.length() );
-                channel.writeAndFlush( new TextWebSocketFrame( text ) );
+                channel.writeAndFlush( binary
+                    ? new BinaryWebSocketFrame( Unpooled.wrappedBuffer( StringUtil.encodeString( text ) ) )
+                    : new TextWebSocketFrame( text ) );
                 return null;
             }
             case 2:

src/main/java/dan200/computercraft/core/computer/ComputerThread.java

@@ -8,13 +8,14 @@ package dan200.computercraft.core.computer;
 
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.core.tracking.Tracking;
+import dan200.computercraft.shared.util.ThreadUtils;
 
 import java.util.HashSet;
 import java.util.Set;
 import java.util.WeakHashMap;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.ThreadFactory;
 
 public class ComputerThread
 {
@@ -56,8 +57,8 @@ public class ComputerThread
      */
     private static Thread[] s_threads = null;
 
-    private static final AtomicInteger s_ManagerCounter = new AtomicInteger( 1 );
-    private static final AtomicInteger s_DelegateCounter = new AtomicInteger( 1 );
+    private static final ThreadFactory s_ManagerFactory = ThreadUtils.factory( "Computer-Manager" );
+    private static final ThreadFactory s_RunnerFactory = ThreadUtils.factory( "Computer-Runner" );
 
     /**
      * Start the computer thread
@@ -72,16 +73,12 @@ public class ComputerThread
                 s_threads = new Thread[ComputerCraft.computer_threads];
             }
 
-            SecurityManager manager = System.getSecurityManager();
-            final ThreadGroup group = manager == null ? Thread.currentThread().getThreadGroup() : manager.getThreadGroup();
             for( int i = 0; i < s_threads.length; i++ )
             {
                 Thread thread = s_threads[i];
                 if( thread == null || !thread.isAlive() )
                 {
-                    thread = s_threads[i] = new Thread( group, new TaskExecutor(), "ComputerCraft-Computer-Manager-" + s_ManagerCounter.getAndIncrement() );
-                    thread.setDaemon( true );
-                    thread.start();
+                    (s_threads[i] = s_ManagerFactory.newThread( new TaskExecutor() )).start();
                 }
             }
         }
@@ -188,12 +185,7 @@ public class ComputerThread
             if( thread == null || !thread.isAlive() )
             {
                 runner = new TaskRunner();
-
-                SecurityManager manager = System.getSecurityManager();
-                final ThreadGroup group = manager == null ? Thread.currentThread().getThreadGroup() : manager.getThreadGroup();
-                Thread thread = this.thread = new Thread( group, runner, "ComputerCraft-Computer-Runner" + s_DelegateCounter.getAndIncrement() );
-                thread.setDaemon( true );
-                thread.start();
+                (thread = s_RunnerFactory.newThread( runner )).start();
             }
 
             long start = System.nanoTime();

src/main/java/dan200/computercraft/core/computer/IComputerOwned.java

@@ -0,0 +1,9 @@
+package dan200.computercraft.core.computer;
+
+import javax.annotation.Nullable;
+
+public interface IComputerOwned
+{
+    @Nullable
+    Computer getComputer();
+}

src/main/java/dan200/computercraft/core/filesystem/ComboMount.java

@@ -11,6 +11,7 @@ import dan200.computercraft.api.filesystem.IMount;
 import javax.annotation.Nonnull;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.channels.ReadableByteChannel;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
@@ -114,6 +115,7 @@ public class ComboMount implements IMount
 
     @Nonnull
     @Override
+    @Deprecated
     public InputStream openForRead( @Nonnull String path ) throws IOException
     {
         for( int i=m_parts.length-1; i>=0; --i )
@@ -126,4 +128,19 @@ public class ComboMount implements IMount
         }
         throw new IOException( "/" + path + ": No such file" );
     }
+
+    @Nonnull
+    @Override
+    public ReadableByteChannel openChannelForRead( @Nonnull String path ) throws IOException
+    {
+        for( int i=m_parts.length-1; i>=0; --i )
+        {
+            IMount part = m_parts[i];
+            if( part.exists( path ) && !part.isDirectory( path ) )
+            {
+                return part.openChannelForRead( path );
+            }
+        }
+        throw new IOException( "/" + path + ": No such file" );
+    }
 }

src/main/java/dan200/computercraft/core/filesystem/EmptyMount.java

@@ -9,7 +9,9 @@ package dan200.computercraft.core.filesystem;
 import dan200.computercraft.api.filesystem.IMount;
 
 import javax.annotation.Nonnull;
+import java.io.IOException;
 import java.io.InputStream;
+import java.nio.channels.ReadableByteChannel;
 import java.util.List;
 
 public class EmptyMount implements IMount
@@ -45,8 +47,17 @@ public class EmptyMount implements IMount
 
     @Nonnull
     @Override
-    public InputStream openForRead( @Nonnull String path )
+    @Deprecated
+    public InputStream openForRead( @Nonnull String path ) throws IOException
     {
-        return null;
+        throw new IOException( "/" + path + ": No such file" );
+    }
+
+    @Nonnull
+    @Override
+    @Deprecated
+    public ReadableByteChannel openChannelForRead( @Nonnull String path ) throws IOException
+    {
+        throw new IOException( "/" + path + ": No such file" );
     }
 }

src/main/java/dan200/computercraft/core/filesystem/FileMount.java

@@ -6,61 +6,47 @@
 
 package dan200.computercraft.core.filesystem;
 
+import com.google.common.collect.Sets;
 import dan200.computercraft.api.filesystem.IWritableMount;
 
 import javax.annotation.Nonnull;
 import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.channels.*;
+import java.nio.file.Files;
+import java.nio.file.OpenOption;
+import java.nio.file.StandardOpenOption;
+import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 public class FileMount implements IWritableMount
 {
-    private static int MINIMUM_FILE_SIZE = 500;
+    private static final int MINIMUM_FILE_SIZE = 500;
+    private static final Set<OpenOption> READ_OPTIONS = Collections.singleton( StandardOpenOption.READ );
+    private static final Set<OpenOption> WRITE_OPTIONS = Sets.newHashSet( StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING );
+    private static final Set<OpenOption> APPEND_OPTIONS = Sets.newHashSet( StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.APPEND );
 
-    private class CountingOutputStream extends OutputStream
+    private class WritableCountingChannel implements WritableByteChannel
     {
-        private OutputStream m_innerStream;
-        private long m_ignoredBytesLeft;
 
-        public CountingOutputStream( OutputStream innerStream, long bytesToIgnore )
+        private final WritableByteChannel m_inner;
+        long m_ignoredBytesLeft;
+
+        WritableCountingChannel( WritableByteChannel inner, long bytesToIgnore )
         {
-            m_innerStream = innerStream;
+            m_inner = inner;
             m_ignoredBytesLeft = bytesToIgnore;
         }
 
         @Override
-        public void close() throws IOException
+        public int write( @Nonnull ByteBuffer b ) throws IOException
         {
-            m_innerStream.close();
+            count( b.remaining() );
+            return m_inner.write( b );
         }
 
-        @Override
-        public void flush() throws IOException
-        {
-            m_innerStream.flush();
-        }
-        
-        @Override
-        public void write( @Nonnull byte[] b ) throws IOException
-        {
-            count( b.length );
-            m_innerStream.write( b );
-        }
-        
-        @Override
-        public void write( @Nonnull byte[] b, int off, int len ) throws IOException
-        {
-            count( len );
-            m_innerStream.write( b, off, len );
-        }
-
-        @Override
-        public void write( int b ) throws IOException
-        {
-            count( 1 );
-            m_innerStream.write( b );
-        }
-
-        private void count( long n ) throws IOException
+        void count( long n ) throws IOException
         {
             m_ignoredBytesLeft -= n;
             if( m_ignoredBytesLeft < 0 )
@@ -79,6 +65,73 @@ public class FileMount implements IWritableMount
                 }
             }
         }
+
+        @Override
+        public boolean isOpen()
+        {
+            return m_inner.isOpen();
+        }
+
+        @Override
+        public void close() throws IOException
+        {
+            m_inner.close();
+        }
+    }
+
+    private class SeekableCountingChannel extends WritableCountingChannel implements SeekableByteChannel
+    {
+        private final SeekableByteChannel m_inner;
+
+        SeekableCountingChannel( SeekableByteChannel inner, long bytesToIgnore )
+        {
+            super( inner, bytesToIgnore );
+            this.m_inner = inner;
+        }
+
+        @Override
+        public SeekableByteChannel position( long newPosition ) throws IOException
+        {
+            if( !isOpen() ) throw new ClosedChannelException();
+            if( newPosition < 0 ) throw new IllegalArgumentException();
+
+            long delta = newPosition - m_inner.position();
+            if( delta < 0 )
+            {
+                m_ignoredBytesLeft -= delta;
+            }
+            else
+            {
+                count( delta );
+            }
+
+            return m_inner.position( newPosition );
+        }
+
+        @Override
+        public SeekableByteChannel truncate( long size ) throws IOException
+        {
+            throw new IOException( "Not yet implemented" );
+        }
+
+        @Override
+        public int read( ByteBuffer dst ) throws IOException
+        {
+            if( !m_inner.isOpen() ) throw new ClosedChannelException();
+            throw new NonReadableChannelException();
+        }
+
+        @Override
+        public long position() throws IOException
+        {
+            return m_inner.position();
+        }
+
+        @Override
+        public long size() throws IOException
+        {
+            return m_inner.size();
+        }
     }
 
     private File m_rootPath;
@@ -183,6 +236,7 @@ public class FileMount implements IWritableMount
 
     @Nonnull
     @Override
+    @Deprecated
     public InputStream openForRead( @Nonnull String path ) throws IOException
     {
         if( created() )
@@ -193,7 +247,22 @@ public class FileMount implements IWritableMount
                 return new FileInputStream( file );
             }
         }
-        throw new IOException( "/" + path +  ": No such file" );
+        throw new IOException( "/" + path + ": No such file" );
+    }
+
+    @Nonnull
+    @Override
+    public ReadableByteChannel openChannelForRead( @Nonnull String path ) throws IOException
+    {
+        if( created() )
+        {
+            File file = getRealPath( path );
+            if( file.exists() && !file.isDirectory() )
+            {
+                return FileChannel.open( file.toPath(), READ_OPTIONS );
+            }
+        }
+        throw new IOException( "/" + path + ": No such file" );
     }
 
     // IWritableMount implementation
@@ -282,7 +351,23 @@ public class FileMount implements IWritableMount
 
     @Nonnull
     @Override
+    @Deprecated
     public OutputStream openForWrite( @Nonnull String path ) throws IOException
+    {
+        return Channels.newOutputStream( openChannelForWrite( path ) );
+    }
+
+    @Nonnull
+    @Override
+    @Deprecated
+    public OutputStream openForAppend( @Nonnull String path ) throws IOException
+    {
+        return Channels.newOutputStream( openChannelForAppend( path ) );
+    }
+
+    @Nonnull
+    @Override
+    public WritableByteChannel openChannelForWrite( @Nonnull String path ) throws IOException
     {
         create();
         File file = getRealPath( path );
@@ -308,13 +393,13 @@ public class FileMount implements IWritableMount
                 m_usedSpace -= Math.max( file.length(), MINIMUM_FILE_SIZE );
                 m_usedSpace += MINIMUM_FILE_SIZE;
             }
-            return new CountingOutputStream( new FileOutputStream( file, false ), MINIMUM_FILE_SIZE );
+            return new SeekableCountingChannel( Files.newByteChannel( file.toPath(), WRITE_OPTIONS ), MINIMUM_FILE_SIZE );
         }
     }
 
     @Nonnull
     @Override
-    public OutputStream openForAppend( @Nonnull String path ) throws IOException
+    public WritableByteChannel openChannelForAppend( @Nonnull String path ) throws IOException
     {
         if( created() )
         {
@@ -329,7 +414,11 @@ public class FileMount implements IWritableMount
             }
             else
             {
-                return new CountingOutputStream( new FileOutputStream( file, true ), Math.max( MINIMUM_FILE_SIZE - file.length(), 0 ) );
+                // Allowing seeking when appending is not recommended, so we use a separate channel.
+                return new WritableCountingChannel(
+                    Files.newByteChannel( file.toPath(), APPEND_OPTIONS ),
+                    Math.max( MINIMUM_FILE_SIZE - file.length(), 0 )
+                );
             }
         }
         else

src/main/java/dan200/computercraft/core/filesystem/FileSystem.java

@@ -6,13 +6,23 @@
 
 package dan200.computercraft.core.filesystem;
 
+import com.google.common.io.ByteStreams;
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.api.filesystem.IFileSystem;
 import dan200.computercraft.api.filesystem.IMount;
 import dan200.computercraft.api.filesystem.IWritableMount;
 
-import java.io.*;
+import javax.annotation.Nonnull;
+import java.io.Closeable;
+import java.io.IOException;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.nio.file.AccessDeniedException;
 import java.util.*;
+import java.util.function.Function;
 import java.util.regex.Pattern;
 
 public class FileSystem
@@ -146,14 +156,14 @@ public class FileSystem
             }
         }
     
-        public InputStream openForRead( String path ) throws FileSystemException
+        public ReadableByteChannel openForRead( String path ) throws FileSystemException
         {
             path = toLocal( path );
             try
             {
                 if( m_mount.exists( path ) && !m_mount.isDirectory( path ) )
                 {
-                    return m_mount.openForRead( path );
+                    return m_mount.openChannelForRead( path );
                 }
                 else
                 {
@@ -209,13 +219,17 @@ public class FileSystem
                     m_writableMount.delete( path );
                 }
             }
+            catch( AccessDeniedException e )
+            {
+                throw new FileSystemException( "Access denied" );
+            }
             catch( IOException e )
             {
                 throw new FileSystemException( e.getMessage() );
             }
         }
     
-        public OutputStream openForWrite( String path ) throws FileSystemException
+        public WritableByteChannel openForWrite( String path ) throws FileSystemException
         {
             if( m_writableMount == null )
             {
@@ -238,16 +252,20 @@ public class FileSystem
                             m_writableMount.makeDirectory( dir );
                         }
                     }
-                    return m_writableMount.openForWrite( path );
+                    return m_writableMount.openChannelForWrite( path );
                 }
             }
+            catch( AccessDeniedException e )
+            {
+                throw new FileSystemException( "Access denied" );
+            }
             catch( IOException e )
             {
                 throw new FileSystemException( e.getMessage() );
             }
         }
         
-        public OutputStream openForAppend( String path ) throws FileSystemException
+        public WritableByteChannel openForAppend( String path ) throws FileSystemException
         {
             if( m_writableMount == null )
             {
@@ -266,7 +284,7 @@ public class FileSystem
                             m_writableMount.makeDirectory( dir );
                         }
                     }
-                    return m_writableMount.openForWrite( path );
+                    return m_writableMount.openChannelForWrite( path );
                 }
                 else if( m_mount.isDirectory( path ) )
                 {
@@ -274,9 +292,13 @@ public class FileSystem
                 }
                 else
                 {
-                    return m_writableMount.openForAppend( path );
+                    return m_writableMount.openChannelForAppend( path );
                 }
             }
+            catch( AccessDeniedException e )
+            {
+                throw new FileSystemException( "Access denied" );
+            }
             catch( IOException e )
             {
                 throw new FileSystemException( e.getMessage() );
@@ -291,9 +313,11 @@ public class FileSystem
         }
     }
 
-    private final FileSystemMount m_wrapper = new FileSystemMount( this );
+    private final FileSystemWrapperMount m_wrapper = new FileSystemWrapperMount( this );
     private final Map<String, MountWrapper> m_mounts = new HashMap<>();
-    private final Set<Closeable> m_openFiles = Collections.newSetFromMap( new WeakHashMap<Closeable, Boolean>() );
+
+    private final HashMap<WeakReference<FileSystemWrapper<?>>, Closeable> m_openFiles = new HashMap<>();
+    private final ReferenceQueue<FileSystemWrapper<?>> m_openFileQueue = new ReferenceQueue<>();
 
     public FileSystem( String rootLabel, IMount rootMount ) throws FileSystemException
     {
@@ -310,24 +334,15 @@ public class FileSystem
         // Close all dangling open files
         synchronized( m_openFiles )
         {
-            for( Closeable file : m_openFiles )
-            {
-                try {
-                    file.close();
-                } catch (IOException e) {
-                    // Ignore
-                }
-            }
+            for( Closeable file : m_openFiles.values() ) closeQuietly( file );
             m_openFiles.clear();
+            while( m_openFileQueue.poll() != null ) ;
         }
     }
     
     public synchronized void mount( String label, String location, IMount mount ) throws FileSystemException
     {
-        if( mount == null )
-        {
-            throw new NullPointerException();
-        }
+        if( mount == null ) throw new NullPointerException();
         location = sanitizePath( location );
         if( location.contains( ".." ) ) {
             throw new FileSystemException( "Cannot mount below the root" );
@@ -352,20 +367,14 @@ public class FileSystem
     private synchronized void mount( MountWrapper wrapper )
     {
         String location = wrapper.getLocation();
-        if( m_mounts.containsKey( location ) )
-        {
-            m_mounts.remove( location );
-        }
+        m_mounts.remove( location );
         m_mounts.put( location, wrapper );
     }
         
     public synchronized void unmount( String path )
     {
         path = sanitizePath( path );
-        if( m_mounts.containsKey( path ) )
-        {
-            m_mounts.remove( path );
-        }
+        m_mounts.remove( path );
     }
         
     public synchronized String combine( String path, String childPath )
@@ -599,108 +608,85 @@ public class FileSystem
         else
         {
             // Copy a file:
-            InputStream source = null;
-            OutputStream destination = null;
-            try
+            try( ReadableByteChannel source = sourceMount.openForRead( sourcePath );
+                 WritableByteChannel destination = destinationMount.openForWrite( destinationPath ) )
             {
-                // Open both files
-                source = sourceMount.openForRead( sourcePath );
-                destination = destinationMount.openForWrite( destinationPath );
-            
                 // Copy bytes as fast as we can
-                byte[] buffer = new byte[1024];
-                while( true )
-                {
-                    int bytesRead = source.read( buffer );
-                    if( bytesRead >= 0 )
-                    {
-                        destination.write( buffer, 0, bytesRead );
-                    }
-                    else
-                    {
-                        break;
-                    }
-                }
+                ByteStreams.copy( source, destination );
+            }
+            catch( AccessDeniedException e )
+            {
+                throw new FileSystemException( "Access denied" );
             }
             catch( IOException e )
             {
                 throw new FileSystemException( e.getMessage() );
             }
-            finally
+        }
+    }
+
+    private void cleanup()
+    {
+        synchronized( m_openFiles )
+        {
+            Reference<?> ref;
+            while( (ref = m_openFileQueue.poll()) != null )
             {
-                // Close both files
-                if( source != null )
-                {
-                    try {
-                        source.close();
-                    } catch( IOException e ) {
-                        // nobody cares
-                    }
-                }
-                if( destination != null )
-                {
-                    try {
-                        destination.close();
-                    } catch( IOException e ) {
-                        // nobody cares
-                    }
-                }
+                Closeable file = m_openFiles.remove( ref );
+                if( file != null ) closeQuietly( file );
             }
         }
     }
 
-    private synchronized <T> T openFile( T file, Closeable handle ) throws FileSystemException
+    private synchronized <T extends Closeable> FileSystemWrapper<T> openFile( @Nonnull T file ) throws FileSystemException
     {
         synchronized( m_openFiles )
         {
             if( ComputerCraft.maximumFilesOpen > 0 &&
                 m_openFiles.size() >= ComputerCraft.maximumFilesOpen )
             {
-                if( handle != null )
-                {
-                    try {
-                        handle.close();
-                    } catch ( IOException ignored ) {
-                        // shrug
-                    }
-                }
-                throw new FileSystemException("Too many files already open");
+                closeQuietly( file );
+                throw new FileSystemException( "Too many files already open" );
             }
 
-            m_openFiles.add( handle );
-            return file;
+            FileSystemWrapper<T> wrapper = new FileSystemWrapper<>( this, file, m_openFileQueue );
+            m_openFiles.put( wrapper.self, file );
+            return wrapper;
         }
     }
 
-    private synchronized void closeFile( Closeable handle ) throws IOException
+    synchronized void removeFile( FileSystemWrapper<?> handle ) 
     {
         synchronized( m_openFiles )
         {
-            m_openFiles.remove( handle );
-            handle.close();
+            m_openFiles.remove( handle.self );
         }
     }
 
-    public synchronized InputStream openForRead( String path ) throws FileSystemException
+    public synchronized <T extends Closeable> FileSystemWrapper<T> openForRead( String path, Function<ReadableByteChannel, T> open ) throws FileSystemException
     {
-        path = sanitizePath ( path );
+        cleanup();
+
+        path = sanitizePath( path );
         MountWrapper mount = getMount( path );
-        InputStream stream = mount.openForRead( path );
-        if( stream != null )
+        ReadableByteChannel channel = mount.openForRead( path );
+        if( channel != null )
         {
-            return openFile( new ClosingInputStream( stream ), stream );
+            return openFile( open.apply( channel ) );
         }
         return null;
     }
 
-    public synchronized OutputStream openForWrite( String path, boolean append ) throws FileSystemException
+    public synchronized <T extends Closeable> FileSystemWrapper<T> openForWrite( String path, boolean append, Function<WritableByteChannel, T> open ) throws FileSystemException
     {
-        path = sanitizePath ( path );
+        cleanup();
+
+        path = sanitizePath( path );
         MountWrapper mount = getMount( path );
-        OutputStream stream = append ? mount.openForAppend( path ) : mount.openForWrite( path );
-        if( stream != null )
+        WritableByteChannel channel = append ? mount.openForAppend( path ) : mount.openForWrite( path );
+        if( channel != null )
         {
-            return openFile( new ClosingOutputStream( stream ), stream );
+            return openFile( open.apply( channel ) );
         }
         return null;
     }
@@ -865,33 +851,14 @@ public class FileSystem
         }
     }
 
-    private class ClosingInputStream extends FilterInputStream
+    private static void closeQuietly( Closeable c )
     {
-        protected ClosingInputStream( InputStream in )
+        try
         {
-            super( in );
+            c.close();
         }
-
-        @Override
-        public void close() throws IOException
+        catch( IOException ignored )
         {
-            super.close();
-            closeFile( in );
-        }
-    }
-
-    private class ClosingOutputStream extends FilterOutputStream
-    {
-        protected ClosingOutputStream( OutputStream out )
-        {
-            super( out );
-        }
-
-        @Override
-        public void close() throws IOException
-        {
-            super.close();
-            closeFile( out );
         }
     }
 }

src/main/java/dan200/computercraft/core/filesystem/FileSystemMount.java

@@ -1,185 +1,132 @@
 package dan200.computercraft.core.filesystem;
 
-import dan200.computercraft.api.filesystem.IFileSystem;
+import dan200.computercraft.api.filesystem.IMount;
 
 import javax.annotation.Nonnull;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.OutputStream;
-import java.util.Collections;
-import java.util.List;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.file.FileSystem;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.*;
+import java.util.stream.Stream;
 
-public class FileSystemMount implements IFileSystem
+public class FileSystemMount implements IMount
 {
-    private final FileSystem m_filesystem;
+    private final Entry rootEntry;
 
-    public FileSystemMount( FileSystem m_filesystem )
+    public FileSystemMount( FileSystem fileSystem, String root ) throws IOException
     {
-        this.m_filesystem = m_filesystem;
-    }
+        Path rootPath = fileSystem.getPath( root );
+        rootEntry = new Entry( "", rootPath );
 
-    @Override
-    public void makeDirectory( @Nonnull String path ) throws IOException
-    {
-        try
+        Queue<Entry> entries = new ArrayDeque<>();
+        entries.add( rootEntry );
+        while( !entries.isEmpty() )
         {
-            m_filesystem.makeDir( path );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
+            Entry entry = entries.remove();
+            try( Stream<Path> childStream = Files.list( entry.path ) )
+            {
+                Iterator<Path> children = childStream.iterator();
+                while( children.hasNext() )
+                {
+                    Path childPath = children.next();
+                    Entry child = new Entry( childPath.getFileName().toString(), childPath );
+                    entry.children.put( child.name, child );
+                    if( child.directory ) entries.add( child );
+                }
+            }
         }
     }
 
     @Override
-    public void delete( @Nonnull String path ) throws IOException
+    public boolean exists( @Nonnull String path )
     {
-        try
-        {
-            m_filesystem.delete( path );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
-    }
-
-    @Nonnull
-    @Override
-    public OutputStream openForWrite( @Nonnull String path ) throws IOException
-    {
-        try
-        {
-            return m_filesystem.openForWrite( path, false );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
-    }
-
-    @Nonnull
-    @Override
-    public OutputStream openForAppend( @Nonnull String path ) throws IOException
-    {
-        try
-        {
-            return m_filesystem.openForWrite( path, true );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
+        return getFile( path ) != null;
     }
 
     @Override
-    public long getRemainingSpace() throws IOException
+    public boolean isDirectory( @Nonnull String path )
     {
-        try
-        {
-            return m_filesystem.getFreeSpace( "/" );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
-    }
-
-    @Override
-    public boolean exists( @Nonnull String path ) throws IOException
-    {
-        try
-        {
-            return m_filesystem.exists( path );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
-    }
-
-    @Override
-    public boolean isDirectory( @Nonnull String path ) throws IOException
-    {
-        try
-        {
-            return m_filesystem.exists( path );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
+        Entry entry = getFile( path );
+        return entry != null && entry.directory;
     }
 
     @Override
     public void list( @Nonnull String path, @Nonnull List<String> contents ) throws IOException
     {
-        try
-        {
-            Collections.addAll( contents, m_filesystem.list( path ) );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
+        Entry entry = getFile( path );
+        if( entry == null || !entry.directory ) throw new IOException( "/" + path + ": Not a directory" );
+
+        contents.addAll( entry.children.keySet() );
     }
 
     @Override
     public long getSize( @Nonnull String path ) throws IOException
     {
-        try
-        {
-            return m_filesystem.getSize( path );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
+        Entry file = getFile( path );
+        if( file == null ) throw new IOException( "/" + path + ": No such file" );
+        return file.size;
     }
 
     @Nonnull
     @Override
+    @Deprecated
     public InputStream openForRead( @Nonnull String path ) throws IOException
     {
-        try
-        {
-            return m_filesystem.openForRead( path );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
-        }
+        Entry file = getFile( path );
+        if( file == null || file.directory ) throw new IOException( "/" + path + ": No such file" );
+
+        return Files.newInputStream( file.path, StandardOpenOption.READ );
     }
 
+    @Nonnull
     @Override
-    public String combine( String path, String child )
+    public ReadableByteChannel openChannelForRead( @Nonnull String path ) throws IOException
     {
-        return m_filesystem.combine( path, child );
+        Entry file = getFile( path );
+        if( file == null || file.directory ) throw new IOException( "/" + path + ": No such file" );
+
+        return Files.newByteChannel( file.path, StandardOpenOption.READ );
     }
 
-    @Override
-    public void copy( String from, String to ) throws IOException
+    private Entry getFile( String path )
     {
-        try
+        if( path.equals( "" ) ) return rootEntry;
+        if( !path.contains( "/" ) ) return rootEntry.children.get( path );
+
+        String[] components = path.split( "/" );
+        Entry entry = rootEntry;
+        for( String component : components )
         {
-            m_filesystem.copy( from, to );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
+            if( entry == null || entry.children == null ) return null;
+            entry = entry.children.get( component );
         }
+
+        return entry;
     }
 
-    @Override
-    public void move( String from, String to ) throws IOException
+    private static class Entry
     {
-        try
+        final String name;
+        final Path path;
+
+        final boolean directory;
+        final long size;
+        final Map<String, Entry> children;
+
+        private Entry( String name, Path path ) throws IOException
         {
-            m_filesystem.move( from, to );
-        }
-        catch( FileSystemException e )
-        {
-            throw new IOException( e.getMessage() );
+            if( name.endsWith( "/" ) || name.endsWith( "\\" ) ) name = name.substring( 0, name.length() - 1 );
+
+            this.name = name;
+            this.path = path;
+
+            BasicFileAttributes attributes = Files.readAttributes( path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS );
+            this.directory = attributes.isDirectory();
+            this.size = directory ? 0 : attributes.size();
+            this.children = directory ? new HashMap<>() : null;
         }
     }
 }

src/main/java/dan200/computercraft/core/filesystem/FileSystemWrapper.java

@@ -0,0 +1,42 @@
+package dan200.computercraft.core.filesystem;
+
+import javax.annotation.Nonnull;
+import java.io.Closeable;
+import java.io.IOException;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+/**
+ * An alternative closeable implementation that will free up resources in the filesystem.
+ *
+ * In an ideal world, we'd just wrap the closeable. However, as we do some {@code instanceof} checks
+ * on the stream, it's not really possible as it'd require numerous instances.
+ *
+ * @param <T> The stream to wrap.
+ */
+public class FileSystemWrapper<T extends Closeable> implements Closeable
+{
+    private final FileSystem fileSystem;
+    private final T closeable;
+    final WeakReference<FileSystemWrapper<?>> self;
+
+    FileSystemWrapper( FileSystem fileSystem, T closeable, ReferenceQueue<FileSystemWrapper<?>> queue )
+    {
+        this.fileSystem = fileSystem;
+        this.closeable = closeable;
+        this.self = new WeakReference<>( this, queue );
+    }
+
+    @Override
+    public void close() throws IOException
+    {
+        fileSystem.removeFile( this );
+        closeable.close();
+    }
+
+    @Nonnull
+    public T get()
+    {
+        return closeable;
+    }
+}

src/main/java/dan200/computercraft/core/filesystem/FileSystemWrapperMount.java

@@ -0,0 +1,220 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2018. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+
+package dan200.computercraft.core.filesystem;
+
+import dan200.computercraft.api.filesystem.IFileSystem;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+
+public class FileSystemWrapperMount implements IFileSystem
+{
+    private final FileSystem m_filesystem;
+
+    public FileSystemWrapperMount( FileSystem m_filesystem )
+    {
+        this.m_filesystem = m_filesystem;
+    }
+
+    @Override
+    public void makeDirectory( @Nonnull String path ) throws IOException
+    {
+        try
+        {
+            m_filesystem.makeDir( path );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Override
+    public void delete( @Nonnull String path ) throws IOException
+    {
+        try
+        {
+            m_filesystem.delete( path );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Nonnull
+    @Override
+    public ReadableByteChannel openChannelForRead( @Nonnull String path ) throws IOException
+    {
+        try
+        {
+            // FIXME: Think of a better way of implementing this, so closing this will close on the computer.
+            return m_filesystem.openForRead( path, Function.identity() ).get();
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Nonnull
+    @Override
+    public WritableByteChannel openChannelForWrite( @Nonnull String path ) throws IOException
+    {
+        try
+        {
+            return m_filesystem.openForWrite( path, false, Function.identity() ).get();
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Nonnull
+    @Override
+    public WritableByteChannel openChannelForAppend( @Nonnull String path ) throws IOException
+    {
+        try
+        {
+            return m_filesystem.openForWrite( path, true, Function.identity() ).get();
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Nonnull
+    @Override
+    @Deprecated
+    public InputStream openForRead( @Nonnull String path ) throws IOException
+    {
+        return Channels.newInputStream( openChannelForRead( path ) );
+    }
+
+    @Nonnull
+    @Override
+    @Deprecated
+    public OutputStream openForWrite( @Nonnull String path ) throws IOException
+    {
+        return Channels.newOutputStream( openChannelForWrite( path ) );
+    }
+
+    @Nonnull
+    @Override
+    @Deprecated
+    public OutputStream openForAppend( @Nonnull String path ) throws IOException
+    {
+        return Channels.newOutputStream( openChannelForAppend( path ) );
+    }
+
+    @Override
+    public long getRemainingSpace() throws IOException
+    {
+        try
+        {
+            return m_filesystem.getFreeSpace( "/" );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Override
+    public boolean exists( @Nonnull String path ) throws IOException
+    {
+        try
+        {
+            return m_filesystem.exists( path );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Override
+    public boolean isDirectory( @Nonnull String path ) throws IOException
+    {
+        try
+        {
+            return m_filesystem.exists( path );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Override
+    public void list( @Nonnull String path, @Nonnull List<String> contents ) throws IOException
+    {
+        try
+        {
+            Collections.addAll( contents, m_filesystem.list( path ) );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Override
+    public long getSize( @Nonnull String path ) throws IOException
+    {
+        try
+        {
+            return m_filesystem.getSize( path );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Override
+    public String combine( String path, String child )
+    {
+        return m_filesystem.combine( path, child );
+    }
+
+    @Override
+    public void copy( String from, String to ) throws IOException
+    {
+        try
+        {
+            m_filesystem.copy( from, to );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+
+    @Override
+    public void move( String from, String to ) throws IOException
+    {
+        try
+        {
+            m_filesystem.move( from, to );
+        }
+        catch( FileSystemException e )
+        {
+            throw new IOException( e.getMessage() );
+        }
+    }
+}

src/main/java/dan200/computercraft/core/filesystem/JarMount.java

@@ -20,9 +20,10 @@ import java.util.Map;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
+@Deprecated
 public class JarMount implements IMount
 {
-    private class FileInZip
+    private static class FileInZip
     {
         private String m_path;
         private boolean m_directory;
@@ -73,7 +74,7 @@ public class JarMount implements IMount
 
             // Otherwise, get the next component of the path
             String localPath = FileSystem.toLocal( path, m_path );
-            int slash = localPath.indexOf("/");
+            int slash = localPath.indexOf( "/" );
             if( slash >= 0 )
             {
                 localPath = localPath.substring( 0, slash );
@@ -109,6 +110,7 @@ public class JarMount implements IMount
     private FileInZip m_root;
     private String m_rootPath;
 
+    @Deprecated
     public JarMount( File jarFile, String subPath ) throws IOException
     {
         if( !jarFile.exists() || jarFile.isDirectory() )
@@ -203,7 +205,7 @@ public class JarMount implements IMount
         }
         else
         {
-            throw new IOException(  "/" + path + ": Not a directory" );
+            throw new IOException( "/" + path + ": Not a directory" );
         }
     }
 
@@ -215,7 +217,7 @@ public class JarMount implements IMount
         {
             return file.getSize();
         }
-        throw new IOException(  "/" + path + ": No such file" );
+        throw new IOException( "/" + path + ": No such file" );
     }
 
     @Nonnull
@@ -243,6 +245,6 @@ public class JarMount implements IMount
                 // treat errors as non-existance of file
             }
         }
-        throw new IOException(  "/" + path  + ": No such file" );
+        throw new IOException( "/" + path + ": No such file" );
     }
 }

src/main/java/dan200/computercraft/core/filesystem/SubMount.java

@@ -11,6 +11,7 @@ import dan200.computercraft.api.filesystem.IMount;
 import javax.annotation.Nonnull;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.channels.ReadableByteChannel;
 import java.util.List;
 
 public class SubMount implements IMount
@@ -52,11 +53,19 @@ public class SubMount implements IMount
 
     @Nonnull
     @Override
+    @Deprecated
     public InputStream openForRead( @Nonnull String path ) throws IOException
     {
         return m_parent.openForRead( getFullPath( path ) );
     }
 
+    @Nonnull
+    @Override
+    public ReadableByteChannel openChannelForRead( @Nonnull String path ) throws IOException
+    {
+        return m_parent.openChannelForRead( getFullPath( path ) );
+    }
+
     private String getFullPath( String path )
     {
         if( path.length() == 0 )

src/main/java/dan200/computercraft/core/lua/CobaltLuaMachine.java

@@ -7,14 +7,13 @@
 package dan200.computercraft.core.lua;
 
 import dan200.computercraft.ComputerCraft;
-import dan200.computercraft.api.lua.ILuaContext;
-import dan200.computercraft.api.lua.ILuaObject;
-import dan200.computercraft.api.lua.ILuaTask;
-import dan200.computercraft.api.lua.LuaException;
-import dan200.computercraft.api.lua.ILuaAPI;
+import dan200.computercraft.api.lua.*;
 import dan200.computercraft.core.computer.Computer;
 import dan200.computercraft.core.computer.ITask;
 import dan200.computercraft.core.computer.MainThread;
+import dan200.computercraft.core.tracking.Tracking;
+import dan200.computercraft.core.tracking.TrackingField;
+import dan200.computercraft.shared.util.ThreadUtils;
 import org.squiddev.cobalt.*;
 import org.squiddev.cobalt.compiler.CompileException;
 import org.squiddev.cobalt.compiler.LoadState;
@@ -25,7 +24,7 @@ import org.squiddev.cobalt.function.LibFunction;
 import org.squiddev.cobalt.function.LuaFunction;
 import org.squiddev.cobalt.function.VarArgFunction;
 import org.squiddev.cobalt.lib.*;
-import org.squiddev.cobalt.lib.platform.AbstractResourceManipulator;
+import org.squiddev.cobalt.lib.platform.VoidResourceManipulator;
 
 import javax.annotation.Nonnull;
 import java.io.IOException;
@@ -35,6 +34,9 @@ import java.util.Arrays;
 import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.Map;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 import static org.squiddev.cobalt.Constants.NONE;
 import static org.squiddev.cobalt.ValueFactory.valueOf;
@@ -42,12 +44,19 @@ import static org.squiddev.cobalt.ValueFactory.varargsOf;
 
 public class CobaltLuaMachine implements ILuaMachine
 {
+    private static final ThreadPoolExecutor coroutines = new ThreadPoolExecutor(
+        0, Integer.MAX_VALUE,
+        60L, TimeUnit.SECONDS,
+        new SynchronousQueue<>(),
+        ThreadUtils.factory( "Coroutine" )
+    );
+
     private final Computer m_computer;
 
-    private final LuaState m_state;
-    private final LuaTable m_globals;
-
+    private LuaState m_state;
+    private LuaTable m_globals;
     private LuaThread m_mainRoutine;
+
     private String m_eventFilter;
     private String m_softAbortMessage;
     private String m_hardAbortMessage;
@@ -57,60 +66,71 @@ public class CobaltLuaMachine implements ILuaMachine
         m_computer = computer;
 
         // Create an environment to run in
-        final LuaState state = this.m_state = new LuaState( new AbstractResourceManipulator()
-        {
-            @Override
-            public InputStream findResource( String filename )
+        LuaState state = this.m_state = LuaState.builder()
+            .resourceManipulator( new VoidResourceManipulator() )
+            .debug( new DebugHandler()
             {
-                return null;
-            }
-        } );
-        state.debug = new DebugHandler( state )
-        {
-            private int count = 0;
-            private boolean hasSoftAbort;
+                private int count = 0;
+                private boolean hasSoftAbort;
 
-            @Override
-            public void onInstruction( DebugState ds, DebugFrame di, int pc, Varargs extras, int top ) throws LuaError
-            {
-                int count = ++this.count;
-                if( count > 100000 )
+                @Override
+                public void onInstruction( DebugState ds, DebugFrame di, int pc, Varargs extras, int top ) throws LuaError
                 {
-                    if( m_hardAbortMessage != null ) LuaThread.yield( state, NONE );
-                    this.count = 0;
+                    int count = ++this.count;
+                    if( count > 100000 )
+                    {
+                        if( m_hardAbortMessage != null ) LuaThread.yield( m_state, NONE );
+                        this.count = 0;
+                    }
+                    else
+                    {
+                        handleSoftAbort();
+                    }
+
+                    super.onInstruction( ds, di, pc, extras, top );
                 }
-                else
+
+                @Override
+                public void poll() throws LuaError
                 {
+                    if( m_hardAbortMessage != null ) LuaThread.yield( m_state, NONE );
                     handleSoftAbort();
                 }
 
-                super.onInstruction( ds, di, pc, extras, top );
-            }
+                private void handleSoftAbort() throws LuaError
+                {
+                    // If the soft abort has been cleared then we can reset our flags and continue.
+                    String message = m_softAbortMessage;
+                    if( message == null )
+                    {
+                        hasSoftAbort = false;
+                        return;
+                    }
 
-            @Override
-            public void poll() throws LuaError
-            {
-                if( m_hardAbortMessage != null ) LuaThread.yield( state, NONE );
-                handleSoftAbort();
-            }
+                    if( hasSoftAbort && m_hardAbortMessage == null )
+                    {
+                        // If we have fired our soft abort, but we haven't been hard aborted then everything is OK.
+                        return;
+                    }
 
-            private void handleSoftAbort() throws LuaError {
-                // If the soft abort has been cleared then we can reset our flags and continue.
-                String message = m_softAbortMessage;
-                if (message == null) {
-                    hasSoftAbort = false;
-                    return;
+                    hasSoftAbort = true;
+                    throw new LuaError( message );
                 }
-
-                if (hasSoftAbort && m_hardAbortMessage == null) {
-                    // If we have fired our soft abort, but we haven't been hard aborted then everything is OK.
-                    return;
-                }
-
-                hasSoftAbort = true;
-                throw new LuaError(message);
-            }
-        };
+            } )
+            .coroutineFactory( command -> {
+                Tracking.addValue( m_computer, TrackingField.COROUTINES_CREATED, 1 );
+                coroutines.execute( () -> {
+                    try
+                    {
+                        command.run();
+                    }
+                    finally
+                    {
+                        Tracking.addValue( m_computer, TrackingField.COROUTINES_DISPOSED, 1 );
+                    }
+                } );
+            } )
+            .build();
 
         m_globals = new LuaTable();
         state.setupThread( m_globals );
@@ -128,7 +148,7 @@ public class CobaltLuaMachine implements ILuaMachine
         LibFunction.bind( state, m_globals, PrefixLoader.class, new String[]{ "load", "loadstring" } );
 
         // Remove globals we don't want to expose
-        m_globals.rawset( "collectgarbage", Constants.NIL );
+        // m_globals.rawset( "collectgarbage", Constants.NIL );
         m_globals.rawset( "dofile", Constants.NIL );
         m_globals.rawset( "loadfile", Constants.NIL );
         m_globals.rawset( "print", Constants.NIL );
@@ -166,10 +186,7 @@ public class CobaltLuaMachine implements ILuaMachine
     public void loadBios( InputStream bios )
     {
         // Begin executing a file (ie, the bios)
-        if( m_mainRoutine != null )
-        {
-            return;
-        }
+        if( m_mainRoutine != null ) return;
 
         try
         {
@@ -178,30 +195,19 @@ public class CobaltLuaMachine implements ILuaMachine
         }
         catch( CompileException e )
         {
-            if( m_mainRoutine != null )
-            {
-                m_mainRoutine.abandon();
-                m_mainRoutine = null;
-            }
+            unload();
         }
         catch( IOException e )
         {
             ComputerCraft.log.warn( "Could not load bios.lua ", e );
-            if( m_mainRoutine != null )
-            {
-                m_mainRoutine.abandon();
-                m_mainRoutine = null;
-            }
+            unload();
         }
     }
 
     @Override
     public void handleEvent( String eventName, Object[] arguments )
     {
-        if( m_mainRoutine == null )
-        {
-            return;
-        }
+        if( m_mainRoutine == null ) return;
 
         if( m_eventFilter != null && eventName != null && !eventName.equals( m_eventFilter ) && !eventName.equals( "terminate" ) )
         {
@@ -228,26 +234,14 @@ public class CobaltLuaMachine implements ILuaMachine
             else
             {
                 LuaValue filter = results.arg( 2 );
-                if( filter.isString() )
-                {
-                    m_eventFilter = filter.toString();
-                }
-                else
-                {
-                    m_eventFilter = null;
-                }
+                m_eventFilter = filter.isString() ? filter.toString() : null;
             }
 
-            LuaThread mainThread = m_mainRoutine;
-            if( mainThread.getStatus().equals( "dead" ) )
-            {
-                m_mainRoutine = null;
-            }
+            if( m_mainRoutine.getStatus().equals( "dead" ) ) unload();
         }
         catch( LuaError e )
         {
-            m_mainRoutine.abandon();
-            m_mainRoutine = null;
+            unload();
         }
         finally
         {
@@ -284,18 +278,18 @@ public class CobaltLuaMachine implements ILuaMachine
     @Override
     public boolean isFinished()
     {
-        return (m_mainRoutine == null);
+        return m_mainRoutine == null;
     }
 
     @Override
     public void unload()
     {
-        if( m_mainRoutine != null )
-        {
-            LuaThread mainThread = m_mainRoutine;
-            mainThread.abandon();
-            m_mainRoutine = null;
-        }
+        if( m_state == null ) return;
+
+        m_state.abandon();
+        m_mainRoutine = null;
+        m_state = null;
+        m_globals = null;
     }
 
     private LuaTable wrapLuaObject( ILuaObject object )
@@ -691,7 +685,7 @@ public class CobaltLuaMachine implements ILuaMachine
         private byte[] bytes;
         private int offset, remaining = 0;
 
-        public StringInputStream( LuaState state, LuaValue func )
+        StringInputStream( LuaState state, LuaValue func )
         {
             this.state = state;
             this.func = func;

src/main/java/dan200/computercraft/core/tracking/ComputerTracker.java

@@ -1,7 +1,7 @@
 package dan200.computercraft.core.tracking;
 
 import dan200.computercraft.core.computer.Computer;
-import gnu.trove.map.hash.TObjectLongHashMap;
+import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
 
 import javax.annotation.Nullable;
 import java.lang.ref.WeakReference;
@@ -18,13 +18,13 @@ public class ComputerTracker
     private long serverCount;
     private long serverTime;
 
-    private final TObjectLongHashMap<TrackingField> fields;
+    private final Object2LongOpenHashMap<TrackingField> fields;
 
     public ComputerTracker( Computer computer )
     {
         this.computer = new WeakReference<>( computer );
         this.computerId = computer.getID();
-        this.fields = new TObjectLongHashMap<>();
+        this.fields = new Object2LongOpenHashMap<>();
     }
 
     ComputerTracker( ComputerTracker timings )
@@ -39,7 +39,7 @@ public class ComputerTracker
         this.serverCount = timings.serverCount;
         this.serverTime = timings.serverTime;
 
-        this.fields = new TObjectLongHashMap<>( timings.fields );
+        this.fields = new Object2LongOpenHashMap<>( timings.fields );
     }
 
     @Nullable
@@ -90,7 +90,7 @@ public class ComputerTracker
     {
         synchronized( fields )
         {
-            fields.adjustOrPutValue( field, change, change );
+            fields.addTo( field, change );
         }
     }
 
@@ -106,7 +106,7 @@ public class ComputerTracker
 
         synchronized( fields )
         {
-            return fields.get( field );
+            return fields.getLong( field );
         }
     }
 

src/main/java/dan200/computercraft/core/tracking/TrackingField.java

@@ -28,6 +28,9 @@ public class TrackingField
     public static final TrackingField WEBSOCKET_INCOMING = TrackingField.of( "websocket_incoming", "Websocket incoming", TrackingField::formatBytes );
     public static final TrackingField WEBSOCKET_OUTGOING = TrackingField.of( "websocket_outgoing", "Websocket outgoing", TrackingField::formatBytes );
 
+    public static final TrackingField COROUTINES_CREATED = TrackingField.of( "coroutines_created", "Coroutines created", x -> String.format( "%4d", x ) );
+    public static final TrackingField COROUTINES_DISPOSED = TrackingField.of( "coroutines_dead", "Coroutines disposed", x -> String.format( "%4d", x ) );
+
     private final String id;
     private final String displayName;
     private final LongFunction<String> format;

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

@@ -20,10 +20,10 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.text.ITextComponent;
 import net.minecraft.util.text.TextComponentString;
 import net.minecraft.world.World;
-import net.minecraftforge.common.util.FakePlayer;
 
 import javax.annotation.Nonnull;
 import java.util.*;
+import java.util.function.Consumer;
 
 import static dan200.computercraft.shared.command.framework.ChatHelpers.*;
 
@@ -59,7 +59,7 @@ public final class CommandComputerCraft extends CommandDelegate
             {
                 if( arguments.size() == 0 )
                 {
-                    TextTable table = new TextTable( DUMP_LIST_ID, "Instance", "Id", "On", "Position" );
+                    TextTable table = new TextTable( DUMP_LIST_ID, "Computer", "On", "Position" );
 
                     List<ServerComputer> computers = new ArrayList<>( ComputerCraft.serverComputerRegistry.getComputers() );
 
@@ -92,8 +92,7 @@ public final class CommandComputerCraft extends CommandDelegate
                     for( ServerComputer computer : computers )
                     {
                         table.addRow(
-                            linkComputer( computer ),
-                            text( Integer.toString( computer.getID() ) ),
+                            linkComputer( context, computer, computer.getID() ),
                             bool( computer.isOn() ),
                             linkPosition( context, computer )
                         );
@@ -149,26 +148,15 @@ public final class CommandComputerCraft extends CommandDelegate
             @Override
             public void execute( @Nonnull CommandContext context, @Nonnull List<String> arguments ) throws CommandException
             {
-                Set<ServerComputer> computers = Sets.newHashSet();
-                if( arguments.size() > 0 )
-                {
-                    for( String arg : arguments )
+                withComputers( arguments, computers -> {
+                    int shutdown = 0;
+                    for( ServerComputer computer : computers )
                     {
-                        computers.addAll( ComputerSelector.getComputers( arg ) );
+                        if( computer.isOn() ) shutdown++;
+                        computer.unload();
                     }
-                }
-                else
-                {
-                    computers.addAll( ComputerCraft.serverComputerRegistry.getComputers() );
-                }
-
-                int shutdown = 0;
-                for( ServerComputer computer : computers )
-                {
-                    if( computer.isOn() ) shutdown++;
-                    computer.unload();
-                }
-                context.getSender().sendMessage( text( "Shutdown " + shutdown + " / " + computers.size() + " computers" ) );
+                    context.getSender().sendMessage( text( "Shutdown " + shutdown + " / " + computers.size() + " computers" ) );
+                } );
             }
 
             @Nonnull
@@ -190,26 +178,15 @@ public final class CommandComputerCraft extends CommandDelegate
             @Override
             public void execute( @Nonnull CommandContext context, @Nonnull List<String> arguments ) throws CommandException
             {
-                Set<ServerComputer> computers = Sets.newHashSet();
-                if( arguments.size() > 0 )
-                {
-                    for( String arg : arguments )
+                withComputers( arguments, computers -> {
+                    int on = 0;
+                    for( ServerComputer computer : computers )
                     {
-                        computers.addAll( ComputerSelector.getComputers( arg ) );
+                        if( !computer.isOn() ) on++;
+                        computer.turnOn();
                     }
-                }
-                else
-                {
-                    computers.addAll( ComputerCraft.serverComputerRegistry.getComputers() );
-                }
-
-                int on = 0;
-                for( ServerComputer computer : computers )
-                {
-                    if( !computer.isOn() ) on++;
-                    computer.turnOn();
-                }
-                context.getSender().sendMessage( text( "Turned on " + on + " / " + computers.size() + " computers" ) );
+                    context.getSender().sendMessage( text( "Turned on " + on + " / " + computers.size() + " computers" ) );
+                } );
             }
 
             @Nonnull
@@ -406,13 +383,46 @@ public final class CommandComputerCraft extends CommandDelegate
         return root;
     }
 
-    private static ITextComponent linkComputer( ServerComputer computer )
+    private static ITextComponent linkComputer( CommandContext context, ServerComputer serverComputer, int computerId )
     {
-        return link(
-            text( Integer.toString( computer.getInstanceID() ) ),
-            "/computercraft dump " + computer.getInstanceID(),
-            "View more info about this computer"
-        );
+        ITextComponent out = new TextComponentString( "" );
+
+        // Append the computer instance
+        if( serverComputer == null )
+        {
+            out.appendSibling( text( "?" ) );
+        }
+        else
+        {
+            out.appendSibling( link(
+                text( Integer.toString( serverComputer.getInstanceID() ) ),
+                "/computercraft dump " + serverComputer.getInstanceID(),
+                "View more info about this computer"
+            ) );
+        }
+
+        // And ID
+        out.appendText( " (id " + computerId + ")" );
+
+        // And, if we're a player, some useful links
+        if( serverComputer != null && UserLevel.OP.canExecute( context ) && context.fromPlayer() )
+        {
+            out
+                .appendText( " " )
+                .appendSibling( link(
+                    text( "\u261b" ),
+                    "/computercraft tp " + serverComputer.getInstanceID(),
+                    "Teleport to this computer"
+                ) )
+                .appendText( " " )
+                .appendSibling( link(
+                    text( "\u20e2" ),
+                    "/computercraft view " + serverComputer.getInstanceID(),
+                    "View this computer"
+                ) );
+        }
+
+        return out;
     }
 
     private static ITextComponent linkPosition( CommandContext context, ServerComputer computer )
@@ -458,9 +468,6 @@ public final class CommandComputerCraft extends CommandDelegate
             if( server.getID() > maxId ) maxId = server.getID();
         }
 
-        ICommandSender sender = context.getSender();
-        boolean isPlayer = sender instanceof EntityPlayerMP && !(sender instanceof FakePlayer);
-
         timings.sort( Comparator.<ComputerTracker, Long>comparing( x -> x.get( field ) ).reversed() );
 
         boolean defaultLayout = field == TrackingField.TASKS || field == TrackingField.TOTAL_TIME
@@ -476,26 +483,7 @@ public final class CommandComputerCraft extends CommandDelegate
             Computer computer = entry.getComputer();
             ServerComputer serverComputer = computer == null ? null : lookup.get( computer );
 
-            ITextComponent computerComponent = new TextComponentString( "" )
-                .appendSibling( serverComputer == null ? text( "?" ) : linkComputer( serverComputer ) )
-                .appendText( " (id " + entry.getComputerId() + ")" );
-
-            if( serverComputer != null && UserLevel.OP.canExecute( context ) && isPlayer )
-            {
-                computerComponent
-                    .appendText( " " )
-                    .appendSibling( link(
-                        text( "\u261b" ),
-                        "/computercraft tp " + serverComputer.getInstanceID(),
-                        "Teleport to this computer"
-                    ) )
-                    .appendText( " " )
-                    .appendSibling( link(
-                        text( "\u20e2" ),
-                        "/computercraft view " + serverComputer.getInstanceID(),
-                        "View this computer"
-                    ) );
-            }
+            ITextComponent computerComponent = linkComputer( context, serverComputer, entry.getComputerId() );
 
             if( defaultLayout )
             {
@@ -515,4 +503,30 @@ public final class CommandComputerCraft extends CommandDelegate
 
         table.displayTo( context.getSender() );
     }
+
+    private static void withComputers( List<String> selectors, Consumer<Collection<ServerComputer>> action ) throws CommandException
+    {
+        Set<ServerComputer> computers = Sets.newHashSet();
+        List<String> failed = new ArrayList<>();
+        if( selectors.isEmpty() )
+        {
+            computers.addAll( ComputerCraft.serverComputerRegistry.getComputers() );
+        }
+        else
+        {
+            for( String selector : selectors )
+            {
+                List<ServerComputer> selected = ComputerSelector.getComputers( selector );
+                computers.addAll( selected );
+                if( selected.isEmpty() ) failed.add( selector );
+            }
+        }
+
+        action.accept( computers );
+
+        if( !failed.isEmpty() )
+        {
+            throw new CommandException( "Could not find computers matching " + String.join( ", ", failed ) );
+        }
+    }
 }

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

@@ -12,30 +12,22 @@ import java.util.function.Predicate;
 
 public final class ComputerSelector
 {
-    private static List<ServerComputer> getComputers( Predicate<ServerComputer> predicate, String selector ) throws CommandException
+    private static List<ServerComputer> getComputers( Predicate<ServerComputer> predicate ) throws CommandException
     {
         // We copy it to prevent concurrent modifications.
-        List<ServerComputer> computers = Lists.newArrayList( ComputerCraft.serverComputerRegistry.getComputers() );
-        List<ServerComputer> candidates = Lists.newArrayList();
-        for( ServerComputer searchComputer : computers )
-        {
-            if( predicate.test( searchComputer ) ) candidates.add( searchComputer );
-        }
-
-        if( candidates.isEmpty() )
-        {
-            throw new CommandException( "No computer matching " + selector );
-        }
-        else
-        {
-            return candidates;
-        }
+        ArrayList<ServerComputer> computers = new ArrayList<>( ComputerCraft.serverComputerRegistry.getComputers() );
+        computers.removeIf( predicate.negate() );
+        return computers;
     }
 
     public static ServerComputer getComputer( String selector ) throws CommandException
     {
         List<ServerComputer> computers = getComputers( selector );
-        if( computers.size() == 1 )
+        if( computers.size() == 0 )
+        {
+            throw new CommandException( "No computer matching " + selector );
+        }
+        else if( computers.size() == 1 )
         {
             return computers.get( 0 );
         }
@@ -46,7 +38,7 @@ public final class ComputerSelector
 
             for( int i = 0; i < computers.size(); i++ )
             {
-                if( i > 1 ) builder.append( ", " );
+                if( i > 0 ) builder.append( ", " );
                 builder.append( computers.get( i ).getInstanceID() );
             }
             builder.append( ")" );
@@ -71,17 +63,17 @@ public final class ComputerSelector
                 throw new CommandException( "'" + selector + "' is not a valid number" );
             }
 
-            return getComputers( x -> x.getID() == id, selector );
+            return getComputers( x -> x.getID() == id );
         }
         else if( selector.length() > 0 && selector.charAt( 0 ) == '@' )
         {
             String label = selector.substring( 1 );
-            return getComputers( x -> Objects.equals( label, x.getLabel() ), selector );
+            return getComputers( x -> Objects.equals( label, x.getLabel() ) );
         }
         else if( selector.length() > 0 && selector.charAt( 0 ) == '~' )
         {
             String familyName = selector.substring( 1 );
-            return getComputers( x -> x.getFamily().name().equalsIgnoreCase( familyName ), selector );
+            return getComputers( x -> x.getFamily().name().equalsIgnoreCase( familyName ) );
         }
         else
         {
@@ -96,14 +88,7 @@ public final class ComputerSelector
             }
 
             ServerComputer computer = ComputerCraft.serverComputerRegistry.get( instance );
-            if( computer == null )
-            {
-                throw new CommandException( "No such computer for instance id " + instance );
-            }
-            else
-            {
-                return Collections.singletonList( computer );
-            }
+            return computer == null ? Collections.emptyList() : Collections.singletonList( computer );
         }
     }
 

src/main/java/dan200/computercraft/shared/command/framework/CommandContext.java

@@ -2,7 +2,9 @@ package dan200.computercraft.shared.command.framework;
 
 import com.google.common.collect.Lists;
 import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.server.MinecraftServer;
+import net.minecraftforge.common.util.FakePlayer;
 
 import java.util.Collections;
 import java.util.List;
@@ -90,4 +92,9 @@ public final class CommandContext
     {
         return sender;
     }
+
+    public boolean fromPlayer()
+    {
+        return sender instanceof EntityPlayerMP && !(sender instanceof FakePlayer);
+    }
 }

src/main/java/dan200/computercraft/shared/command/framework/TextFormatter.java

@@ -17,7 +17,6 @@ import static dan200.computercraft.shared.command.framework.ChatHelpers.coloured
  */
 public class TextFormatter
 {
-    private static final int SPACE_WIDTH = 4;
     private static final char PADDING_CHAR = '\u02cc';
 
     /**
@@ -54,7 +53,7 @@ public class TextFormatter
         8, 4,
     };
 
-    private static int getWidth( int codePoint )
+    public static int getWidth( int codePoint )
     {
         // Escape codes
         if( codePoint == 167 ) return -1;
@@ -73,7 +72,7 @@ public class TextFormatter
         return 0;
     }
 
-    private static int getWidth( ITextComponent component )
+    public static int getWidth( ITextComponent component )
     {
         int total = 0;
         if( component instanceof TextComponentString )
@@ -132,19 +131,17 @@ public class TextFormatter
         int width = getWidthFor( entry, sender );
         int delta = maxWidth - width;
 
-        if( delta > 0 )
+        int spaceWidth = getWidthFor( ' ', sender );
+        int spaces = delta / spaceWidth;
+        int extra = delta % spaces;
+
+        // Append a fixed number of spaces
+        if( spaces > 0 ) out.appendSibling( new TextComponentString( StringUtils.repeat( ' ', spaces ) ) );
+
+        // Append several minor characters to pad to a full string 
+        if( extra > 0 )
         {
-            int spaces = delta / SPACE_WIDTH;
-            int extra = delta % SPACE_WIDTH;
-
-            // Append a fixed number of spaces
-            if( spaces > 0 ) out.appendSibling( new TextComponentString( StringUtils.repeat( ' ', spaces ) ) );
-
-            // Append several minor characters to pad to a full string 
-            if( extra > 0 )
-            {
-                out.appendSibling( coloured( StringUtils.repeat( PADDING_CHAR, extra ), TextFormatting.GRAY ) );
-            }
+            out.appendSibling( coloured( StringUtils.repeat( PADDING_CHAR, extra ), TextFormatting.GRAY ) );
         }
     }
 }

src/main/java/dan200/computercraft/shared/command/framework/TextTable.java

@@ -35,7 +35,7 @@ public class TextTable
         this.columns = header.length;
     }
 
-    public TextTable(int id)
+    public TextTable( int id )
     {
         this.id = id;
         this.header = null;
@@ -90,14 +90,15 @@ public class TextTable
             ITextComponent[] row = rows.get( y );
             for( int i = 0; i < row.length; i++ )
             {
-                int width = getWidthFor( row[i], sender ) + 3;
+                int width = getWidthFor( row[i], sender );
                 if( width > maxWidths[i] ) maxWidths[i] = width;
             }
         }
 
-        // Add a small amount of extra padding. We include this here instead of the separator to allow
-        // for "extra" characters
-        for( int i = 0; i < maxWidths.length; i++ ) maxWidths[i] += 4;
+        // Add a small amount of extra padding. This defaults to 3 spaces for players
+        // and 1 for everyone else.
+        int padding = isPlayer( sender ) ? getWidth( ' ' ) * 3 : 1;
+        for( int i = 0; i < maxWidths.length; i++ ) maxWidths[i] += padding;
 
         int totalWidth = (columns - 1) * getWidthFor( SEPARATOR, sender );
         for( int x : maxWidths ) totalWidth += x;
@@ -161,7 +162,7 @@ public class TextTable
             for( int i = 0; i < out.size(); i++ )
             {
                 if( i > 0 ) result.appendSibling( LINE );
-                result.appendSibling( out.get( 0 ) );
+                result.appendSibling( out.get( i ) );
             }
             sender.sendMessage( result );
         }

src/main/java/dan200/computercraft/shared/common/ServerTerminal.java

@@ -54,6 +54,11 @@ public class ServerTerminal implements ITerminal
         }
     }
 
+    protected void markTerminalChanged()
+    {
+        m_terminalChanged = true;
+    }
+
     public void update()
     {
         m_terminalChangedLastFrame = m_terminalChanged || (m_terminal != null && m_terminal.getChanged());

src/main/java/dan200/computercraft/shared/computer/blocks/BlockCommandComputer.java

@@ -42,7 +42,7 @@ public class BlockCommandComputer extends BlockComputerBase
         super( Material.IRON );
         setBlockUnbreakable();
         setResistance( 6000000.0F );
-        setUnlocalizedName( "computercraft:command_computer" );
+        setTranslationKey( "computercraft:command_computer" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
         setDefaultState( this.blockState.getBaseState()
             .withProperty( Properties.FACING, EnumFacing.NORTH )
@@ -62,7 +62,7 @@ public class BlockCommandComputer extends BlockComputerBase
     @Deprecated
     public IBlockState getStateFromMeta( int meta )
     {
-        EnumFacing dir = EnumFacing.getFront( meta & 0x7 );
+        EnumFacing dir = EnumFacing.byIndex( meta & 0x7 );
         if( dir.getAxis() == EnumFacing.Axis.Y )
         {
             dir = EnumFacing.NORTH;

src/main/java/dan200/computercraft/shared/computer/blocks/BlockComputer.java

@@ -44,7 +44,7 @@ public class BlockComputer extends BlockComputerBase
     {
         super( Material.ROCK );
         setHardness( 2.0f );
-        setUnlocalizedName( "computercraft:computer" );
+        setTranslationKey( "computercraft:computer" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
         setDefaultState( this.blockState.getBaseState()
             .withProperty( Properties.FACING, EnumFacing.NORTH )
@@ -65,7 +65,7 @@ public class BlockComputer extends BlockComputerBase
     @Deprecated
     public IBlockState getStateFromMeta( int meta )
     {
-        EnumFacing dir = EnumFacing.getFront( meta & 0x7 );
+        EnumFacing dir = EnumFacing.byIndex( meta & 0x7 );
         if( dir.getAxis() == EnumFacing.Axis.Y )
         {
             dir = EnumFacing.NORTH;

src/main/java/dan200/computercraft/shared/computer/core/ServerComputer.java

@@ -154,7 +154,7 @@ public class ServerComputer extends ServerTerminal
         return packet;
     }
 
-    private ComputerCraftPacket createTerminalPacket() {
+    protected ComputerCraftPacket createTerminalPacket() {
         ComputerCraftPacket packet = new ComputerCraftPacket();
         packet.m_packetType = ComputerCraftPacket.ComputerTerminalChanged;
         packet.m_dataInt = new int[] { getInstanceID() };
@@ -465,7 +465,7 @@ public class ServerComputer extends ServerTerminal
         }
     }
 
-    private boolean isInteracting( EntityPlayer player )
+    protected boolean isInteracting( EntityPlayer player )
     {
         if( player == null ) return false;
 

src/main/java/dan200/computercraft/shared/computer/items/ItemCommandComputer.java

@@ -24,7 +24,7 @@ public class ItemCommandComputer extends ItemComputer
         super( block );
         setMaxStackSize( 64 );
         setHasSubtypes( true );
-        setUnlocalizedName( "computercraft:command_computer" );
+        setTranslationKey( "computercraft:command_computer" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
     }
 

src/main/java/dan200/computercraft/shared/computer/items/ItemComputer.java

@@ -33,7 +33,7 @@ public class ItemComputer extends ItemComputerBase
         super( block );
         setMaxStackSize( 64 );
         setHasSubtypes( true );
-        setUnlocalizedName( "computercraft:computer" );
+        setTranslationKey( "computercraft:computer" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
     }
 
@@ -114,7 +114,7 @@ public class ItemComputer extends ItemComputerBase
 
     @Nonnull
     @Override
-    public String getUnlocalizedName( @Nonnull ItemStack stack )
+    public String getTranslationKey( @Nonnull ItemStack stack )
     {
         switch( getFamily( stack ) )
         {

src/main/java/dan200/computercraft/shared/datafix/Fixes.java

@@ -0,0 +1,23 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2018. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+
+package dan200.computercraft.shared.datafix;
+
+import dan200.computercraft.ComputerCraft;
+import net.minecraft.util.datafix.FixTypes;
+import net.minecraftforge.common.util.CompoundDataFixer;
+import net.minecraftforge.common.util.ModFixs;
+
+public class Fixes
+{
+    public static final int VERSION = 1;
+
+    public static void register( CompoundDataFixer fixer )
+    {
+        ModFixs fixes = fixer.init( ComputerCraft.MOD_ID, VERSION );
+        fixes.registerFix( FixTypes.BLOCK_ENTITY, new TileEntityDataFixer() );
+    }
+}

src/main/java/dan200/computercraft/shared/datafix/TileEntityDataFixer.java

@@ -0,0 +1,39 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2018. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+
+package dan200.computercraft.shared.datafix;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.datafix.IFixableData;
+
+import javax.annotation.Nonnull;
+
+import static dan200.computercraft.ComputerCraft.MOD_ID;
+import static dan200.computercraft.shared.datafix.Fixes.VERSION;
+
+/**
+ * Fixes up the botched tile entity IDs from the 1.11 port.
+ */
+public class TileEntityDataFixer implements IFixableData
+{
+    @Override
+    public int getFixVersion()
+    {
+        return VERSION;
+    }
+
+    @Nonnull
+    @Override
+    public NBTTagCompound fixTagCompound( @Nonnull NBTTagCompound tag )
+    {
+        String id = tag.getString( "id" );
+        if( id.startsWith( MOD_ID + " : " ) )
+        {
+            tag.setString( "id", id.replaceFirst( MOD_ID + " : ", MOD_ID + ":" ) );
+        }
+        return tag;
+    }
+}

src/main/java/dan200/computercraft/shared/integration/charset/BundledCapabilityProvider.java

@@ -0,0 +1,87 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2018. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+
+package dan200.computercraft.shared.integration.charset;
+
+import dan200.computercraft.shared.common.TileGeneric;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.ICapabilityProvider;
+import pl.asie.charset.api.wires.IBundledEmitter;
+import pl.asie.charset.api.wires.IBundledReceiver;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import static dan200.computercraft.shared.integration.charset.IntegrationCharset.CAPABILITY_EMITTER;
+import static dan200.computercraft.shared.integration.charset.IntegrationCharset.CAPABILITY_RECEIVER;
+
+final class BundledCapabilityProvider implements ICapabilityProvider
+{
+    private final TileGeneric tile;
+    private IBundledReceiver receiver;
+    private IBundledEmitter[] emitters;
+
+    BundledCapabilityProvider( TileGeneric tile )
+    {
+        this.tile = tile;
+    }
+
+    @Override
+    public boolean hasCapability( @Nonnull Capability<?> capability, @Nullable EnumFacing side )
+    {
+        return capability == CAPABILITY_EMITTER || capability == CAPABILITY_RECEIVER;
+    }
+
+    @Nullable
+    @Override
+    public <T> T getCapability( @Nonnull Capability<T> capability, @Nullable EnumFacing side )
+    {
+        if( capability == CAPABILITY_RECEIVER )
+        {
+            IBundledReceiver receiver = this.receiver;
+            if( receiver == null ) receiver = this.receiver = tile::onNeighbourChange;
+
+            return CAPABILITY_RECEIVER.cast( receiver );
+        }
+        else if( capability == CAPABILITY_EMITTER )
+        {
+            IBundledEmitter[] emitters = this.emitters;
+            if( emitters == null ) emitters = this.emitters = new IBundledEmitter[7];
+
+            int index = side == null ? 6 : side.getIndex();
+            IBundledEmitter emitter = emitters[index];
+            if( emitter == null )
+            {
+                if( side == null )
+                {
+                    emitter = emitters[index] = () -> {
+                        int flags = 0;
+                        for( EnumFacing facing : EnumFacing.VALUES ) flags |= tile.getBundledRedstoneOutput( facing );
+                        return toBytes( flags );
+                    };
+                }
+                else
+                {
+                    emitter = emitters[index] = () -> toBytes( tile.getBundledRedstoneOutput( side ) );
+                }
+            }
+
+            return CAPABILITY_EMITTER.cast( emitter );
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    private static byte[] toBytes( int flag )
+    {
+        byte[] channels = new byte[16];
+        for( int i = 0; i < 16; i++ ) channels[i] = (flag & (1 << i)) == 0 ? (byte) 0 : 15;
+        return channels;
+    }
+}

src/main/java/dan200/computercraft/shared/integration/charset/BundledRedstoneProvider.java

@@ -0,0 +1,34 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2018. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+
+package dan200.computercraft.shared.integration.charset;
+
+import dan200.computercraft.api.redstone.IBundledRedstoneProvider;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import javax.annotation.Nonnull;
+
+import static dan200.computercraft.shared.integration.charset.IntegrationCharset.CAPABILITY_EMITTER;
+
+public class BundledRedstoneProvider implements IBundledRedstoneProvider
+{
+    @Override
+    public int getBundledRedstoneOutput( @Nonnull World world, @Nonnull BlockPos pos, @Nonnull EnumFacing side )
+    {
+        TileEntity tile = world.getTileEntity( pos );
+        if( tile == null || !tile.hasCapability( CAPABILITY_EMITTER, side ) ) return -1;
+
+        byte[] signal = tile.getCapability( CAPABILITY_EMITTER, side ).getBundledSignal();
+        if( signal == null ) return -1;
+
+        int flag = 0;
+        for( int i = 0; i < signal.length; i++ ) flag |= signal[i] > 0 ? (1 << i) : 0;
+        return flag;
+    }
+}

src/main/java/dan200/computercraft/shared/integration/charset/IntegrationCharset.java

@@ -0,0 +1,53 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2018. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+
+package dan200.computercraft.shared.integration.charset;
+
+import dan200.computercraft.ComputerCraft;
+import dan200.computercraft.api.ComputerCraftAPI;
+import dan200.computercraft.shared.common.TileGeneric;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.CapabilityInject;
+import net.minecraftforge.event.AttachCapabilitiesEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import pl.asie.charset.api.wires.IBundledEmitter;
+import pl.asie.charset.api.wires.IBundledReceiver;
+
+public final class IntegrationCharset
+{
+    private static final ResourceLocation CAPABILITY_KEY = new ResourceLocation( ComputerCraft.MOD_ID, "charset" );
+
+    @CapabilityInject( IBundledEmitter.class )
+    public static final Capability<IBundledEmitter> CAPABILITY_EMITTER = null;
+
+    @CapabilityInject( IBundledReceiver.class )
+    public static final Capability<IBundledReceiver> CAPABILITY_RECEIVER = null;
+
+    private IntegrationCharset()
+    {
+    }
+
+    public static void register()
+    {
+        if( CAPABILITY_EMITTER == null || CAPABILITY_RECEIVER == null ) return;
+
+        MinecraftForge.EVENT_BUS.register( new IntegrationCharset() );
+        ComputerCraftAPI.registerBundledRedstoneProvider( new BundledRedstoneProvider() );
+    }
+
+    @SubscribeEvent
+    public void attachGenericCapabilities( AttachCapabilitiesEvent<TileEntity> event)
+    {
+        TileEntity tile = event.getObject();
+        if(tile instanceof TileGeneric)
+        {
+            event.addCapability( CAPABILITY_KEY, new BundledCapabilityProvider( (TileGeneric) tile ) );
+        }
+    }
+}

src/main/java/dan200/computercraft/shared/media/items/ItemDiskLegacy.java

@@ -33,7 +33,7 @@ public class ItemDiskLegacy extends Item
     {
         setMaxStackSize( 1 );
         setHasSubtypes( true );
-        setUnlocalizedName( "computercraft:disk" );
+        setTranslationKey( "computercraft:disk" );
         setCreativeTab( ComputerCraft.mainCreativeTab  );
     }
     

src/main/java/dan200/computercraft/shared/media/items/ItemPrintout.java

@@ -39,7 +39,7 @@ public class ItemPrintout extends Item
     {
         setMaxStackSize( 1 );
         setHasSubtypes( true );
-        setUnlocalizedName( "computercraft:page" );
+        setTranslationKey( "computercraft:page" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
     }
 
@@ -64,7 +64,7 @@ public class ItemPrintout extends Item
 
     @Nonnull
     @Override
-    public String getUnlocalizedName( @Nonnull ItemStack stack )
+    public String getTranslationKey( @Nonnull ItemStack stack )
     {
         Type type = getType( stack );
         switch( type )

src/main/java/dan200/computercraft/shared/media/items/ItemTreasureDisk.java

@@ -34,7 +34,7 @@ public class ItemTreasureDisk extends Item
     {
         setMaxStackSize( 1 );
         setHasSubtypes( true );
-        setUnlocalizedName( "computercraft:treasure_disk" );
+        setTranslationKey( "computercraft:treasure_disk" );
     }
     
     @Override

src/main/java/dan200/computercraft/shared/peripheral/common/BlockCable.java

@@ -55,7 +55,7 @@ public class BlockCable extends BlockPeripheralBase
     public BlockCable()
     {
         setHardness( 1.5f );
-        setUnlocalizedName( "computercraft:cable" );
+        setTranslationKey( "computercraft:cable" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
         setDefaultState( this.blockState.getBaseState()
             .withProperty( Properties.MODEM, BlockCableModemVariant.None )
@@ -94,12 +94,12 @@ public class BlockCable extends BlockPeripheralBase
         if( meta < 6 )
         {
             state = state.withProperty( Properties.CABLE, BlockCableCableVariant.NONE );
-            state = state.withProperty( Properties.MODEM, BlockCableModemVariant.fromFacing( EnumFacing.getFront( meta ) ) );
+            state = state.withProperty( Properties.MODEM, BlockCableModemVariant.fromFacing( EnumFacing.byIndex( meta ) ) );
         }
         else if( meta < 12 )
         {
             state = state.withProperty( Properties.CABLE, BlockCableCableVariant.ANY );
-            state = state.withProperty( Properties.MODEM, BlockCableModemVariant.fromFacing( EnumFacing.getFront( meta - 6 ) ) );
+            state = state.withProperty( Properties.MODEM, BlockCableModemVariant.fromFacing( EnumFacing.byIndex( meta - 6 ) ) );
         }
         else if( meta == 13 )
         {
@@ -296,7 +296,7 @@ public class BlockCable extends BlockPeripheralBase
                 }
             }
 
-            return result == null ? null : new RayTraceResult( result.hitVec.addVector( pos.getX(), pos.getY(), pos.getZ() ), result.sideHit, pos );
+            return result == null ? null : new RayTraceResult( result.hitVec.add( pos.getX(), pos.getY(), pos.getZ() ), result.sideHit, pos );
         }
         else
         {

src/main/java/dan200/computercraft/shared/peripheral/common/BlockPeripheral.java

@@ -44,7 +44,7 @@ public class BlockPeripheral extends BlockPeripheralBase
     public BlockPeripheral()
     {
         setHardness( 2.0f );
-        setUnlocalizedName( "computercraft:peripheral" );
+        setTranslationKey( "computercraft:peripheral" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
         setDefaultState( this.blockState.getBaseState()
             .withProperty( Properties.FACING, EnumFacing.NORTH )
@@ -55,7 +55,7 @@ public class BlockPeripheral extends BlockPeripheralBase
     @Override
     @Nonnull
     @SideOnly( Side.CLIENT)
-    public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getRenderLayer()
     {
         return BlockRenderLayer.CUTOUT;
     }
@@ -76,7 +76,7 @@ public class BlockPeripheral extends BlockPeripheralBase
         if( meta >= 2 && meta <= 5 )
         {
             state = state.withProperty( Properties.VARIANT, BlockPeripheralVariant.DiskDriveEmpty );
-            state = state.withProperty( Properties.FACING, EnumFacing.getFront( meta ) );
+            state = state.withProperty( Properties.FACING, EnumFacing.byIndex( meta ) );
         }
         else if( meta <= 9 )
         {
@@ -93,7 +93,7 @@ public class BlockPeripheral extends BlockPeripheralBase
             else
             {
                 state = state.withProperty( Properties.VARIANT, BlockPeripheralVariant.WirelessModemOff );
-                state = state.withProperty( Properties.FACING, EnumFacing.getFront( meta - 4 ) );
+                state = state.withProperty( Properties.FACING, EnumFacing.byIndex( meta - 4 ) );
             }
         }
         else if( meta == 10 )
@@ -651,7 +651,7 @@ public class BlockPeripheral extends BlockPeripheralBase
     public boolean causesSuffocation(IBlockState state)
     {
         // This normally uses the default state 
-        return blockMaterial.blocksMovement() && state.isOpaqueCube();
+        return material.blocksMovement() && state.isOpaqueCube();
     }
 
     @Override

src/main/java/dan200/computercraft/shared/peripheral/common/BlockWiredModemFull.java

@@ -34,7 +34,7 @@ public class BlockWiredModemFull extends BlockPeripheralBase
     public BlockWiredModemFull()
     {
         setHardness( 1.5f );
-        setUnlocalizedName( "computercraft:wired_modem_full" );
+        setTranslationKey( "computercraft:wired_modem_full" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
         setDefaultState( blockState.getBaseState()
             .withProperty( Properties.MODEM_ON, false )

src/main/java/dan200/computercraft/shared/peripheral/common/ItemAdvancedModem.java

@@ -21,7 +21,7 @@ public class ItemAdvancedModem extends ItemPeripheralBase
     public ItemAdvancedModem( Block block )
     {
         super( block );
-        setUnlocalizedName( "computercraft:advanced_modem" );
+        setTranslationKey( "computercraft:advanced_modem" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
     }
 

src/main/java/dan200/computercraft/shared/peripheral/common/ItemCable.java

@@ -28,7 +28,7 @@ public class ItemCable extends ItemPeripheralBase
     public ItemCable( Block block )
     {
         super( block );
-        setUnlocalizedName( "computercraft:cable" );
+        setTranslationKey( "computercraft:cable" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
     }
 

src/main/java/dan200/computercraft/shared/peripheral/common/ItemPeripheral.java

@@ -20,7 +20,7 @@ public class ItemPeripheral extends ItemPeripheralBase
     public ItemPeripheral( Block block )
     {
         super( block );
-        setUnlocalizedName( "computercraft:peripheral" );
+        setTranslationKey( "computercraft:peripheral" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
     }
 

src/main/java/dan200/computercraft/shared/peripheral/common/ItemPeripheralBase.java

@@ -59,7 +59,7 @@ public abstract class ItemPeripheralBase extends ItemBlock implements IPeriphera
 
     @Nonnull
     @Override
-    public String getUnlocalizedName( @Nonnull ItemStack stack )
+    public String getTranslationKey( @Nonnull ItemStack stack )
     {
         PeripheralType type = getPeripheralType( stack );
         switch( type )

src/main/java/dan200/computercraft/shared/peripheral/common/TilePeripheralBase.java

@@ -112,12 +112,12 @@ public abstract class TilePeripheralBase extends TileGeneric
         }
     }
 
-    public synchronized int getAnim()
+    public int getAnim()
     {
         return m_anim;
     }
     
-    public synchronized void setAnim( int anim )
+    public void setAnim( int anim )
     {
         if( anim != m_anim )
         {
@@ -127,12 +127,12 @@ public abstract class TilePeripheralBase extends TileGeneric
     }
 
     @Override    
-    public synchronized void update()
+    public void update()
     {
         if( m_changed )
         {
-            updateBlock();
             m_changed = false;
+            updateBlock();
         }
     }
             
@@ -143,7 +143,7 @@ public abstract class TilePeripheralBase extends TileGeneric
         super.readFromNBT(nbttagcompound);
         if( nbttagcompound.hasKey( "dir" ) )
         {
-            m_dir = EnumFacing.getFront( nbttagcompound.getInteger( "dir" ) );
+            m_dir = EnumFacing.byIndex( nbttagcompound.getInteger( "dir" ) );
         }
         if( nbttagcompound.hasKey( "anim" ) )
         {
@@ -174,7 +174,7 @@ public abstract class TilePeripheralBase extends TileGeneric
     public void readDescription( @Nonnull NBTTagCompound nbttagcompound )
     {
         super.readDescription( nbttagcompound );
-        m_dir = EnumFacing.getFront( nbttagcompound.getInteger( "dir" ) );
+        m_dir = EnumFacing.byIndex( nbttagcompound.getInteger( "dir" ) );
         m_anim = nbttagcompound.getInteger( "anim" );
         if( nbttagcompound.hasKey( "label" ) )
         {

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

@@ -80,12 +80,9 @@ public class TileDiskDrive extends TilePeripheralBase
     public void destroy()
     {
         ejectContents( true );
-        synchronized( this )
+        if( m_recordPlaying )
         {
-            if( m_recordPlaying )
-            {
-                stopRecord();
-            }
+            stopRecord();
         }
     }
 
@@ -170,13 +167,10 @@ public class TileDiskDrive extends TilePeripheralBase
         super.update();
 
         // Ejection
-        synchronized( this )
+        if( m_ejectQueued )
         {
-            if( m_ejectQueued )
-            {
-                ejectContents( false );
-                m_ejectQueued = false;
-            }
+            ejectContents( false );
+            m_ejectQueued = false;
         }
         
         // Music
@@ -391,10 +385,7 @@ public class TileDiskDrive extends TilePeripheralBase
     @Override
     public void clear()
     {
-        synchronized( this )
-        {
-            setInventorySlotContents( 0, ItemStack.EMPTY );
-        }
+        setInventorySlotContents( 0, ItemStack.EMPTY );
     }
 
     @Override
@@ -425,18 +416,12 @@ public class TileDiskDrive extends TilePeripheralBase
     @Nonnull
     public ItemStack getDiskStack()
     {
-        synchronized( this )
-        {
-            return getStackInSlot( 0 );
-        }
+        return getStackInSlot( 0 );
     }
 
     public void setDiskStack( @Nonnull ItemStack stack )
     {
-        synchronized( this )
-        {
-            setInventorySlotContents( 0, stack );
-        }
+        setInventorySlotContents( 0, stack );
     }
 
     public IMedia getDiskMedia()
@@ -569,7 +554,7 @@ public class TileDiskDrive extends TilePeripheralBase
         }
     }
 
-    private synchronized void updateAnim()
+    private void updateAnim()
     {            
         if( !m_diskStack.isEmpty() )
         {
@@ -605,8 +590,8 @@ public class TileDiskDrive extends TilePeripheralBase
             if( !destroyed )
             {
                 EnumFacing dir = getDirection();
-                xOff = dir.getFrontOffsetX();
-                zOff = dir.getFrontOffsetZ();
+                xOff = dir.getXOffset();
+                zOff = dir.getZOffset();
             }
 
             BlockPos pos = getPos();

src/main/java/dan200/computercraft/shared/peripheral/modem/BlockAdvancedModem.java

@@ -33,7 +33,7 @@ public class BlockAdvancedModem extends BlockPeripheralBase
     public BlockAdvancedModem()
     {
         setHardness( 2.0f );
-        setUnlocalizedName( "computercraft:advanced_modem" );
+        setTranslationKey( "computercraft:advanced_modem" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
         setDefaultState( this.blockState.getBaseState()
             .withProperty( Properties.FACING, EnumFacing.NORTH )
@@ -54,7 +54,7 @@ public class BlockAdvancedModem extends BlockPeripheralBase
     public IBlockState getStateFromMeta( int meta )
     {
         IBlockState state = getDefaultState();
-        state = state.withProperty( Properties.FACING, EnumFacing.getFront( meta ) );
+        state = state.withProperty( Properties.FACING, EnumFacing.byIndex( meta ) );
         state = state.withProperty( Properties.ON, false );
         return state;
     }

src/main/java/dan200/computercraft/shared/peripheral/modem/ModemPeripheral.java

@@ -14,53 +14,43 @@ import dan200.computercraft.api.network.IPacketSender;
 import dan200.computercraft.api.network.Packet;
 import dan200.computercraft.api.peripheral.IComputerAccess;
 import dan200.computercraft.api.peripheral.IPeripheral;
-import gnu.trove.set.TIntSet;
-import gnu.trove.set.hash.TIntHashSet;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
 
 import javax.annotation.Nonnull;
+import java.util.HashSet;
+import java.util.Set;
 
 import static dan200.computercraft.core.apis.ArgumentHelper.getInt;
 
-public abstract class ModemPeripheral
-    implements IPeripheral, IPacketSender, IPacketReceiver
+public abstract class ModemPeripheral implements IPeripheral, IPacketSender, IPacketReceiver
 {
     private IPacketNetwork m_network;
-    private IComputerAccess m_computer;
-    private final TIntSet m_channels;
+    private final Set<IComputerAccess> m_computers = new HashSet<>( 1 );
+    private final ModemState m_state;
 
-    private boolean m_open;
-    private boolean m_changed;
-
-    public ModemPeripheral()
+    protected ModemPeripheral( ModemState state )
     {
-        m_network = null;
-        m_computer = null;
-        m_channels = new TIntHashSet();
-        m_open = false;
-        m_changed = true;
+        this.m_state = state;
+    }
+
+    public ModemState getModemState()
+    {
+        return m_state;
     }
 
     private synchronized void setNetwork( IPacketNetwork network )
     {
-        if( m_network != network )
-        {
-            // Leave old network
-            if( m_network != null )
-            {
-                m_network.removeReceiver( this );
-            }
+        if( m_network == network ) return;
 
-            // Set new network
-            m_network = network;
+        // Leave old network
+        if( m_network != null ) m_network.removeReceiver( this );
 
-            // Join new network
-            if( m_network != null )
-            {
-                m_network.addReceiver( this );
-            }
-        }
+        // Set new network
+        m_network = network;
+
+        // Join new network
+        if( m_network != null ) m_network.addReceiver( this );
     }
 
     protected void switchNetwork()
@@ -68,39 +58,22 @@ public abstract class ModemPeripheral
         setNetwork( getNetwork() );
     }
 
-    public synchronized void destroy()
+    public void destroy()
     {
         setNetwork( null );
-        m_channels.clear();
-        m_open = false;
-    }
-    
-    public synchronized boolean pollChanged()
-    {
-        if( m_changed )
-        {
-            m_changed = false;
-            return true;
-        }
-        return false;
-    }
-
-    public synchronized boolean isActive()
-    {
-        return (m_computer != null) && m_open;
     }
 
     @Override
     public void receiveSameDimension( @Nonnull Packet packet, double distance )
     {
-        if( packet.getSender() == this ) return;
+        if( packet.getSender() == this || !m_state.isOpen( packet.getChannel() ) ) return;
 
-        synchronized (m_channels)
+        synchronized( m_computers )
         {
-            if( m_computer != null && m_channels.contains( packet.getChannel() ) )
+            for( IComputerAccess computer : m_computers )
             {
-                m_computer.queueEvent( "modem_message", new Object[] {
-                    m_computer.getAttachmentName(), packet.getChannel(), packet.getReplyChannel(), packet.getPayload(), distance
+                computer.queueEvent( "modem_message", new Object[]{
+                    computer.getAttachmentName(), packet.getChannel(), packet.getReplyChannel(), packet.getPayload(), distance
                 } );
             }
         }
@@ -109,14 +82,14 @@ public abstract class ModemPeripheral
     @Override
     public void receiveDifferentDimension( @Nonnull Packet packet )
     {
-        if( packet.getSender() == this ) return;
+        if( packet.getSender() == this || !m_state.isOpen( packet.getChannel() ) ) return;
 
-        synchronized (m_channels)
+        synchronized( m_computers )
         {
-            if( m_computer != null && m_channels.contains( packet.getChannel() ) )
+            for( IComputerAccess computer : m_computers )
             {
-                m_computer.queueEvent( "modem_message", new Object[] {
-                    m_computer.getAttachmentName(), packet.getChannel(), packet.getReplyChannel(), packet.getPayload()
+                computer.queueEvent( "modem_message", new Object[]{
+                    computer.getAttachmentName(), packet.getChannel(), packet.getReplyChannel(), packet.getPayload()
                 } );
             }
         }
@@ -137,7 +110,7 @@ public abstract class ModemPeripheral
     @Override
     public String[] getMethodNames()
     {
-        return new String[] {
+        return new String[]{
             "open",
             "isOpen",
             "close",
@@ -166,68 +139,26 @@ public abstract class ModemPeripheral
             {
                 // open
                 int channel = parseChannel( arguments, 0 );
-                synchronized( this )
-                {
-                    if( !m_channels.contains( channel ) )
-                    {
-                        if( m_channels.size() >= 128 )
-                        {
-                            throw new LuaException( "Too many open channels" );
-                        }
-
-                        m_channels.add( channel );
-                        if( !m_open )
-                        {
-                            m_open = true;
-                            m_changed = true;
-                        }
-                    }
-                }
+                m_state.open( channel );
                 return null;
             }
             case 1:
             {
                 // isOpen
                 int channel = parseChannel( arguments, 0 );
-                synchronized( this )
-                {
-                    boolean open = m_channels.contains( channel );
-                    return new Object[] { open };
-                }
+                return new Object[]{ m_state.isOpen( channel ) };
             }
             case 2:
             {
                 // close
                 int channel = parseChannel( arguments, 0 );
-                synchronized( this )
-                {
-                    if( m_channels.remove( channel ) )
-                    {
-                        if( m_channels.size() == 0 )
-                        {
-                            m_open = false;
-                            m_changed = true;
-                        }
-                    }
-                }
+                m_state.close( channel );
                 return null;
             }
             case 3:
             {
                 // closeAll
-                synchronized( this )
-                {
-                    if( m_channels.size() > 0 )
-                    {
-                        m_channels.clear();
-                        
-                        if( m_open )
-                        {
-                            m_open = false;
-                            m_changed = true;
-                        }
-                    }
-                }
+                m_state.closeAll();
                 return null;
             }
             case 4:
@@ -235,12 +166,12 @@ public abstract class ModemPeripheral
                 // transmit
                 int channel = parseChannel( arguments, 0 );
                 int replyChannel = parseChannel( arguments, 1 );
-                Object payload = (arguments.length >= 3) ? arguments[2] : null;
+                Object payload = arguments.length > 2 ? arguments[2] : null;
                 synchronized( this )
                 {
                     World world = getWorld();
                     Vec3d position = getPosition();
-                    if( world != null && position != null && m_network != null)
+                    if( world != null && position != null && m_network != null )
                     {
                         Packet packet = new Packet( channel, replyChannel, payload, this );
                         if( isInterdimensional() )
@@ -258,14 +189,8 @@ public abstract class ModemPeripheral
             case 5:
             {
                 // isWireless
-                synchronized( this )
-                {
-                    if( m_network != null )
-                    {
-                        return new Object[] { m_network.isWireless() };
-                    }
-                }
-                return new Object[] { false };
+                IPacketNetwork network = m_network;
+                return new Object[]{ network != null && network.isWireless() };
             }
             default:
             {
@@ -277,46 +202,42 @@ public abstract class ModemPeripheral
     @Override
     public synchronized void attach( @Nonnull IComputerAccess computer )
     {
-        m_computer = computer;
+        synchronized( m_computers )
+        {
+            m_computers.add( computer );
+        }
+
         setNetwork( getNetwork() );
-        m_open = !m_channels.isEmpty();
     }
 
     @Override
     public synchronized void detach( @Nonnull IComputerAccess computer )
     {
-        if( m_network != null )
+        boolean empty;
+        synchronized( m_computers )
         {
-            m_network.removeReceiver( this );
-            m_channels.clear();
-            m_network = null;
+            m_computers.remove( computer );
+            empty = m_computers.isEmpty();
         }
 
-        m_computer = null;
-            
-        if( m_open )
-        {
-            m_open = false;        
-            m_changed = true;
-        }
-    }
-
-    public IComputerAccess getComputer()
-    {
-        return m_computer;
+        if( empty ) setNetwork( null );
     }
 
     @Nonnull
     @Override
     public String getSenderID()
     {
-        if( m_computer == null )
+        synchronized( m_computers )
         {
-            return "unknown";
-        }
-        else
-        {
-            return m_computer.getID() + "_" + m_computer.getAttachmentName();
+            if( m_computers.size() != 1 )
+            {
+                return "unknown";
+            }
+            else
+            {
+                IComputerAccess computer = m_computers.iterator().next();
+                return computer.getID() + "_" + computer.getAttachmentName();
+            }
         }
     }
 }

src/main/java/dan200/computercraft/shared/peripheral/modem/ModemState.java

@@ -0,0 +1,77 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2018. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+
+package dan200.computercraft.shared.peripheral.modem;
+
+import dan200.computercraft.api.lua.LuaException;
+import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import it.unimi.dsi.fastutil.ints.IntSet;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class ModemState
+{
+    private boolean open = false;
+    private AtomicBoolean changed = new AtomicBoolean( true );
+
+    private final IntSet channels = new IntOpenHashSet();
+
+    private void setOpen( boolean open )
+    {
+        if( this.open == open ) return;
+        this.open = open;
+        this.changed.set( true );
+    }
+
+    public boolean pollChanged()
+    {
+        return changed.getAndSet( false );
+    }
+
+    public boolean isOpen()
+    {
+        return open;
+    }
+
+    public boolean isOpen( int channel )
+    {
+        synchronized( channels )
+        {
+            return channels.contains( channel );
+        }
+    }
+
+    public void open( int channel ) throws LuaException
+    {
+        synchronized( channels )
+        {
+            if( !channels.contains( channel ) )
+            {
+                if( channels.size() >= 128 ) throw new LuaException( "Too many open channels" );
+                channels.add( channel );
+                setOpen( true );
+            }
+        }
+    }
+
+    public void close( int channel )
+    {
+        synchronized( channels )
+        {
+            channels.remove( channel );
+            if( channels.isEmpty() ) setOpen( false );
+        }
+    }
+
+    public void closeAll()
+    {
+        synchronized( channels )
+        {
+            channels.clear();
+            setOpen( false );
+        }
+    }
+}

src/main/java/dan200/computercraft/shared/peripheral/modem/TileAdvancedModem.java

@@ -25,7 +25,7 @@ public class TileAdvancedModem extends TileModemBase
 
         public Peripheral( TileModemBase entity )
         {
-            super( true );
+            super( new ModemState(), true );
             m_entity = entity;
         }
 

src/main/java/dan200/computercraft/shared/peripheral/modem/TileCable.java

@@ -106,12 +106,13 @@ public class TileCable extends TileModemBase
     {
         m_cable = new CableElement( this );
         m_node = m_cable.getNode();
-        return new WiredModemPeripheral( m_cable )
+        return new WiredModemPeripheral( new ModemState(), m_cable )
         {
+            @Nonnull
             @Override
-            protected boolean canSeePeripheral( @Nonnull String peripheralName )
+            protected WiredModemLocalPeripheral getLocalPeripheral()
             {
-                return !peripheralName.equals( m_peripheral.getConnectedName() );
+                return m_peripheral;
             }
 
             @Nonnull
@@ -452,14 +453,8 @@ public class TileCable extends TileModemBase
     protected void updateAnim()
     {
         int anim = 0;
-        if( m_modem.isActive() )
-        {
-            anim += 1;
-        }
-        if( m_peripheralAccessAllowed )
-        {
-            anim += 2;
-        }
+        if( m_modem.getModemState().isOpen() ) anim |= 1;
+        if( m_peripheralAccessAllowed ) anim |= 2;
         setAnim( anim );
     }
 

src/main/java/dan200/computercraft/shared/peripheral/modem/TileModemBase.java

@@ -37,7 +37,7 @@ public abstract class TileModemBase extends TilePeripheralBase
     protected abstract ModemPeripheral createPeripheral();
             
     @Override
-    public synchronized void destroy()
+    public void destroy()
     {
         if( m_modem != null )
         {
@@ -56,10 +56,7 @@ public abstract class TileModemBase extends TilePeripheralBase
     public void onNeighbourChange()
     {
         EnumFacing dir = getDirection();
-        if( !getWorld().isSideSolid(
-            getPos().offset( dir ),
-            dir.getOpposite()
-        ) )
+        if( !getWorld().isSideSolid( getPos().offset( dir ), dir.getOpposite() ) )
         {
             // Drop everything and remove block
             ((BlockGeneric)getBlockType()).dropAllItems( getWorld(), getPos(), false );
@@ -79,7 +76,7 @@ public abstract class TileModemBase extends TilePeripheralBase
     public void update()
     {
         super.update();
-        if( !getWorld().isRemote && m_modem.pollChanged() )
+        if( !getWorld().isRemote && m_modem.getModemState().pollChanged() )
         {
             updateAnim();
         }
@@ -87,14 +84,7 @@ public abstract class TileModemBase extends TilePeripheralBase
 
     protected void updateAnim()
     {
-        if( m_modem.isActive() )
-        {
-            setAnim(1);
-        }
-        else
-        {
-            setAnim(0);
-        }
+        setAnim( m_modem.getModemState().isOpen() ? 1 : 0 );
     }
 
     @Override
@@ -109,15 +99,6 @@ public abstract class TileModemBase extends TilePeripheralBase
     @Override
     public IPeripheral getPeripheral( EnumFacing side )
     {
-        if( side == getDirection() )
-        {
-            return m_modem;
-        }
-        return null;
-    }
-
-    protected boolean isAttached()
-    {
-        return (m_modem != null) && (m_modem.getComputer() != null);
+        return side == getDirection() ? m_modem : null;
     }
 }

src/main/java/dan200/computercraft/shared/peripheral/modem/TileWiredModemFull.java

@@ -83,6 +83,7 @@ public class TileWiredModemFull extends TilePeripheralBase
     private boolean m_destroyed = false;
     private boolean m_connectionsFormed = false;
 
+    private final ModemState m_modemState = new ModemState();
     private final WiredModemElement m_element = new FullElement( this );
     private final IWiredNode m_node = m_element.getNode();
 
@@ -236,19 +237,8 @@ public class TileWiredModemFull extends TilePeripheralBase
     protected void updateAnim()
     {
         int anim = 0;
-        for( WiredModemPeripheral modem : m_modems )
-        {
-            if( modem != null && modem.isActive() )
-            {
-                anim += 1;
-                break;
-            }
-        }
-
-        if( m_peripheralAccessAllowed )
-        {
-            anim += 2;
-        }
+        if( m_modemState.isOpen() ) anim |= 1;
+        if( m_peripheralAccessAllowed ) anim |= 2;
         setAnim( anim );
     }
 
@@ -264,12 +254,7 @@ public class TileWiredModemFull extends TilePeripheralBase
     {
         if( !getWorld().isRemote )
         {
-            boolean changed = false;
-            for( WiredModemPeripheral peripheral : m_modems )
-            {
-                if( peripheral != null && peripheral.pollChanged() ) changed = true;
-            }
-            if( changed ) updateAnim();
+            if( m_modemState.pollChanged() ) updateAnim();
 
             if( !m_connectionsFormed )
             {
@@ -401,12 +386,14 @@ public class TileWiredModemFull extends TilePeripheralBase
         WiredModemPeripheral peripheral = m_modems[side.ordinal()];
         if( peripheral == null )
         {
-            peripheral = m_modems[side.ordinal()] = new WiredModemPeripheral( m_element )
+            WiredModemLocalPeripheral localPeripheral = m_peripherals[side.ordinal()];
+            peripheral = m_modems[side.ordinal()] = new WiredModemPeripheral( m_modemState, m_element )
             {
+                @Nonnull
                 @Override
-                protected boolean canSeePeripheral( @Nonnull String peripheralName )
+                protected WiredModemLocalPeripheral getLocalPeripheral()
                 {
-                    return !peripheralName.equals( m_peripherals[side.ordinal()].getConnectedName() );
+                    return localPeripheral;
                 }
 
                 @Nonnull

src/main/java/dan200/computercraft/shared/peripheral/modem/TileWirelessModem.java

@@ -29,7 +29,7 @@ public class TileWirelessModem extends TileModemBase
 
         public Peripheral( TileModemBase entity )
         {
-            super( false );
+            super( new ModemState(), false );
             m_entity = entity;
         }
 

src/main/java/dan200/computercraft/shared/peripheral/modem/WiredModemPeripheral.java

@@ -10,12 +10,16 @@ import dan200.computercraft.api.network.wired.IWiredNode;
 import dan200.computercraft.api.network.wired.IWiredSender;
 import dan200.computercraft.api.peripheral.IComputerAccess;
 import dan200.computercraft.api.peripheral.IPeripheral;
+import dan200.computercraft.core.computer.Computer;
+import dan200.computercraft.core.computer.IComputerOwned;
 import net.minecraft.world.World;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 import static dan200.computercraft.core.apis.ArgumentHelper.getString;
 
@@ -23,10 +27,11 @@ public abstract class WiredModemPeripheral extends ModemPeripheral implements IW
 {
     private final WiredModemElement modem;
 
-    private final Map<String, RemotePeripheralWrapper> peripheralWrappers = new HashMap<>();
+    private final Map<IComputerAccess, ConcurrentMap<String, RemotePeripheralWrapper>> peripheralWrappers = new HashMap<>( 1 );
 
-    public WiredModemPeripheral( WiredModemElement modem )
+    public WiredModemPeripheral( ModemState state, WiredModemElement modem )
     {
+        super( state );
         this.modem = modem;
     }
 
@@ -56,7 +61,8 @@ public abstract class WiredModemPeripheral extends ModemPeripheral implements IW
         return modem.getWorld();
     }
 
-    protected abstract boolean canSeePeripheral( @Nonnull String peripheralName );
+    @Nonnull
+    protected abstract WiredModemLocalPeripheral getLocalPeripheral();
     //endregion
 
     //region IPeripheral
@@ -65,13 +71,14 @@ public abstract class WiredModemPeripheral extends ModemPeripheral implements IW
     public String[] getMethodNames()
     {
         String[] methods = super.getMethodNames();
-        String[] newMethods = new String[methods.length + 5];
+        String[] newMethods = new String[methods.length + 6];
         System.arraycopy( methods, 0, newMethods, 0, methods.length );
         newMethods[methods.length] = "getNamesRemote";
         newMethods[methods.length + 1] = "isPresentRemote";
         newMethods[methods.length + 2] = "getTypeRemote";
         newMethods[methods.length + 3] = "getMethodsRemote";
         newMethods[methods.length + 4] = "callRemote";
+        newMethods[methods.length + 5] = "getNameLocal";
         return newMethods;
     }
 
@@ -84,56 +91,60 @@ public abstract class WiredModemPeripheral extends ModemPeripheral implements IW
             case 0:
             {
                 // getNamesRemote
-                synchronized( peripheralWrappers )
+                Map<String, RemotePeripheralWrapper> wrappers = getWrappers( computer );
+                Map<Object, Object> table = new HashMap<>();
+                if( wrappers != null )
                 {
                     int idx = 1;
-                    Map<Object, Object> table = new HashMap<>();
-                    for( String name : peripheralWrappers.keySet() )
-                    {
-                        table.put( idx++, name );
-                    }
-                    return new Object[]{ table };
+                    for( String name : wrappers.keySet() ) table.put( idx++, name );
                 }
+                return new Object[]{ table };
             }
             case 1:
             {
                 // isPresentRemote
-                String type = getTypeRemote( getString( arguments, 0 ) );
-                return new Object[]{ type != null };
+                String name = getString( arguments, 0 );
+                return new Object[]{ getWrapper( computer, name ) != null };
             }
             case 2:
             {
                 // getTypeRemote
-                String type = getTypeRemote( getString( arguments, 0 ) );
-                if( type != null )
-                {
-                    return new Object[]{ type };
-                }
-                return null;
+                String name = getString( arguments, 0 );
+                RemotePeripheralWrapper wrapper = getWrapper( computer, name );
+                return wrapper != null ? new Object[]{ wrapper.getType() } : null;
             }
             case 3:
             {
                 // getMethodsRemote
-                String[] methodNames = getMethodNamesRemote( getString( arguments, 0 ) );
-                if( methodNames != null )
+                String name = getString( arguments, 0 );
+                RemotePeripheralWrapper wrapper = getWrapper( computer, name );
+                if( wrapper == null ) return null;
+
+                String[] methodNames = wrapper.getMethodNames();
+                Map<Object, Object> table = new HashMap<>();
+                for( int i = 0; i < methodNames.length; ++i )
                 {
-                    Map<Object, Object> table = new HashMap<>();
-                    for( int i = 0; i < methodNames.length; ++i )
-                    {
-                        table.put( i + 1, methodNames[i] );
-                    }
-                    return new Object[]{ table };
+                    table.put( i + 1, methodNames[i] );
                 }
-                return null;
+                return new Object[]{ table };
             }
             case 4:
             {
                 // callRemote
                 String remoteName = getString( arguments, 0 );
                 String methodName = getString( arguments, 1 );
+                RemotePeripheralWrapper wrapper = getWrapper( computer, remoteName );
+                if( wrapper == null ) throw new LuaException( "No peripheral: " + remoteName );
+
                 Object[] methodArgs = new Object[arguments.length - 2];
                 System.arraycopy( arguments, 2, methodArgs, 0, arguments.length - 2 );
-                return callMethodRemote( remoteName, context, methodName, methodArgs );
+                return wrapper.callMethod( context, methodName, methodArgs );
+            }
+            case 5:
+            {
+                // getNameLocal
+                String local = getLocalPeripheral().getConnectedName();
+                return local == null ? null : new Object[]{ local };
             }
             default:
             {
@@ -147,29 +158,37 @@ public abstract class WiredModemPeripheral extends ModemPeripheral implements IW
     public void attach( @Nonnull IComputerAccess computer )
     {
         super.attach( computer );
+
+        ConcurrentMap<String, RemotePeripheralWrapper> wrappers;
+        synchronized( peripheralWrappers )
+        {
+            wrappers = peripheralWrappers.get( computer );
+            if( wrappers == null ) peripheralWrappers.put( computer, wrappers = new ConcurrentHashMap<>() ); 
+        }
+        
         synchronized( modem.getRemotePeripherals() )
         {
-            synchronized( peripheralWrappers )
+            for( Map.Entry<String, IPeripheral> entry : modem.getRemotePeripherals().entrySet() )
             {
-                for( Map.Entry<String, IPeripheral> entry : modem.getRemotePeripherals().entrySet() )
-                {
-                    attachPeripheralImpl( entry.getKey(), entry.getValue() );
-                }
+                attachPeripheralImpl( computer, wrappers, entry.getKey(), entry.getValue() );
             }
         }
     }
 
     @Override
-    public synchronized void detach( @Nonnull IComputerAccess computer )
+    public void detach( @Nonnull IComputerAccess computer )
     {
+        Map<String, RemotePeripheralWrapper> wrappers;
         synchronized( peripheralWrappers )
         {
-            for( RemotePeripheralWrapper wrapper : peripheralWrappers.values() )
-            {
-                wrapper.detach();
-            }
-            peripheralWrappers.clear();
+            wrappers = peripheralWrappers.remove( computer );
         }
+        if( wrappers != null )
+        {
+            for( RemotePeripheralWrapper wrapper : wrappers.values() ) wrapper.detach();
+            wrappers.clear();
+        }
+
         super.detach( computer );
     }
 
@@ -194,11 +213,12 @@ public abstract class WiredModemPeripheral extends ModemPeripheral implements IW
 
     public void attachPeripheral( String name, IPeripheral peripheral )
     {
-        if( getComputer() == null ) return;
-
         synchronized( peripheralWrappers )
         {
-            attachPeripheralImpl( name, peripheral );
+            for( Map.Entry<IComputerAccess, ConcurrentMap<String, RemotePeripheralWrapper>> entry : peripheralWrappers.entrySet() )
+            {
+                attachPeripheralImpl( entry.getKey(), entry.getValue(), name, peripheral );
+            }
         }
     }
 
@@ -206,66 +226,38 @@ public abstract class WiredModemPeripheral extends ModemPeripheral implements IW
     {
         synchronized( peripheralWrappers )
         {
-            RemotePeripheralWrapper wrapper = peripheralWrappers.get( name );
-            if( wrapper != null )
-            {
-                peripheralWrappers.remove( name );
-                wrapper.detach();
+            for(ConcurrentMap<String, RemotePeripheralWrapper> wrappers : peripheralWrappers.values()) {
+                RemotePeripheralWrapper wrapper = wrappers.remove( name );
+                if( wrapper != null ) wrapper.detach();
             }
+            
         }
     }
 
-    private void attachPeripheralImpl( String periphName, IPeripheral peripheral )
+    private void attachPeripheralImpl( IComputerAccess computer, ConcurrentMap<String, RemotePeripheralWrapper> peripherals, String periphName, IPeripheral peripheral )
     {
-        if( !peripheralWrappers.containsKey( periphName ) && canSeePeripheral( periphName ) )
+        if( !peripherals.containsKey( periphName ) && !periphName.equals( getLocalPeripheral().getConnectedName() ) )
         {
-            RemotePeripheralWrapper wrapper = new RemotePeripheralWrapper( modem, peripheral, getComputer(), periphName );
-            peripheralWrappers.put( periphName, wrapper );
+            RemotePeripheralWrapper wrapper = new RemotePeripheralWrapper( modem, peripheral, computer, periphName );
+            peripherals.put( periphName, wrapper );
             wrapper.attach();
         }
     }
     
-    private String getTypeRemote( String remoteName )
-    {
+    private ConcurrentMap<String, RemotePeripheralWrapper> getWrappers( IComputerAccess computer ) {
         synchronized( peripheralWrappers )
         {
-            RemotePeripheralWrapper wrapper = peripheralWrappers.get( remoteName );
-            if( wrapper != null )
-            {
-                return wrapper.getType();
-            }
+            return peripheralWrappers.get( computer );
         }
-        return null;
     }
 
-    private String[] getMethodNamesRemote( String remoteName )
+    private RemotePeripheralWrapper getWrapper( IComputerAccess computer, String remoteName )
     {
-        synchronized( peripheralWrappers )
-        {
-            RemotePeripheralWrapper wrapper = peripheralWrappers.get( remoteName );
-            if( wrapper != null )
-            {
-                return wrapper.getMethodNames();
-            }
-        }
-        return null;
+        ConcurrentMap<String, RemotePeripheralWrapper> wrappers = getWrappers( computer );
+        return wrappers == null ? null : wrappers.get( remoteName );
     }
 
-    private Object[] callMethodRemote( String remoteName, ILuaContext context, String method, Object[] arguments ) throws LuaException, InterruptedException
-    {
-        RemotePeripheralWrapper wrapper;
-        synchronized( peripheralWrappers )
-        {
-            wrapper = peripheralWrappers.get( remoteName );
-        }
-        if( wrapper != null )
-        {
-            return wrapper.callMethod( context, method, arguments );
-        }
-        throw new LuaException( "No peripheral: " + remoteName );
-    }
-
-    private static class RemotePeripheralWrapper implements IComputerAccess
+    private static class RemotePeripheralWrapper implements IComputerAccess, IComputerOwned
     {
         private final WiredModemElement m_element;
         private final IPeripheral m_peripheral;
@@ -400,5 +392,12 @@ public abstract class WiredModemPeripheral extends ModemPeripheral implements IW
                 return m_element.getRemotePeripherals().get( name );
             }
         }
+
+        @Nullable
+        @Override
+        public Computer getComputer()
+        {
+            return m_computer instanceof IComputerOwned ? ((IComputerOwned) m_computer).getComputer() : null;
+        }
     }
 }

src/main/java/dan200/computercraft/shared/peripheral/modem/WirelessModemPeripheral.java

@@ -15,9 +15,16 @@ public abstract class WirelessModemPeripheral extends ModemPeripheral
 {
     private boolean m_advanced;
 
+    public WirelessModemPeripheral( ModemState state, boolean advanced )
+    {
+        super( state );
+        m_advanced = advanced;
+    }
+
+    @Deprecated
     public WirelessModemPeripheral( boolean advanced )
     {
-        m_advanced = advanced;
+        this( new ModemState(), advanced );
     }
 
     @Override

src/main/java/dan200/computercraft/shared/peripheral/modem/WirelessNetwork.java

@@ -13,8 +13,9 @@ import dan200.computercraft.api.network.IPacketSender;
 import dan200.computercraft.api.network.Packet;
 
 import javax.annotation.Nonnull;
-import java.util.HashSet;
+import java.util.Collections;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class WirelessNetwork implements IPacketNetwork
 {
@@ -34,45 +35,34 @@ public class WirelessNetwork implements IPacketNetwork
         s_universalNetwork = null;
     }
 
-    private final Set<IPacketReceiver> m_receivers;
-
-    private WirelessNetwork()
-    {
-        m_receivers = new HashSet<>();
-    }
+    private final Set<IPacketReceiver> m_receivers = Collections.newSetFromMap( new ConcurrentHashMap<>() );
 
     @Override
-    public synchronized void addReceiver( @Nonnull IPacketReceiver receiver )
+    public void addReceiver( @Nonnull IPacketReceiver receiver )
     {
         Preconditions.checkNotNull( receiver, "device cannot be null" );
         m_receivers.add( receiver );
     }
 
     @Override
-    public synchronized void removeReceiver( @Nonnull IPacketReceiver receiver )
+    public void removeReceiver( @Nonnull IPacketReceiver receiver )
     {
         Preconditions.checkNotNull( receiver, "device cannot be null" );
         m_receivers.remove( receiver );
     }
 
     @Override
-    public synchronized void transmitSameDimension( @Nonnull Packet packet, double range )
+    public void transmitSameDimension( @Nonnull Packet packet, double range )
     {
         Preconditions.checkNotNull( packet, "packet cannot be null" );
-        for( IPacketReceiver device : m_receivers )
-        {
-            tryTransmit( device, packet, range, false );
-        }
+        for( IPacketReceiver device : m_receivers ) tryTransmit( device, packet, range, false );
     }
 
     @Override
-    public synchronized void transmitInterdimensional( @Nonnull Packet packet )
+    public void transmitInterdimensional( @Nonnull Packet packet )
     {
         Preconditions.checkNotNull( packet, "packet cannot be null" );
-        for (IPacketReceiver device : m_receivers)
-        {
-            tryTransmit( device, packet, 0, true );
-        }
+        for( IPacketReceiver device : m_receivers ) tryTransmit( device, packet, 0, true );
     }
 
     private void tryTransmit( IPacketReceiver receiver, Packet packet, double range, boolean interdimensional )

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

@@ -66,7 +66,8 @@ public class MonitorPeripheral implements IPeripheral
             "setPaletteColor",
             "getPaletteColour",
             "getPaletteColor",
-            "getTextScale"
+            "getTextScale",
+            "getCursorBlink",
         };
     }
 
@@ -245,8 +246,12 @@ public class MonitorPeripheral implements IPeripheral
                 // getTextScale
                 return new Object[] { monitor.getTextScale() / 2.0 };
             }
+            case 25:
+                // getCursorBlink
+                return new Object[] { terminal.getCursorBlink() };
+            default:
+                return null;
         }
-        return null;
     }
 
     @Override

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

@@ -344,7 +344,7 @@ public class TileMonitor extends TilePeripheralBase
 
     public EnumFacing getFront()
     {
-        return m_dir <= 5 ? EnumFacing.getFront( m_dir ) : (m_dir <= 11 ? EnumFacing.DOWN : EnumFacing.UP);
+        return m_dir <= 5 ? EnumFacing.byIndex( m_dir ) : (m_dir <= 11 ? EnumFacing.DOWN : EnumFacing.UP);
     }
 
     public EnumFacing getRight()

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

@@ -190,10 +190,7 @@ public class TilePrinter extends TilePeripheralBase
     @Override    
     public ItemStack getStackInSlot(int i)
     {
-        synchronized( m_inventory )
-        {
-            return m_inventory.get( i );
-        }
+        return m_inventory.get( i );
     }
 
     @Nonnull

src/main/java/dan200/computercraft/shared/peripheral/speaker/SpeakerPeripheral.java

@@ -8,10 +8,11 @@ package dan200.computercraft.shared.peripheral.speaker;
 
 import dan200.computercraft.ComputerCraft;
 import dan200.computercraft.api.lua.ILuaContext;
-import dan200.computercraft.api.lua.ILuaTask;
 import dan200.computercraft.api.lua.LuaException;
 import dan200.computercraft.api.peripheral.IComputerAccess;
 import dan200.computercraft.api.peripheral.IPeripheral;
+import net.minecraft.network.play.server.SPacketCustomSound;
+import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.SoundCategory;
 import net.minecraft.util.SoundEvent;
@@ -20,33 +21,35 @@ import net.minecraft.world.World;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static dan200.computercraft.core.apis.ArgumentHelper.getString;
 import static dan200.computercraft.core.apis.ArgumentHelper.optReal;
 
-public class SpeakerPeripheral implements IPeripheral {
-    private TileSpeaker m_speaker;
+public class SpeakerPeripheral implements IPeripheral
+{
+    private final TileSpeaker m_speaker;
     private long m_clock;
     private long m_lastPlayTime;
-    private int m_notesThisTick;
+    private final AtomicInteger m_notesThisTick;
 
     public SpeakerPeripheral()
     {
-        m_clock = 0;
-        m_lastPlayTime = 0;
-        m_notesThisTick = 0;
+        this( null );
     }
 
-    SpeakerPeripheral(TileSpeaker speaker)
+    SpeakerPeripheral( TileSpeaker speaker )
     {
-        this();
+        m_clock = 0;
+        m_lastPlayTime = 0;
+        m_notesThisTick = new AtomicInteger(  );
         m_speaker = speaker;
     }
 
-    public synchronized void update()
+    public void update()
     {
         m_clock++;
-        m_notesThisTick = 0;
+        m_notesThisTick.set( 0 );
     }
 
     public World getWorld()
@@ -59,9 +62,9 @@ public class SpeakerPeripheral implements IPeripheral {
         return m_speaker.getPos();
     }
 
-    public synchronized boolean madeSound(long ticks)
+    public boolean madeSound(long ticks)
     {
-        return (m_clock - m_lastPlayTime <= ticks) ;
+        return m_clock - m_lastPlayTime <= ticks;
     }
 
     /* IPeripheral implementation */
@@ -69,15 +72,9 @@ public class SpeakerPeripheral implements IPeripheral {
     @Override
     public boolean equals( IPeripheral other )
     {
-        if( other != null && other instanceof SpeakerPeripheral )
-        {
-            SpeakerPeripheral otherSpeaker = (SpeakerPeripheral) other;
-            return otherSpeaker.m_speaker == m_speaker;
-        }
-        else
-        {
-            return false;
-        }
+        if( other == this ) return true;
+        if( !(other instanceof SpeakerPeripheral) ) return false;
+        return m_speaker == ((SpeakerPeripheral) other).m_speaker;
     }
 
     @Nonnull
@@ -92,8 +89,8 @@ public class SpeakerPeripheral implements IPeripheral {
     public String[] getMethodNames()
     {
         return new String[] {
-                "playSound", // Plays sound at resourceLocator
-                "playNote" // Plays note
+            "playSound", // Plays sound at resourceLocator
+            "playNote" // Plays note
         };
     }
 
@@ -105,18 +102,22 @@ public class SpeakerPeripheral implements IPeripheral {
             // playSound
             case 0:
             {
-                return playSound(args, context, false);
+                String name = getString( args, 0 );
+                float volume = (float) optReal( args, 1, 1.0 );
+                float pitch = (float) optReal( args, 2, 1.0 );
+
+                return new Object[] { playSound( context, name, volume, pitch, false ) };
             }
 
             // playNote
             case 1:
             {
-                return playNote(args, context);
+                return playNote( args, context );
             }
 
             default:
             {
-                throw new LuaException("Method index out of range!");
+                throw new LuaException( "Method index out of range!" );
             }
 
         }
@@ -125,75 +126,53 @@ public class SpeakerPeripheral implements IPeripheral {
     @Nonnull
     private synchronized Object[] playNote( Object[] arguments, ILuaContext context ) throws LuaException
     {
-        String name = getString(arguments, 0);
+        String name = getString( arguments, 0 );
         float volume = (float) optReal( arguments, 1, 1.0 );
         float pitch = (float) optReal( arguments, 2, 1.0 );
         
-        // Check if sound exists
-        if ( !SoundEvent.REGISTRY.containsKey( new ResourceLocation( "block.note." + name ) ) )
+        String noteName = "block.note." + name;
+
+        // Check if the note exists
+        if( !SoundEvent.REGISTRY.containsKey( new ResourceLocation( noteName ) ) )
         {
-            throw new LuaException("Invalid instrument, \"" + arguments[0] + "\"!");
+            throw new LuaException( "Invalid instrument, \"" + name + "\"!" );
         }
 
         // If the resource location for note block notes changes, this method call will need to be updated
-        Object[] returnValue = playSound(
-            new Object[] {
-                "block.note." + name,
-                (double)Math.min( volume, 3f ),
-                Math.pow( 2.0f, ( pitch - 12.0f ) / 12.0f)
-            }, context, true
-        );
+        boolean success = playSound( context, noteName, volume, (float) Math.pow( 2.0, (pitch - 12.0) / 12.0 ), true );
 
-        if( returnValue[0] instanceof Boolean && (Boolean) returnValue[0] )
-        {
-            m_notesThisTick++;
-        }
-
-        return returnValue;
+        if( success ) m_notesThisTick.incrementAndGet();
+        return new Object[] { success };
     }
 
-    @Nonnull
-    private synchronized Object[] playSound( Object[] arguments, ILuaContext context, boolean isNote ) throws LuaException
+    private synchronized boolean playSound( ILuaContext context, String name, float volume, float pitch, boolean isNote ) throws LuaException
     {
-        String name = getString(arguments, 0);
-        float volume = (float) optReal( arguments, 1, 1.0 );
-        float pitch = (float) optReal( arguments, 2, 1.0 );
-
-        ResourceLocation resourceName = new ResourceLocation( name );
-
-        if( m_clock - m_lastPlayTime >= TileSpeaker.MIN_TICKS_BETWEEN_SOUNDS || ( ( m_clock - m_lastPlayTime == 0 ) && ( m_notesThisTick < ComputerCraft.maxNotesPerTick ) && isNote ) )
+        if( m_clock - m_lastPlayTime < TileSpeaker.MIN_TICKS_BETWEEN_SOUNDS &&
+            (!isNote || m_clock - m_lastPlayTime != 0 || m_notesThisTick.get() >= ComputerCraft.maxNotesPerTick) )
         {
-            if( SoundEvent.REGISTRY.containsKey(resourceName) )
-            {
-                final World world = getWorld();
-                final BlockPos pos = getPos();
-                final ResourceLocation resource = resourceName;
-                final float vol = volume;
-                final float soundPitch = pitch;
-
-                context.issueMainThreadTask(new ILuaTask()
-                {
-                    @Nullable
-                    @Override
-                    public Object[] execute()
-                    {
-                        world.playSound( null, pos, SoundEvent.REGISTRY.getObject( resource ), SoundCategory.RECORDS, Math.min( vol, 3f ), soundPitch );
-                        return null;
-                    }
-                });
-
-                m_lastPlayTime = m_clock;
-                return new Object[]{true}; // Success, return true
-            }
-            else
-            {
-                return new Object[]{false}; // Failed - sound not existent, return false
-            }
-        }
-        else
-        {
-            return new Object[]{false}; // Failed - rate limited, return false
+            // Rate limiting occurs when we've already played a sound within the last tick, or we've
+            // played more notes than allowable within the current tick.
+            return false;
         }
+
+        World world = getWorld();
+        BlockPos pos = getPos();
+
+        context.issueMainThreadTask( () -> {
+            MinecraftServer server = world.getMinecraftServer();
+            if( server == null ) return null;
+
+            double x = pos.getX() + 0.5, y = pos.getY() + 0.5, z = pos.getZ() + 0.5;
+            float adjVolume = Math.min( volume, 3.0f );
+            server.getPlayerList().sendToAllNearExcept(
+                null, x, y, z, adjVolume > 1.0f ? 16 * adjVolume : 16.0, world.provider.getDimension(),
+                new SPacketCustomSound( name, SoundCategory.RECORDS, x, y, z, adjVolume, pitch )
+            );
+            return null;
+        } );
+
+        m_lastPlayTime = m_clock;
+        return true;
     }
 }
 

src/main/java/dan200/computercraft/shared/peripheral/speaker/TileSpeaker.java

@@ -25,7 +25,7 @@ public class TileSpeaker extends TilePeripheralBase
     }
 
     @Override
-    public synchronized void update()
+    public void update()
     {
         m_peripheral.update();
     }

src/main/java/dan200/computercraft/shared/pocket/core/PocketServerComputer.java

@@ -8,6 +8,7 @@ import dan200.computercraft.shared.computer.core.ComputerFamily;
 import dan200.computercraft.shared.computer.core.ServerComputer;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
@@ -138,7 +139,7 @@ public class PocketServerComputer extends ServerComputer implements IPocketAcces
     {
         if( this.m_upgrade == upgrade ) return;
 
-        synchronized (this)
+        synchronized( this )
         {
             ComputerCraft.Items.pocketComputer.setUpgrade( m_stack, upgrade );
             if( m_entity instanceof EntityPlayer ) ((EntityPlayer) m_entity).inventory.markDirty();
@@ -156,6 +157,9 @@ public class PocketServerComputer extends ServerComputer implements IPocketAcces
             setPosition( entity.getPosition() );
         }
 
+        // If a new entity has picked it up then rebroadcast the terminal to them
+        if( entity != m_entity && entity instanceof EntityPlayerMP ) markTerminalChanged();
+
         m_entity = entity;
         m_stack = stack;
 
@@ -165,4 +169,19 @@ public class PocketServerComputer extends ServerComputer implements IPocketAcces
             invalidatePeripheral();
         }
     }
+
+    public void broadcastState( boolean force )
+    {
+        super.broadcastState( force );
+
+        if( (hasTerminalChanged() || force) && m_entity instanceof EntityPlayerMP )
+        {
+            // Broadcast the state to the current entity if they're not already interacting with it.
+            EntityPlayerMP player = (EntityPlayerMP) m_entity;
+            if( player.connection != null && !isInteracting( player ) )
+            {
+                ComputerCraft.sendToPlayer( player, createTerminalPacket() );
+            }
+        }
+    }
 }

src/main/java/dan200/computercraft/shared/pocket/items/ItemPocketComputer.java

@@ -43,7 +43,7 @@ public class ItemPocketComputer extends Item implements IComputerItem, IMedia, I
     {
         setMaxStackSize( 1 );
         setHasSubtypes( true );
-        setUnlocalizedName( "computercraft:pocket_computer" );
+        setTranslationKey( "computercraft:pocket_computer" );
         setCreativeTab( ComputerCraft.mainCreativeTab );
     }
 
@@ -189,7 +189,7 @@ public class ItemPocketComputer extends Item implements IComputerItem, IMedia, I
 
     @Nonnull
     @Override
-    public String getUnlocalizedName( @Nonnull ItemStack stack )
+    public String getTranslationKey( @Nonnull ItemStack stack )
     {
         switch( getFamily( stack ) )
         {
@@ -209,7 +209,7 @@ public class ItemPocketComputer extends Item implements IComputerItem, IMedia, I
     @Override
     public String getItemStackDisplayName( @Nonnull ItemStack stack )
     {
-        String baseString = getUnlocalizedName( stack );
+        String baseString = getTranslationKey( stack );
         IPocketUpgrade upgrade = getUpgrade( stack );
         if( upgrade != null )
         {

src/main/java/dan200/computercraft/shared/pocket/peripherals/PocketModem.java

@@ -5,6 +5,7 @@ import dan200.computercraft.api.pocket.IPocketAccess;
 import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.shared.peripheral.PeripheralType;
 import dan200.computercraft.shared.peripheral.common.PeripheralItemFactory;
+import dan200.computercraft.shared.peripheral.modem.ModemState;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.item.ItemStack;
@@ -75,7 +76,8 @@ public class PocketModem implements IPocketUpgrade
                 modem.setLocation( entity.getEntityWorld(), entity.posX, entity.posY, entity.posZ );
             }
 
-            access.setLight( modem.isActive() ? 0xBA0000 : -1 );
+            ModemState state = modem.getModemState();
+            if( state.pollChanged() ) access.setLight( state.isOpen() ? 0xBA0000 : -1 );
         }
     }
 }

src/main/java/dan200/computercraft/shared/pocket/peripherals/PocketModemPeripheral.java

@@ -6,6 +6,7 @@
 package dan200.computercraft.shared.pocket.peripherals;
 
 import dan200.computercraft.api.peripheral.IPeripheral;
+import dan200.computercraft.shared.peripheral.modem.ModemState;
 import dan200.computercraft.shared.peripheral.modem.WirelessModemPeripheral;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
@@ -19,7 +20,7 @@ public class PocketModemPeripheral extends WirelessModemPeripheral
 
     public PocketModemPeripheral( boolean advanced )
     {
-        super( advanced );
+        super( new ModemState(), advanced );
         m_world = null;
         m_position = new Vec3d( 0.0, 0.0, 0.0 );
     }

src/main/java/dan200/computercraft/shared/proxy/CCTurtleProxyCommon.java

@@ -21,7 +21,6 @@ import dan200.computercraft.shared.turtle.items.ItemTurtleNormal;
 import dan200.computercraft.shared.turtle.items.TurtleItemFactory;
 import dan200.computercraft.shared.turtle.recipes.TurtleUpgradeRecipe;
 import dan200.computercraft.shared.turtle.upgrades.*;
-import dan200.computercraft.shared.util.IEntityDropConsumer;
 import dan200.computercraft.shared.util.ImpostorRecipe;
 import dan200.computercraft.shared.util.InventoryUtil;
 import net.minecraft.block.Block;
@@ -33,28 +32,44 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.IRecipe;
 import net.minecraft.util.NonNullList;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.RegistryEvent;
+import net.minecraftforge.event.entity.EntityJoinWorldEvent;
 import net.minecraftforge.event.entity.living.LivingDropsEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.registry.EntityRegistry;
 import net.minecraftforge.fml.common.registry.GameRegistry;
 import net.minecraftforge.registries.IForgeRegistry;
 
 import javax.annotation.Nonnull;
-import java.util.*;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 
 public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
 {
     private Map<Integer, ITurtleUpgrade> m_legacyTurtleUpgrades;
     private Map<String, ITurtleUpgrade> m_turtleUpgrades;
-    private Map<Entity, IEntityDropConsumer> m_dropConsumers;
+
+    private Function<ItemStack, ItemStack> dropConsumer;
+    private List<ItemStack> remainingDrops;
+    private WeakReference<World> dropWorld;
+    private BlockPos dropPos;
+    private AxisAlignedBB dropBounds;
+    private WeakReference<Entity> dropEntity;
 
     public CCTurtleProxyCommon()
     {
         m_legacyTurtleUpgrades = new HashMap<>();
         m_turtleUpgrades = new HashMap<>();
-        m_dropConsumers = new WeakHashMap<>();
     }
 
     // ICCTurtleProxy implementation
@@ -126,7 +141,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
             }
             catch( Exception e )
             {
-                ComputerCraft.log.error("Error getting computer upgrade item", e);
+                ComputerCraft.log.error( "Error getting computer upgrade item", e );
             }
         }
         return null;
@@ -169,7 +184,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
 
     private void addUpgradedTurtle( ComputerFamily family, ITurtleUpgrade upgrade, List<ItemStack> list )
     {
-        if ( isUpgradeSuitableForFamily( family, upgrade ) )
+        if( isUpgradeSuitableForFamily( family, upgrade ) )
         {
             ItemStack stack = TurtleItemFactory.create( -1, null, -1, family, upgrade, null, 0, null );
             if( !stack.isEmpty() )
@@ -187,45 +202,56 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
     }
 
     @Override
-    public void setEntityDropConsumer( Entity entity, IEntityDropConsumer consumer )
+    public void setDropConsumer( Entity entity, Function<ItemStack, ItemStack> consumer )
     {
-        if( !m_dropConsumers.containsKey( entity ) )
-        {
-            boolean captured = entity.captureDrops;
+        dropConsumer = consumer;
+        remainingDrops = new ArrayList<>();
+        dropEntity = new WeakReference<>( entity );
+        dropWorld = new WeakReference<>( entity.world );
+        dropPos = null;
+        dropBounds = new AxisAlignedBB( entity.getPosition() ).grow( 2, 2, 2 );
 
-            if( !captured )
-            {
-                entity.captureDrops = true;
-                ArrayList<EntityItem> items = entity.capturedDrops;
-                
-                if( items == null || items.size() == 0 )
-                {
-                    m_dropConsumers.put( entity, consumer );
-                }
-            }
-        }
+        entity.captureDrops = true;
     }
 
     @Override
-    public void clearEntityDropConsumer( Entity entity )
+    public void setDropConsumer( World world, BlockPos pos, Function<ItemStack, ItemStack> consumer )
     {
-        if( m_dropConsumers.containsKey( entity ) )
-        {
-            boolean captured = entity.captureDrops;
+        dropConsumer = consumer;
+        remainingDrops = new ArrayList<>();
+        dropEntity = null;
+        dropWorld = new WeakReference<>( world );
+        dropPos = pos;
+        dropBounds = new AxisAlignedBB( pos ).grow( 2, 2, 2 );
+    }
 
-            if( captured )
+    @Override
+    public List<ItemStack> clearDropConsumer()
+    {
+        if( dropEntity != null )
+        {
+            Entity entity = dropEntity.get();
+            if( entity != null )
             {
                 entity.captureDrops = false;
-                ArrayList<EntityItem> items = entity.capturedDrops;
-                
-                if( items != null )
+                if( entity.capturedDrops != null )
                 {
-                    dispatchEntityDrops( entity, items );
-                    items.clear();
+                    for( EntityItem entityItem : entity.capturedDrops ) handleDrops( entityItem.getItem() );
+                    entity.capturedDrops.clear();
                 }
             }
-            m_dropConsumers.remove( entity );
         }
+
+        List<ItemStack> remainingStacks = remainingDrops;
+
+        dropConsumer = null;
+        remainingDrops = null;
+        dropEntity = null;
+        dropWorld = null;
+        dropPos = null;
+        dropBounds = null;
+
+        return remainingStacks;
     }
 
     private void registerTurtleUpgradeInternal( ITurtleUpgrade upgrade )
@@ -289,7 +315,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
     {
         IForgeRegistry<Item> registry = event.getRegistry();
 
-        registry.register( new ItemTurtleLegacy( ComputerCraft.Blocks.turtle).setRegistryName( new ResourceLocation( ComputerCraft.MOD_ID, "turtle" ) ) );
+        registry.register( new ItemTurtleLegacy( ComputerCraft.Blocks.turtle ).setRegistryName( new ResourceLocation( ComputerCraft.MOD_ID, "turtle" ) ) );
         registry.register( new ItemTurtleNormal( ComputerCraft.Blocks.turtleExpanded ).setRegistryName( new ResourceLocation( ComputerCraft.MOD_ID, "turtle_expanded" ) ) );
         registry.register( new ItemTurtleAdvanced( ComputerCraft.Blocks.turtleAdvanced ).setRegistryName( new ResourceLocation( ComputerCraft.MOD_ID, "turtle_advanced" ) ) );
     }
@@ -362,7 +388,7 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
     private void registerUpgrades()
     {
         // Upgrades
-        ComputerCraft.Upgrades.wirelessModem =  new TurtleModem( false, new ResourceLocation( "computercraft", "wireless_modem" ), 1 );
+        ComputerCraft.Upgrades.wirelessModem = new TurtleModem( false, new ResourceLocation( "computercraft", "wireless_modem" ), 1 );
         registerTurtleUpgradeInternal( ComputerCraft.Upgrades.wirelessModem );
 
         ComputerCraft.Upgrades.craftingTable = new TurtleCraftingTable( 2 );
@@ -396,10 +422,10 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
         // We have to use mappings.getAllMappings() as the mod ID is upper case but the domain lower.
         for( RegistryEvent.MissingMappings.Mapping<Item> mapping : mappings.getAllMappings() )
         {
-            String domain = mapping.key.getResourceDomain();
+            String domain = mapping.key.getNamespace();
             if( !domain.equalsIgnoreCase( ComputerCraft.MOD_ID ) ) continue;
 
-            String key = mapping.key.getResourcePath();
+            String key = mapping.key.getPath();
             if( key.equalsIgnoreCase( "CC-Turtle" ) )
             {
                 mapping.remap( Item.getItemFromBlock( ComputerCraft.Blocks.turtle ) );
@@ -421,10 +447,10 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
         // We have to use mappings.getAllMappings() as the mod ID is upper case but the domain lower.
         for( RegistryEvent.MissingMappings.Mapping<Block> mapping : mappings.getAllMappings() )
         {
-            String domain = mapping.key.getResourceDomain();
+            String domain = mapping.key.getNamespace();
             if( !domain.equalsIgnoreCase( ComputerCraft.MOD_ID ) ) continue;
 
-            String key = mapping.key.getResourcePath();
+            String key = mapping.key.getPath();
             if( key.equalsIgnoreCase( "CC-Turtle" ) )
             {
                 mapping.remap( ComputerCraft.Blocks.turtle );
@@ -443,9 +469,9 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
     private void registerTileEntities()
     {
         // TileEntities
-        GameRegistry.registerTileEntity( TileTurtle.class, ComputerCraft.LOWER_ID + " : " + "turtle" );
-        GameRegistry.registerTileEntity( TileTurtleExpanded.class, ComputerCraft.LOWER_ID + " : " + "turtleex" );
-        GameRegistry.registerTileEntity( TileTurtleAdvanced.class, ComputerCraft.LOWER_ID + " : " + "turtleadv" );
+        GameRegistry.registerTileEntity( TileTurtle.class, new ResourceLocation( ComputerCraft.MOD_ID, "turtle" ) );
+        GameRegistry.registerTileEntity( TileTurtleExpanded.class, new ResourceLocation( ComputerCraft.MOD_ID, "turtleex" ) );
+        GameRegistry.registerTileEntity( TileTurtleAdvanced.class, new ResourceLocation( ComputerCraft.MOD_ID, "turtleadv" ) );
     }
 
     private void registerForgeHandlers()
@@ -454,17 +480,51 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
         MinecraftForge.EVENT_BUS.register( handlers );
     }
 
-    public class ForgeHandlers
+    private void handleDrops(ItemStack stack)
     {
-        private ForgeHandlers()
-        {
-        }
+        ItemStack remaining = dropConsumer.apply(stack);
+        if (!remaining.isEmpty()) remainingDrops.add(remaining);
+    }
 
-        // Forge event responses 
-        @SubscribeEvent
+    private class ForgeHandlers
+    {
+        @SubscribeEvent(priority = EventPriority.LOWEST)
         public void onEntityLivingDrops( LivingDropsEvent event )
         {
-            dispatchEntityDrops( event.getEntity(), event.getDrops() );
+            // Capture any mob drops for the current entity
+            if( dropEntity != null && event.getEntity() == dropEntity.get() )
+            {
+                List<EntityItem> drops = event.getDrops();
+                for( EntityItem entityItem : drops ) handleDrops( entityItem.getItem() );
+                drops.clear();
+            }
+        }
+
+        @SubscribeEvent(priority = EventPriority.LOWEST)
+        public void onHarvestDrops( BlockEvent.HarvestDropsEvent event )
+        {
+            // Capture block drops for the current entity
+            if( dropWorld != null && dropWorld.get() == event.getWorld()
+                && dropPos != null && dropPos.equals( event.getPos() ) )
+            {
+                for( ItemStack item : event.getDrops() )
+                {
+                    if( event.getWorld().rand.nextFloat() < event.getDropChance() ) handleDrops( item );
+                }
+                event.getDrops().clear();
+            }
+        }
+
+        @SubscribeEvent(priority = EventPriority.LOWEST)
+        public void onEntitySpawn( EntityJoinWorldEvent event )
+        {
+            // Capture any nearby item spawns
+            if( dropWorld != null && dropWorld.get() == event.getWorld() && event.getEntity() instanceof EntityItem
+                && dropBounds.contains( event.getEntity().getPositionVector() ) )
+            {
+                handleDrops( ((EntityItem) event.getEntity()).getItem() );
+                event.setCanceled( true );
+            }
         }
 
         @SubscribeEvent
@@ -476,17 +536,4 @@ public abstract class CCTurtleProxyCommon implements ICCTurtleProxy
         }
     }
 
-    private void dispatchEntityDrops( Entity entity, java.util.List<EntityItem> drops )
-    {
-        IEntityDropConsumer consumer = m_dropConsumers.get( entity );
-        if( consumer != null )
-        {
-            // All checks have passed, lets dispatch the drops
-            for(EntityItem entityItem : drops)
-            {
-                consumer.consumeDrop( entity, entityItem.getItem() );
-            }
-            drops.clear();
-        }
-    }
 }

src/main/java/dan200/computercraft/shared/proxy/ComputerCraftProxyCommon.java

@@ -24,6 +24,8 @@ import dan200.computercraft.shared.computer.core.*;
 import dan200.computercraft.shared.computer.inventory.ContainerComputer;
 import dan200.computercraft.shared.computer.items.ItemCommandComputer;
 import dan200.computercraft.shared.computer.items.ItemComputer;
+import dan200.computercraft.shared.datafix.Fixes;
+import dan200.computercraft.shared.integration.charset.IntegrationCharset;
 import dan200.computercraft.shared.media.common.DefaultMediaProvider;
 import dan200.computercraft.shared.media.inventory.ContainerHeldItem;
 import dan200.computercraft.shared.media.items.ItemDiskExpanded;
@@ -76,6 +78,8 @@ import net.minecraftforge.event.RegistryEvent;
 import net.minecraftforge.event.entity.player.PlayerContainerEvent;
 import net.minecraftforge.event.world.WorldEvent;
 import net.minecraftforge.fml.client.event.ConfigChangedEvent;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.Loader;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
 import net.minecraftforge.fml.common.network.FMLNetworkEvent;
@@ -83,6 +87,7 @@ import net.minecraftforge.fml.common.network.IGuiHandler;
 import net.minecraftforge.fml.common.network.NetworkRegistry;
 import net.minecraftforge.fml.common.registry.GameRegistry;
 import net.minecraftforge.registries.IForgeRegistry;
+import pl.asie.charset.ModCharset;
 
 import javax.annotation.Nonnull;
 import java.io.File;
@@ -117,6 +122,9 @@ public abstract class ComputerCraftProxyCommon implements IComputerCraftProxy
     {
         registerTileEntities();
         registerForgeHandlers();
+
+        Fixes.register( FMLCommonHandler.instance().getDataFixer() );
+        if( Loader.isModLoaded( ModCharset.MODID ) ) IntegrationCharset.register();
     }
 
     @Override
@@ -414,10 +422,10 @@ public abstract class ComputerCraftProxyCommon implements IComputerCraftProxy
         // We have to use mappings.getAllMappings() as the mod ID is upper case but the domain lower.
         for( RegistryEvent.MissingMappings.Mapping<Item> mapping : mappings.getAllMappings() )
         {
-            String domain = mapping.key.getResourceDomain();
+            String domain = mapping.key.getNamespace();
             if( !domain.equalsIgnoreCase( ComputerCraft.MOD_ID ) ) continue;
 
-            String key = mapping.key.getResourcePath();
+            String key = mapping.key.getPath();
             if( key.equalsIgnoreCase( "CC-Computer" ) )
             {
                 mapping.remap( Item.getItemFromBlock( ComputerCraft.Blocks.computer ) );
@@ -451,10 +459,10 @@ public abstract class ComputerCraftProxyCommon implements IComputerCraftProxy
         // We have to use mappings.getAllMappings() as the mod ID is upper case but the domain lower.
         for( RegistryEvent.MissingMappings.Mapping<Block> mapping : mappings.getAllMappings() )
         {
-            String domain = mapping.key.getResourceDomain();
+            String domain = mapping.key.getNamespace();
             if( !domain.equalsIgnoreCase( ComputerCraft.MOD_ID ) ) continue;
 
-            String key = mapping.key.getResourcePath();
+            String key = mapping.key.getPath();
             if( key.equalsIgnoreCase( "CC-Computer" ) )
             {
                 mapping.remap( ComputerCraft.Blocks.computer );
@@ -473,16 +481,16 @@ public abstract class ComputerCraftProxyCommon implements IComputerCraftProxy
     private void registerTileEntities()
     {
         // Tile Entities
-        GameRegistry.registerTileEntity( TileComputer.class, ComputerCraft.LOWER_ID + " : " + "computer" );
-        GameRegistry.registerTileEntity( TileDiskDrive.class, ComputerCraft.LOWER_ID + " : " + "diskdrive" );
-        GameRegistry.registerTileEntity( TileWirelessModem.class, ComputerCraft.LOWER_ID + " : " + "wirelessmodem" );
-        GameRegistry.registerTileEntity( TileMonitor.class, ComputerCraft.LOWER_ID + " : " + "monitor" );
-        GameRegistry.registerTileEntity( TilePrinter.class, ComputerCraft.LOWER_ID + " : " + "ccprinter" );
-        GameRegistry.registerTileEntity( TileCable.class, ComputerCraft.LOWER_ID + " : " + "wiredmodem" );
-        GameRegistry.registerTileEntity( TileCommandComputer.class, ComputerCraft.LOWER_ID + " : " + "command_computer" );
-        GameRegistry.registerTileEntity( TileAdvancedModem.class, ComputerCraft.LOWER_ID + " : " + "advanced_modem" );
-        GameRegistry.registerTileEntity( TileSpeaker.class, ComputerCraft.LOWER_ID + " : " + "speaker" );
-        GameRegistry.registerTileEntity( TileWiredModemFull.class, ComputerCraft.LOWER_ID + " : " + "wired_modem_full" );
+        GameRegistry.registerTileEntity( TileComputer.class, new ResourceLocation( ComputerCraft.MOD_ID, "computer" ) );
+        GameRegistry.registerTileEntity( TileDiskDrive.class, new ResourceLocation( ComputerCraft.MOD_ID, "diskdrive" ) );
+        GameRegistry.registerTileEntity( TileWirelessModem.class, new ResourceLocation( ComputerCraft.MOD_ID, "wirelessmodem" ) );
+        GameRegistry.registerTileEntity( TileMonitor.class, new ResourceLocation( ComputerCraft.MOD_ID, "monitor" ) );
+        GameRegistry.registerTileEntity( TilePrinter.class, new ResourceLocation( ComputerCraft.MOD_ID, "ccprinter" ) );
+        GameRegistry.registerTileEntity( TileCable.class, new ResourceLocation( ComputerCraft.MOD_ID, "wiredmodem" ) );
+        GameRegistry.registerTileEntity( TileCommandComputer.class, new ResourceLocation( ComputerCraft.MOD_ID, "command_computer" ) );
+        GameRegistry.registerTileEntity( TileAdvancedModem.class, new ResourceLocation( ComputerCraft.MOD_ID, "advanced_modem" ) );
+        GameRegistry.registerTileEntity( TileSpeaker.class, new ResourceLocation( ComputerCraft.MOD_ID, "speaker" ) );
+        GameRegistry.registerTileEntity( TileWiredModemFull.class, new ResourceLocation( ComputerCraft.MOD_ID, "wired_modem_full" ) );
 
         // Register peripheral providers
         ComputerCraftAPI.registerPeripheralProvider( new DefaultPeripheralProvider() );

src/main/java/dan200/computercraft/shared/proxy/ICCTurtleProxy.java

@@ -7,12 +7,16 @@
 package dan200.computercraft.shared.proxy;
 
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.shared.util.IEntityDropConsumer;
 import net.minecraft.entity.Entity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
 
 import javax.annotation.Nonnull;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
 
 public interface ICCTurtleProxy
 {
@@ -25,6 +29,7 @@ public interface ICCTurtleProxy
     ITurtleUpgrade getTurtleUpgrade( @Nonnull ItemStack item );
     void addAllUpgradedTurtles( NonNullList<ItemStack> list );
 
-    void setEntityDropConsumer( Entity entity, IEntityDropConsumer consumer );
-    void clearEntityDropConsumer( Entity entity );
+    void setDropConsumer( Entity entity, Function<ItemStack, ItemStack> consumer );
+    void setDropConsumer( World world, BlockPos pos, Function<ItemStack, ItemStack> consumer );
+    List<ItemStack> clearDropConsumer();
 }