diff --git a/assets/opencomputers/lang/de_DE.lang b/assets/opencomputers/lang/de_DE.lang
index 2de97ffb4..273cd974c 100644
--- a/assets/opencomputers/lang/de_DE.lang
+++ b/assets/opencomputers/lang/de_DE.lang
@@ -2,11 +2,16 @@ oc.block.Adapter.name=Adapter
 oc.block.Computer.name=Computer
 oc.block.DiskDrive.name=Diskettenlaufwerk
 oc.block.Keyboard.name=Tastatur
-oc.block.Screen.name=Bildschirm
+oc.block.ScreenAdvanced.name=Hochwertiger Bildschirm
+oc.block.ScreenBasic.name=Einfacher Bildschirm
+oc.block.ScreenProfessional.name=Professioneller Bildschirm
 oc.container.Computer=Computer
 oc.container.DiskDrive=Diskettenlaufwerk
 oc.item.Disk.name=Diskette
-oc.item.GraphicsCard.name=Grafikkarte
+oc.item.GraphicsCard.name=
+oc.item.GraphicsCardAdvanced.name=Hochwertige Grafikkarte
+oc.item.GraphicsCardBasic.name=Einfache Grafikkarte
+oc.item.GraphicsCardProfessional.name=Professionelle Grafikkarte
 oc.item.HardDiskDrive2m.name=Festplatte (2MB)
 oc.item.HardDiskDrive4m.name=Festplatte (4MB)
 oc.item.HardDiskDrive8m.name=Festplatte (8MB)
diff --git a/assets/opencomputers/lang/en_US.lang b/assets/opencomputers/lang/en_US.lang
index 025b57cf9..8c5d336f6 100644
--- a/assets/opencomputers/lang/en_US.lang
+++ b/assets/opencomputers/lang/en_US.lang
@@ -2,11 +2,15 @@ oc.block.Adapter.name=Adapter
 oc.block.Computer.name=Computer
 oc.block.DiskDrive.name=Disk Drive
 oc.block.Keyboard.name=Keyboard
-oc.block.Screen.name=Screen
+oc.block.ScreenAdvanced.name=Advanced Screen
+oc.block.ScreenBasic.name=Basic Screen
+oc.block.ScreenProfessional.name=Professional Screen
 oc.container.Computer=Computer
 oc.container.DiskDrive=Disk Drive
 oc.item.Disk.name=Floppy Disk
-oc.item.GraphicsCard.name=Graphics Card
+oc.item.GraphicsCardAdvanced.name=Advanced Graphics Card
+oc.item.GraphicsCardBasic.name=Basic Graphics Card
+oc.item.GraphicsCardProfessional.name=Professional Graphics Card
 oc.item.HardDiskDrive2m.name=Hard Disk Drive (2MB)
 oc.item.HardDiskDrive4m.name=Hard Disk Drive (4MB)
 oc.item.HardDiskDrive8m.name=Hard Disk Drive (8MB)
diff --git a/assets/opencomputers/textures/blocks/screen/b.png b/assets/opencomputers/textures/blocks/screen/b.png
index 3f8aa24b3..11858ab2e 100644
Binary files a/assets/opencomputers/textures/blocks/screen/b.png and b/assets/opencomputers/textures/blocks/screen/b.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/b2.png b/assets/opencomputers/textures/blocks/screen/b2.png
index 4386ba12e..7a6b1d0c7 100644
Binary files a/assets/opencomputers/textures/blocks/screen/b2.png and b/assets/opencomputers/textures/blocks/screen/b2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bbl.png b/assets/opencomputers/textures/blocks/screen/bbl.png
index a8a3a2b36..db34901d0 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bbl.png and b/assets/opencomputers/textures/blocks/screen/bbl.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bbl2.png b/assets/opencomputers/textures/blocks/screen/bbl2.png
index 66217ed0d..368af8987 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bbl2.png and b/assets/opencomputers/textures/blocks/screen/bbl2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bbm.png b/assets/opencomputers/textures/blocks/screen/bbm.png
index 2a14f8493..e42cd3934 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bbm.png and b/assets/opencomputers/textures/blocks/screen/bbm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bbm2.png b/assets/opencomputers/textures/blocks/screen/bbm2.png
index c7fd84d9e..692280ed6 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bbm2.png and b/assets/opencomputers/textures/blocks/screen/bbm2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bbr.png b/assets/opencomputers/textures/blocks/screen/bbr.png
index 6418d1520..b6fa85988 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bbr.png and b/assets/opencomputers/textures/blocks/screen/bbr.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bbr2.png b/assets/opencomputers/textures/blocks/screen/bbr2.png
index daedd6c37..f8ee4cc38 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bbr2.png and b/assets/opencomputers/textures/blocks/screen/bbr2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bhb.png b/assets/opencomputers/textures/blocks/screen/bhb.png
index 6506260ea..62f59d542 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bhb.png and b/assets/opencomputers/textures/blocks/screen/bhb.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bhb2.png b/assets/opencomputers/textures/blocks/screen/bhb2.png
index 4d701c024..c1a3548d0 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bhb2.png and b/assets/opencomputers/textures/blocks/screen/bhb2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bhm.png b/assets/opencomputers/textures/blocks/screen/bhm.png
index c5c548666..f00f30c4e 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bhm.png and b/assets/opencomputers/textures/blocks/screen/bhm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bhm2.png b/assets/opencomputers/textures/blocks/screen/bhm2.png
index b6abbfa12..73a8b445b 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bhm2.png and b/assets/opencomputers/textures/blocks/screen/bhm2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bht.png b/assets/opencomputers/textures/blocks/screen/bht.png
index 5173c4e67..dccfcfb50 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bht.png and b/assets/opencomputers/textures/blocks/screen/bht.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bht2.png b/assets/opencomputers/textures/blocks/screen/bht2.png
index 65ff0ee1e..4f61bd4bd 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bht2.png and b/assets/opencomputers/textures/blocks/screen/bht2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bml.png b/assets/opencomputers/textures/blocks/screen/bml.png
index 5c1650e88..b69eb451e 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bml.png and b/assets/opencomputers/textures/blocks/screen/bml.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bmm.png b/assets/opencomputers/textures/blocks/screen/bmm.png
index bfcb4069b..643c5579f 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bmm.png and b/assets/opencomputers/textures/blocks/screen/bmm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bmr.png b/assets/opencomputers/textures/blocks/screen/bmr.png
index 7002b116a..5725153fe 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bmr.png and b/assets/opencomputers/textures/blocks/screen/bmr.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/btl.png b/assets/opencomputers/textures/blocks/screen/btl.png
index 6db340a18..aa2f9633f 100644
Binary files a/assets/opencomputers/textures/blocks/screen/btl.png and b/assets/opencomputers/textures/blocks/screen/btl.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/btm.png b/assets/opencomputers/textures/blocks/screen/btm.png
index 7c66aa89b..e8f0dc38c 100644
Binary files a/assets/opencomputers/textures/blocks/screen/btm.png and b/assets/opencomputers/textures/blocks/screen/btm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/btr.png b/assets/opencomputers/textures/blocks/screen/btr.png
index bef5b2143..a2fbe0690 100644
Binary files a/assets/opencomputers/textures/blocks/screen/btr.png and b/assets/opencomputers/textures/blocks/screen/btr.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bvb.png b/assets/opencomputers/textures/blocks/screen/bvb.png
index 3d98bab66..13aa7468e 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bvb.png and b/assets/opencomputers/textures/blocks/screen/bvb.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bvb2.png b/assets/opencomputers/textures/blocks/screen/bvb2.png
index aa3348131..74ae7587c 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bvb2.png and b/assets/opencomputers/textures/blocks/screen/bvb2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bvm.png b/assets/opencomputers/textures/blocks/screen/bvm.png
index 36f8028fb..b676b2fd0 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bvm.png and b/assets/opencomputers/textures/blocks/screen/bvm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/bvt.png b/assets/opencomputers/textures/blocks/screen/bvt.png
index 052aca50b..b9eb6b1f7 100644
Binary files a/assets/opencomputers/textures/blocks/screen/bvt.png and b/assets/opencomputers/textures/blocks/screen/bvt.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/f.png b/assets/opencomputers/textures/blocks/screen/f.png
index dad625015..706dab65f 100644
Binary files a/assets/opencomputers/textures/blocks/screen/f.png and b/assets/opencomputers/textures/blocks/screen/f.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/f2.png b/assets/opencomputers/textures/blocks/screen/f2.png
index f1967ecd5..f2a6656fe 100644
Binary files a/assets/opencomputers/textures/blocks/screen/f2.png and b/assets/opencomputers/textures/blocks/screen/f2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fbl.png b/assets/opencomputers/textures/blocks/screen/fbl.png
index 68ebc653e..e3a8d7fcf 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fbl.png and b/assets/opencomputers/textures/blocks/screen/fbl.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fbl2.png b/assets/opencomputers/textures/blocks/screen/fbl2.png
index 6691c3e3c..752b93f7e 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fbl2.png and b/assets/opencomputers/textures/blocks/screen/fbl2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fbm.png b/assets/opencomputers/textures/blocks/screen/fbm.png
index 2c3ebb541..4102512f3 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fbm.png and b/assets/opencomputers/textures/blocks/screen/fbm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fbm2.png b/assets/opencomputers/textures/blocks/screen/fbm2.png
index 85ca1a582..1db3e077e 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fbm2.png and b/assets/opencomputers/textures/blocks/screen/fbm2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fbr.png b/assets/opencomputers/textures/blocks/screen/fbr.png
index f4ace4b2b..21d63aa0f 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fbr.png and b/assets/opencomputers/textures/blocks/screen/fbr.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fbr2.png b/assets/opencomputers/textures/blocks/screen/fbr2.png
index 8991dc092..41ec09967 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fbr2.png and b/assets/opencomputers/textures/blocks/screen/fbr2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fhb.png b/assets/opencomputers/textures/blocks/screen/fhb.png
index 55e2c1ec2..783d298ea 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fhb.png and b/assets/opencomputers/textures/blocks/screen/fhb.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fhb2.png b/assets/opencomputers/textures/blocks/screen/fhb2.png
index ffdb885aa..f812f0c87 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fhb2.png and b/assets/opencomputers/textures/blocks/screen/fhb2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fhm.png b/assets/opencomputers/textures/blocks/screen/fhm.png
index 7c9343578..fa7f6d77e 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fhm.png and b/assets/opencomputers/textures/blocks/screen/fhm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fhm2.png b/assets/opencomputers/textures/blocks/screen/fhm2.png
index c3ee2d667..0a18b6626 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fhm2.png and b/assets/opencomputers/textures/blocks/screen/fhm2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fht.png b/assets/opencomputers/textures/blocks/screen/fht.png
index c722c9ea9..ab617f205 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fht.png and b/assets/opencomputers/textures/blocks/screen/fht.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fht2.png b/assets/opencomputers/textures/blocks/screen/fht2.png
index 4865ae010..d4454aec6 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fht2.png and b/assets/opencomputers/textures/blocks/screen/fht2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fml.png b/assets/opencomputers/textures/blocks/screen/fml.png
index 937cb6967..4bb0b98bb 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fml.png and b/assets/opencomputers/textures/blocks/screen/fml.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fmr.png b/assets/opencomputers/textures/blocks/screen/fmr.png
index 2759e1a20..2b8136fa4 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fmr.png and b/assets/opencomputers/textures/blocks/screen/fmr.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/ftl.png b/assets/opencomputers/textures/blocks/screen/ftl.png
index 207aced9b..2437c84c3 100644
Binary files a/assets/opencomputers/textures/blocks/screen/ftl.png and b/assets/opencomputers/textures/blocks/screen/ftl.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/ftm.png b/assets/opencomputers/textures/blocks/screen/ftm.png
index 326d5433f..e8ccc65ec 100644
Binary files a/assets/opencomputers/textures/blocks/screen/ftm.png and b/assets/opencomputers/textures/blocks/screen/ftm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/ftr.png b/assets/opencomputers/textures/blocks/screen/ftr.png
index f81c8bde4..60ca5747c 100644
Binary files a/assets/opencomputers/textures/blocks/screen/ftr.png and b/assets/opencomputers/textures/blocks/screen/ftr.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fvb.png b/assets/opencomputers/textures/blocks/screen/fvb.png
index 98b9a2924..f2dcbc3ff 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fvb.png and b/assets/opencomputers/textures/blocks/screen/fvb.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fvb2.png b/assets/opencomputers/textures/blocks/screen/fvb2.png
index 7d17c551b..057db2243 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fvb2.png and b/assets/opencomputers/textures/blocks/screen/fvb2.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fvm.png b/assets/opencomputers/textures/blocks/screen/fvm.png
index 2808d8f07..5c6d9c139 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fvm.png and b/assets/opencomputers/textures/blocks/screen/fvm.png differ
diff --git a/assets/opencomputers/textures/blocks/screen/fvt.png b/assets/opencomputers/textures/blocks/screen/fvt.png
index b99c74d6c..44cc33307 100644
Binary files a/assets/opencomputers/textures/blocks/screen/fvt.png and b/assets/opencomputers/textures/blocks/screen/fvt.png differ
diff --git a/assets/opencomputers/textures/items/gpu.png b/assets/opencomputers/textures/items/gpu0.png
similarity index 100%
rename from assets/opencomputers/textures/items/gpu.png
rename to assets/opencomputers/textures/items/gpu0.png
diff --git a/assets/opencomputers/textures/items/gpu1.png b/assets/opencomputers/textures/items/gpu1.png
new file mode 100644
index 000000000..e248eb1a9
Binary files /dev/null and b/assets/opencomputers/textures/items/gpu1.png differ
diff --git a/assets/opencomputers/textures/items/gpu2.png b/assets/opencomputers/textures/items/gpu2.png
new file mode 100644
index 000000000..166023ead
Binary files /dev/null and b/assets/opencomputers/textures/items/gpu2.png differ
diff --git a/li/cil/oc/Blocks.scala b/li/cil/oc/Blocks.scala
index 4310ba5b8..f7fd22769 100644
--- a/li/cil/oc/Blocks.scala
+++ b/li/cil/oc/Blocks.scala
@@ -7,7 +7,7 @@ object Blocks {
   var blockSpecial: SpecialDelegator = null
 
   var computer: Computer = null
-  var screen: Screen = null
+  var screen1, screen2, screen3: Screen = null
   var keyboard: Keyboard = null
 
   var powerSupply: PowerSupply = null
@@ -24,7 +24,11 @@ object Blocks {
     blockSpecial = new SpecialDelegator(Config.blockSpecialId)
 
     computer = new Computer(blockSimple)
-    screen = new Screen(blockSimple)
+
+    screen1 = new ScreenTier1(blockSimple)
+    screen2 = new ScreenTier2(blockSimple)
+    screen3 = new ScreenTier3(blockSimple)
+
     keyboard = new Keyboard(blockSpecial)
 
     powerSupply = new PowerSupply(blockSimple)
diff --git a/li/cil/oc/Config.scala b/li/cil/oc/Config.scala
index e3abb954d..99c409aca 100644
--- a/li/cil/oc/Config.scala
+++ b/li/cil/oc/Config.scala
@@ -8,6 +8,13 @@ object Config {
   val scriptPath = "/assets/" + resourceDomain + "/lua/"
   val driverPath = "/assets/" + resourceDomain + "/lua/drivers/"
 
+  // Let's stick to "common" ratios of 4:3 and 16:9, pixel wise. Corrected
+  // for the font size that's 2.4:1 and 3.2:1.
+  val screenResolutionsByTier = Array(
+    List((40, 16)),
+    List((40, 16), (60, 25), (80, 25)),
+    List((40, 16), (60, 25), (80, 25), (120, 50), (160, 50)))
+
   // ----------------------------------------------------------------------- //
 
   var blockRenderId = 0
diff --git a/li/cil/oc/Items.scala b/li/cil/oc/Items.scala
index 9edd8c606..12c41bae1 100644
--- a/li/cil/oc/Items.scala
+++ b/li/cil/oc/Items.scala
@@ -5,10 +5,13 @@ import li.cil.oc.common.item
 object Items {
   var multi: item.Delegator = null
 
-  var gpu: item.GraphicsCard = null
   var rs: item.RedstoneCard = null
   var lan: item.NetworkCard = null
 
+  var gpu1: item.GraphicsCard = null
+  var gpu2: item.GraphicsCard = null
+  var gpu3: item.GraphicsCard = null
+
   var ram1: item.Memory = null
   var ram2: item.Memory = null
   var ram3: item.Memory = null
@@ -21,10 +24,13 @@ object Items {
   def init() {
     multi = new item.Delegator(Config.itemId)
 
-    gpu = new item.GraphicsCard(multi)
     rs = new item.RedstoneCard(multi)
     lan = new item.NetworkCard(multi)
 
+    gpu1 = new item.GraphicsCard(multi, 0)
+    gpu2 = new item.GraphicsCard(multi, 1)
+    gpu3 = new item.GraphicsCard(multi, 2)
+
     ram1 = new item.Memory(multi, 32)
     ram2 = new item.Memory(multi, 64)
     ram3 = new item.Memory(multi, 128)
diff --git a/li/cil/oc/client/PacketHandler.scala b/li/cil/oc/client/PacketHandler.scala
index d0deb327f..a8a260270 100644
--- a/li/cil/oc/client/PacketHandler.scala
+++ b/li/cil/oc/client/PacketHandler.scala
@@ -33,41 +33,40 @@ class PacketHandler extends CommonPacketHandler {
 
   def onScreenResolutionChange(p: PacketParser) =
     p.readTileEntity[Screen]() match {
-      case None => // Invalid packet.
       case Some(t) => {
         val w = p.readInt()
         val h = p.readInt()
-        t.screen.resolution = (w, h)
+        t.instance.resolution = (w, h)
       }
+      case _ => // Invalid packet.
     }
 
   def onScreenSet(p: PacketParser) =
     p.readTileEntity[Screen]() match {
-      case None => // Invalid packet.
       case Some(t) => {
         val col = p.readInt()
         val row = p.readInt()
         val s = p.readUTF()
-        t.screen.set(col, row, s)
+        t.instance.set(col, row, s)
       }
+      case _ => // Invalid packet.
     }
 
   def onScreenFill(p: PacketParser) =
     p.readTileEntity[Screen]() match {
-      case None => // Invalid packet.
       case Some(t) => {
         val col = p.readInt()
         val row = p.readInt()
         val w = p.readInt()
         val h = p.readInt()
         val c = p.readChar()
-        t.screen.fill(col, row, w, h, c)
+        t.instance.fill(col, row, w, h, c)
       }
+      case _ => // Invalid packet.
     }
 
   def onScreenCopy(p: PacketParser) =
     p.readTileEntity[Screen]() match {
-      case None => // Invalid packet.
       case Some(t) => {
         val col = p.readInt()
         val row = p.readInt()
@@ -75,42 +74,46 @@ class PacketHandler extends CommonPacketHandler {
         val h = p.readInt()
         val tx = p.readInt()
         val ty = p.readInt()
-        t.screen.copy(col, row, w, h, tx, ty)
+        t.instance.copy(col, row, w, h, tx, ty)
       }
+      case _ => // Invalid packet.
     }
 
   def onScreenBufferResponse(p: PacketParser) =
     p.readTileEntity[Screen]() match {
-      case None => // Invalid packet.
       case Some(t) =>
+        val w = p.readInt()
+        val h = p.readInt()
+        t.instance.resolution = (w, h)
         p.readUTF.split('\n').zipWithIndex.foreach {
-          case (line, i) => t.screen.set(0, i, line)
+          case (line, i) => t.instance.set(0, i, line)
         }
+      case _ => // Invalid packet.
     }
 
   def onComputerStateResponse(p: PacketParser) =
     p.readTileEntity[Computer]() match {
-      case None => // Invalid packet.
       case Some(t) => {
         t.isOn = p.readBoolean()
       }
+      case _ => // Invalid packet.
     }
 
   def onRotatableStateResponse(p: PacketParser) =
     p.readTileEntity[Rotatable]() match {
-      case None => // Invalid packet.
       case Some(t) =>
         t.pitch = p.readDirection()
         t.yaw = p.readDirection()
+      case _ => // Invalid packet.
     }
 
   def onRedstoneStateResponse(p: PacketParser) =
     p.readTileEntity[TileEntity with Redstone]() match {
-      case None => // Invalid packet.
       case Some(t) =>
         t.isOutputEnabled = p.readBoolean()
         for (d <- ForgeDirection.VALID_DIRECTIONS) {
           t.output(d, p.readByte())
         }
+      case _ => // Invalid packet.
     }
 }
\ No newline at end of file
diff --git a/li/cil/oc/client/gui/Screen.scala b/li/cil/oc/client/gui/Screen.scala
index 83af09ccd..65e666921 100644
--- a/li/cil/oc/client/gui/Screen.scala
+++ b/li/cil/oc/client/gui/Screen.scala
@@ -47,11 +47,11 @@ class Screen(tileEntity: tileentity.Screen) extends MCGuiScreen {
 
     // Re-build display lists.
     Screen.compileBackground(innerWidth, innerHeight)
-    Screen.compileText(scale, screen.screen.lines)
+    Screen.compileText(scale, screen.instance.lines)
   }
 
   /** Must be called whenever the buffer of the underlying screen changes. */
-  def updateText() = Screen.compileText(scale, screen.screen.lines)
+  def updateText() = Screen.compileText(scale, screen.instance.lines)
 
   override def handleKeyboardInput() {
     super.handleKeyboardInput()
@@ -83,7 +83,7 @@ class Screen(tileEntity: tileentity.Screen) extends MCGuiScreen {
     super.initGui()
     MonospaceFontRenderer.init(mc.renderEngine)
     Screen.init(mc.renderEngine)
-    val (w, h) = screen.screen.resolution
+    val (w, h) = screen.instance.resolution
     changeSize(w, h)
   }
 
diff --git a/li/cil/oc/client/renderer/tileentity/ScreenRenderer.scala b/li/cil/oc/client/renderer/tileentity/ScreenRenderer.scala
index dfd5bb5ac..8c7550f9d 100644
--- a/li/cil/oc/client/renderer/tileentity/ScreenRenderer.scala
+++ b/li/cil/oc/client/renderer/tileentity/ScreenRenderer.scala
@@ -114,13 +114,13 @@ object ScreenRenderer extends TileEntitySpecialRenderer with Callable[Int] with
     GL11.glTranslatef(0, 0, 0.01f)
 
     // Scale based on actual buffer size.
-    val (w, h) = screen.screen.resolution
+    val (w, h) = screen.instance.resolution
     val scaleX = sx.toFloat / (w * MonospaceFontRenderer.fontWidth)
     val scaleY = sy.toFloat / (h * MonospaceFontRenderer.fontHeight)
     val scale = scaleX min scaleY
     GL11.glScalef(scale / sx.toFloat, scale / sy.toFloat, 1)
 
-    for ((line, i) <- screen.screen.lines.zipWithIndex) {
+    for ((line, i) <- screen.instance.lines.zipWithIndex) {
       MonospaceFontRenderer.drawString(line, 0, i * MonospaceFontRenderer.fontHeight)
     }
 
diff --git a/li/cil/oc/common/block/Adapter.scala b/li/cil/oc/common/block/Adapter.scala
index 2d6003a1a..bebe6621f 100644
--- a/li/cil/oc/common/block/Adapter.scala
+++ b/li/cil/oc/common/block/Adapter.scala
@@ -37,7 +37,7 @@ class Adapter(val parent: SimpleDelegator) extends SimpleDelegate {
 
   override def hasTileEntity = true
 
-  override def createTileEntity(world: World, metadata: Int) = Some(new tileentity.Adapter)
+  override def createTileEntity(world: World) = Some(new tileentity.Adapter)
 
   // ----------------------------------------------------------------------- //
   // Block detection
diff --git a/li/cil/oc/common/block/Computer.scala b/li/cil/oc/common/block/Computer.scala
index 4dd310603..bce4bc32b 100644
--- a/li/cil/oc/common/block/Computer.scala
+++ b/li/cil/oc/common/block/Computer.scala
@@ -57,7 +57,7 @@ class Computer(val parent: SimpleDelegator) extends SimpleDelegate {
 
   override def hasTileEntity = true
 
-  override def createTileEntity(world: World, metadata: Int) = Some(new tileentity.Computer(world.isRemote))
+  override def createTileEntity(world: World) = Some(new tileentity.Computer(world.isRemote))
 
   // ----------------------------------------------------------------------- //
 
@@ -70,7 +70,7 @@ class Computer(val parent: SimpleDelegator) extends SimpleDelegate {
   override def isProvidingWeakPower(world: IBlockAccess, x: Int, y: Int, z: Int, side: ForgeDirection) =
     world.getBlockTileEntity(x, y, z).asInstanceOf[tileentity.Computer].output(side)
 
-  override def onBlockPreDestroy(world: World, x: Int, y: Int, z: Int, metadata: Int) =
+  override def onBlockPreDestroy(world: World, x: Int, y: Int, z: Int) =
     if (!world.isRemote) world.getBlockTileEntity(x, y, z) match {
       case computer: tileentity.Computer =>
         computer.turnOff()
diff --git a/li/cil/oc/common/block/Delegate.scala b/li/cil/oc/common/block/Delegate.scala
index c11c3ac64..9dc68f709 100644
--- a/li/cil/oc/common/block/Delegate.scala
+++ b/li/cil/oc/common/block/Delegate.scala
@@ -19,18 +19,21 @@ trait Delegate {
   // Block
   // ----------------------------------------------------------------------- //
 
-  def breakBlock(world: World, x: Int, y: Int, z: Int, blockId: Int, metadata: Int) {}
+  def breakBlock(world: World, x: Int, y: Int, z: Int, blockId: Int) {}
 
   def canConnectRedstone(world: IBlockAccess, x: Int, y: Int, z: Int, side: ForgeDirection) = false
 
-  def createTileEntity(world: World, metadata: Int): Option[TileEntity] = None
+  def colorMultiplier(world: IBlockAccess, x: Int, y: Int, z: Int) = getRenderColor
 
-  def getBlockTextureFromSide(world: IBlockAccess, x: Int, y: Int, z: Int, worldSide: ForgeDirection, localSide: ForgeDirection): Option[Icon] = icon(localSide)
+  def createTileEntity(world: World): Option[TileEntity] = None
+
+  def getBlockTextureFromSide(world: IBlockAccess, x: Int, y: Int, z: Int,
+                              worldSide: ForgeDirection, localSide: ForgeDirection): Option[Icon] = icon(localSide)
 
   def getCollisionBoundingBoxFromPool(world: World, x: Int, y: Int, z: Int) =
     AxisAlignedBB.getAABBPool.getAABB(x, y, z, x + 1, y + 1, z + 1)
 
-  def icon(side: ForgeDirection): Option[Icon] = None
+  def getRenderColor = 0xFFFFFF
 
   def getLightOpacity(world: World, x: Int, y: Int, z: Int) = 255
 
@@ -40,6 +43,8 @@ trait Delegate {
 
   def hasTileEntity = false
 
+  def icon(side: ForgeDirection): Option[Icon] = None
+
   def isProvidingStrongPower(world: IBlockAccess, x: Int, y: Int, z: Int, side: ForgeDirection) = 0
 
   def isProvidingWeakPower(world: IBlockAccess, x: Int, y: Int, z: Int, side: ForgeDirection) = 0
@@ -50,7 +55,7 @@ trait Delegate {
 
   def onBlockPlacedBy(world: World, x: Int, y: Int, z: Int, player: EntityLivingBase, item: ItemStack) {}
 
-  def onBlockPreDestroy(world: World, x: Int, y: Int, z: Int, metadata: Int) {}
+  def onBlockPreDestroy(world: World, x: Int, y: Int, z: Int) {}
 
   def onBlockRemovedBy(world: World, x: Int, y: Int, z: Int, player: EntityPlayer) = true
 
diff --git a/li/cil/oc/common/block/Delegator.scala b/li/cil/oc/common/block/Delegator.scala
index 0d0c59834..18395bee0 100644
--- a/li/cil/oc/common/block/Delegator.scala
+++ b/li/cil/oc/common/block/Delegator.scala
@@ -101,23 +101,34 @@ class Delegator[Child <: Delegate](id: Int) extends Block(id, Material.iron) {
 
   override def breakBlock(world: World, x: Int, y: Int, z: Int, blockId: Int, metadata: Int) = {
     subBlock(metadata) match {
-      case None => // Invalid but avoid match error.
       case Some(subBlock) => {
         world.getBlockTileEntity(x, y, z) match {
           case node: Node => node.network.foreach(_.remove(node))
           case _ => // Nothing special to do.
         }
-        subBlock.breakBlock(world, x, y, z, blockId, metadata)
+        subBlock.breakBlock(world, x, y, z, blockId)
       }
+      case _ => // Invalid but avoid match error.
     }
     super.breakBlock(world, x, y, z, blockId, metadata)
   }
 
+  override def getRenderColor(metadata: Int) =
+    subBlock(metadata) match {
+      case Some(subBlock) => subBlock.getRenderColor
+      case _ => super.getRenderColor(metadata)
+    }
+
+  override def colorMultiplier(world: IBlockAccess, x: Int, y: Int, z: Int) =
+    subBlock(world, x, y, z) match {
+      case Some(subBlock) => subBlock.colorMultiplier(world, x, y, z)
+      case _ => super.colorMultiplier(world, x, y, z)
+    }
+
   override def getDamageValue(world: World, x: Int, y: Int, z: Int) = world.getBlockMetadata(x, y, z)
 
   override def canConnectRedstone(world: IBlockAccess, x: Int, y: Int, z: Int, side: Int) =
     subBlock(world, x, y, z) match {
-      case None => false
       case Some(subBlock) => subBlock.canConnectRedstone(
         world, x, y, z, toLocal(world, x, y, z, side match {
           case -1 => ForgeDirection.UP
@@ -126,53 +137,54 @@ class Delegator[Child <: Delegate](id: Int) extends Block(id, Material.iron) {
           case 2 => ForgeDirection.SOUTH
           case 3 => ForgeDirection.WEST
         }))
+      case _ => false
     }
 
   override def canProvidePower = true
 
   override def createTileEntity(world: World, metadata: Int): TileEntity =
     subBlock(metadata) match {
-      case None => null
-      case Some(subBlock) => subBlock.createTileEntity(world, metadata).orNull
+      case Some(subBlock) => subBlock.createTileEntity(world).orNull
+      case _ => null
     }
 
   override def getCollisionBoundingBoxFromPool(world: World, x: Int, y: Int, z: Int) =
     subBlock(world, x, y, z) match {
-      case None => super.getCollisionBoundingBoxFromPool(world, x, y, z)
       // TODO Rotate to world space if we have a Rotatable?
       case Some(subBlock) => subBlock.getCollisionBoundingBoxFromPool(world, x, y, z)
+      case _ => super.getCollisionBoundingBoxFromPool(world, x, y, z)
     }
 
   override def getBlockTexture(world: IBlockAccess, x: Int, y: Int, z: Int, side: Int) =
     subBlock(world, x, y, z) match {
-      case None => super.getBlockTexture(world, x, y, z, side)
       case Some(subBlock) =>
         val orientation = ForgeDirection.getOrientation(side)
         subBlock.getBlockTextureFromSide(world, x, y, z, orientation, toLocal(world, x, y, z, orientation)) match {
-          case None => super.getBlockTexture(world, x, y, z, side)
           case Some(icon) => icon
+          case _ => super.getBlockTexture(world, x, y, z, side)
         }
+      case _ => super.getBlockTexture(world, x, y, z, side)
     }
 
   override def getLightValue(world: IBlockAccess, x: Int, y: Int, z: Int) =
     subBlock(world, x, y, z) match {
-      case None => 0
       case Some(subBlock) => subBlock.getLightValue(world, x, y, z)
+      case _ => 0
     }
 
   override def getIcon(side: Int, metadata: Int) =
     subBlock(metadata) match {
-      case None => super.getIcon(side, metadata)
       case Some(subBlock) => subBlock.icon(ForgeDirection.getOrientation(side)) match {
-        case None => super.getIcon(side, metadata)
         case Some(icon) => icon
+        case _ => super.getIcon(side, metadata)
       }
+      case _ => super.getIcon(side, metadata)
     }
 
   override def getLightOpacity(world: World, x: Int, y: Int, z: Int) =
     subBlock(world, x, y, z) match {
-      case None => 255
       case Some(subBlock) => subBlock.getLightOpacity(world, x, y, z)
+      case _ => 255
     }
 
   override def getSubBlocks(itemId: Int, creativeTab: CreativeTabs, list: util.List[_]) = {
@@ -186,33 +198,33 @@ class Delegator[Child <: Delegate](id: Int) extends Block(id, Material.iron) {
 
   def getUnlocalizedName(metadata: Int) =
     subBlock(metadata) match {
-      case None => "oc.block"
       case Some(subBlock) => subBlock.unlocalizedName
+      case _ => "oc.block"
     }
 
   override def getValidRotations(world: World, x: Int, y: Int, z: Int) =
     subBlock(world, x, y, z) match {
-      case None => super.getValidRotations(world, x, y, z)
       case Some(subBlock) => subBlock.getValidRotations(world, x, y, z)
+      case _ => super.getValidRotations(world, x, y, z)
     }
 
   override def hasTileEntity(metadata: Int) = subBlock(metadata) match {
-    case None => false
     case Some(subBlock) => subBlock.hasTileEntity
+    case _ => false
   }
 
   override def isProvidingStrongPower(world: IBlockAccess, x: Int, y: Int, z: Int, side: Int) =
     subBlock(world, x, y, z) match {
-      case None => 0
       case Some(subBlock) => subBlock.isProvidingStrongPower(
         world, x, y, z, toLocal(world, x, y, z, ForgeDirection.getOrientation(side).getOpposite))
+      case _ => 0
     }
 
   override def isProvidingWeakPower(world: IBlockAccess, x: Int, y: Int, z: Int, side: Int) =
     subBlock(world, x, y, z) match {
-      case None => 0
       case Some(subBlock) => subBlock.isProvidingWeakPower(
         world, x, y, z, toLocal(world, x, y, z, ForgeDirection.getOrientation(side).getOpposite))
+      case _ => 0
     }
 
   override def onBlockActivated(world: World, x: Int, y: Int, z: Int, player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float): Boolean = {
@@ -269,15 +281,14 @@ class Delegator[Child <: Delegate](id: Int) extends Block(id, Material.iron) {
 
     // No rotating tool in hand or can't rotate: activate the block.
     subBlock(world, x, y, z) match {
-      case None => false
       case Some(subBlock) => subBlock.onBlockActivated(
         world, x, y, z, player, ForgeDirection.getOrientation(side), hitX, hitY, hitZ)
+      case _ => false
     }
   }
 
   override def onBlockAdded(world: World, x: Int, y: Int, z: Int) =
     subBlock(world, x, y, z) match {
-      case None => // Invalid but avoid match error.
       case Some(subBlock) => {
         world.getBlockTileEntity(x, y, z) match {
           case _: Node => Network.joinOrCreateNetwork(world, x, y, z)
@@ -285,24 +296,25 @@ class Delegator[Child <: Delegate](id: Int) extends Block(id, Material.iron) {
         }
         subBlock.onBlockAdded(world, x, y, z)
       }
+      case _ => // Invalid but avoid match error.
     }
 
   override def onBlockPlacedBy(world: World, x: Int, y: Int, z: Int, player: EntityLivingBase, item: ItemStack) =
     subBlock(world, x, y, z) match {
-      case None => // Invalid but avoid match error.
       case Some(subBlock) => subBlock.onBlockPlacedBy(world, x, y, z, player, item)
+      case _ => // Invalid but avoid match error.
     }
 
   override def onBlockPreDestroy(world: World, x: Int, y: Int, z: Int, metadata: Int) =
     subBlock(world, x, y, z) match {
-      case None => // Invalid but avoid match error.
-      case Some(subBlock) => subBlock.onBlockPreDestroy(world, x, y, z, metadata)
+      case Some(subBlock) => subBlock.onBlockPreDestroy(world, x, y, z)
+      case _ => // Invalid but avoid match error.
     }
 
   override def onNeighborBlockChange(world: World, x: Int, y: Int, z: Int, blockId: Int) =
     subBlock(world, x, y, z) match {
-      case None => // Invalid but avoid match error.
       case Some(subBlock) => subBlock.onNeighborBlockChange(world, x, y, z, blockId)
+      case _ => // Invalid but avoid match error.
     }
 
   override def registerIcons(iconRegister: IconRegister) = {
@@ -312,8 +324,8 @@ class Delegator[Child <: Delegate](id: Int) extends Block(id, Material.iron) {
 
   override def removeBlockByPlayer(world: World, player: EntityPlayer, x: Int, y: Int, z: Int) =
     (subBlock(world, x, y, z) match {
-      case None => true
       case Some(subBlock) => subBlock.onBlockRemovedBy(world, x, y, z, player)
+      case _ => true
     }) && super.removeBlockByPlayer(world, player, x, y, z)
 
   override def rotateBlock(world: World, x: Int, y: Int, z: Int, axis: ForgeDirection) = {
@@ -329,14 +341,14 @@ class SimpleDelegator(id: Int) extends Delegator[SimpleDelegate](id)
 class SpecialDelegator(id: Int) extends Delegator[SpecialDelegate](id) {
   override def isBlockNormalCube(world: World, x: Int, y: Int, z: Int) =
     subBlock(world.getBlockMetadata(x, y, z)) match {
-      case None => false
       case Some(subBlock) => subBlock.isBlockNormalCube(world, x, y, z)
+      case _ => false
     }
 
   override def isBlockSolid(world: IBlockAccess, x: Int, y: Int, z: Int, side: Int) =
     subBlock(world.getBlockMetadata(x, y, z)) match {
-      case None => true
       case Some(subBlock) => subBlock.isBlockSolid(world, x, y, z, ForgeDirection.getOrientation(side))
+      case _ => true
     }
 
   override def isOpaqueCube = false
@@ -345,7 +357,7 @@ class SpecialDelegator(id: Int) extends Delegator[SpecialDelegate](id) {
 
   override def shouldSideBeRendered(world: IBlockAccess, x: Int, y: Int, z: Int, side: Int) =
     subBlock(world.getBlockMetadata(x, y, z)) match {
-      case None => super.shouldSideBeRendered(world, x, y, z, side)
       case Some(subBlock) => subBlock.shouldSideBeRendered(world, x, y, z, ForgeDirection.getOrientation(side))
+      case _ => super.shouldSideBeRendered(world, x, y, z, side)
     }
 }
\ No newline at end of file
diff --git a/li/cil/oc/common/block/DiskDrive.scala b/li/cil/oc/common/block/DiskDrive.scala
index 430a360d8..4b0ffe2eb 100644
--- a/li/cil/oc/common/block/DiskDrive.scala
+++ b/li/cil/oc/common/block/DiskDrive.scala
@@ -34,16 +34,15 @@ class DiskDrive(val parent: SimpleDelegator) extends SimpleDelegate {
 
   override def hasTileEntity = true
 
-  override def createTileEntity(world: World, metadata: Int) = Some(new tileentity.DiskDrive)
+  override def createTileEntity(world: World) = Some(new tileentity.DiskDrive)
 
   // ----------------------------------------------------------------------- //
 
-  override def breakBlock(world: World, x: Int, y: Int, z: Int, blockId: Int, metadata: Int) = {
+  override def breakBlock(world: World, x: Int, y: Int, z: Int, blockId: Int) = {
     if (!world.isRemote) world.getBlockTileEntity(x, y, z) match {
       case drive: tileentity.DiskDrive => drive.dropContent(world, x, y, z)
       case _ => // Ignore.
     }
-    super.breakBlock(world, x, y, z, blockId, metadata)
   }
 
   override def onBlockActivated(world: World, x: Int, y: Int, z: Int, player: EntityPlayer,
diff --git a/li/cil/oc/common/block/Keyboard.scala b/li/cil/oc/common/block/Keyboard.scala
index 89e6e8884..93c53464c 100644
--- a/li/cil/oc/common/block/Keyboard.scala
+++ b/li/cil/oc/common/block/Keyboard.scala
@@ -11,5 +11,5 @@ class Keyboard(val parent: SpecialDelegator) extends SpecialDelegate {
 
   override def hasTileEntity = true
 
-  override def createTileEntity(world: World, metadata: Int) = Some(new tileentity.Keyboard)
+  override def createTileEntity(world: World) = Some(new tileentity.Keyboard)
 }
\ No newline at end of file
diff --git a/li/cil/oc/common/block/PowerDistributor.scala b/li/cil/oc/common/block/PowerDistributor.scala
index 1cf010cc0..9b3b28bd9 100644
--- a/li/cil/oc/common/block/PowerDistributor.scala
+++ b/li/cil/oc/common/block/PowerDistributor.scala
@@ -37,6 +37,6 @@ class PowerDistributor(val parent: SimpleDelegator) extends SimpleDelegate {
 
   override def hasTileEntity = true
 
-  override def createTileEntity(world: World, metadata: Int) = Some(new tileentity.PowerDistributor)
+  override def createTileEntity(world: World) = Some(new tileentity.PowerDistributor)
 }
 
diff --git a/li/cil/oc/common/block/PowerSupply.scala b/li/cil/oc/common/block/PowerSupply.scala
index 18852e534..fea73ea29 100644
--- a/li/cil/oc/common/block/PowerSupply.scala
+++ b/li/cil/oc/common/block/PowerSupply.scala
@@ -12,9 +12,8 @@ class PowerSupply(val parent: SimpleDelegator) extends SimpleDelegate {
   GameRegistry.registerTileEntity(classOf[tileentity.PowerSupply], "oc.powersupply")
   val unlocalizedName = "PowerSupply"
 
-  override def breakBlock(world: World, x: Int, y: Int, z: Int, blockId: Int, metadata: Int) = {
+  override def breakBlock(world: World, x: Int, y: Int, z: Int, blockId: Int) = {
     world.getBlockTileEntity(x, y, z).asInstanceOf[tileentity.PowerSupply].onUnload()
-    super.breakBlock(world, x, y, z, blockId, metadata)
   }
 
   // ----------------------------------------------------------------------- //
@@ -39,5 +38,5 @@ class PowerSupply(val parent: SimpleDelegator) extends SimpleDelegate {
 
   override def hasTileEntity = true
 
-  override def createTileEntity(world: World, metadata: Int) = Some(new tileentity.PowerSupply)
+  override def createTileEntity(world: World) = Some(new tileentity.PowerSupply)
 }
diff --git a/li/cil/oc/common/block/Screen.scala b/li/cil/oc/common/block/Screen.scala
index 97addc83b..b4e18c497 100644
--- a/li/cil/oc/common/block/Screen.scala
+++ b/li/cil/oc/common/block/Screen.scala
@@ -12,10 +12,37 @@ import net.minecraft.world.World
 import net.minecraftforge.common.ForgeDirection
 import sun.plugin.dom.exception.InvalidStateException
 
-class Screen(val parent: SimpleDelegator) extends SimpleDelegate {
-  GameRegistry.registerTileEntity(classOf[tileentity.Screen], "oc.screen")
+class ScreenTier1(parent: SimpleDelegator) extends Screen(parent) {
+  val unlocalizedName = "ScreenBasic"
 
-  val unlocalizedName = "Screen"
+  GameRegistry.registerTileEntity(classOf[tileentity.ScreenTier1], "oc.screen0")
+
+  override def getRenderColor = 0x7F7F7F
+
+  override def createTileEntity(world: World) = Some(new tileentity.ScreenTier1)
+}
+
+class ScreenTier2(parent: SimpleDelegator) extends Screen(parent) {
+  val unlocalizedName = "ScreenAdvanced"
+
+  GameRegistry.registerTileEntity(classOf[tileentity.ScreenTier2], "oc.screen1")
+
+  override def getRenderColor = 0xFFFF66
+
+  override def createTileEntity(world: World) = Some(new tileentity.ScreenTier2)
+}
+
+class ScreenTier3(parent: SimpleDelegator) extends Screen(parent) {
+  val unlocalizedName = "ScreenProfessional"
+
+  GameRegistry.registerTileEntity(classOf[tileentity.ScreenTier3], "oc.screen2")
+
+  override def getRenderColor = 0x66FFFF
+
+  override def createTileEntity(world: World) = Some(new tileentity.ScreenTier3)
+}
+
+abstract class Screen(val parent: SimpleDelegator) extends SimpleDelegate {
 
   // ----------------------------------------------------------------------- //
   // Rendering stuff
@@ -278,8 +305,6 @@ class Screen(val parent: SimpleDelegator) extends SimpleDelegate {
 
   override def hasTileEntity = true
 
-  override def createTileEntity(world: World, metadata: Int) = Some(new tileentity.Screen)
-
   // ----------------------------------------------------------------------- //
   // Interaction
   // ----------------------------------------------------------------------- //
diff --git a/li/cil/oc/common/component/Screen.scala b/li/cil/oc/common/component/Screen.scala
index bf686527d..e53a6c723 100644
--- a/li/cil/oc/common/component/Screen.scala
+++ b/li/cil/oc/common/component/Screen.scala
@@ -4,11 +4,10 @@ import li.cil.oc.api.Persistable
 import li.cil.oc.api.network.{Component, Message, Visibility}
 import li.cil.oc.util.TextBuffer
 import net.minecraft.nbt.NBTTagCompound
+import li.cil.oc.common.component
 
-class Screen(val owner: Screen.Environment) extends Persistable {
-  val supportedResolutions = List((40, 24), (80, 24))
-
-  private val buffer = new TextBuffer(80, 24)
+class Screen(val owner: Screen.Environment, val resolutions: List[(Int, Int)]) extends Persistable {
+  private val buffer = new TextBuffer(resolutions.head._1, resolutions.head._2)
 
   // ----------------------------------------------------------------------- //
 
@@ -19,7 +18,7 @@ class Screen(val owner: Screen.Environment) extends Persistable {
   def resolution = buffer.size
 
   def resolution_=(value: (Int, Int)) =
-    if (supportedResolutions.contains(value) && (buffer.size = value)) {
+    if (resolutions.contains(value) && (buffer.size = value)) {
       val (w, h) = value
       owner.onScreenResolutionChange(w, h)
       true
@@ -60,30 +59,32 @@ class Screen(val owner: Screen.Environment) extends Persistable {
 object Screen {
 
   trait Environment extends Component {
-    final val screen = new Screen(this)
+    final val instance = new component.Screen(this, resolutions)
 
     override val name = "screen"
 
     override val visibility = Visibility.Network
 
+    protected def resolutions: List[(Int, Int)]
+
     // ----------------------------------------------------------------------- //
 
     override def receive(message: Message): Option[Array[Any]] = super.receive(message).orElse {
       message.data match {
         case Array(w: Int, h: Int) if message.name == "screen.resolution=" =>
-          result(screen.resolution = (w, h))
+          result(instance.resolution = (w, h))
         case Array() if message.name == "screen.resolution" => {
-          val (w, h) = screen.resolution
+          val (w, h) = instance.resolution
           result(w, h)
         }
         case Array() if message.name == "screen.resolutions" =>
-          result(screen.supportedResolutions: _*)
+          result(instance.resolutions: _*)
         case Array(x: Int, y: Int, value: String) if message.name == "screen.set" =>
-          screen.set(x, y, value); None
+          instance.set(x, y, value); None
         case Array(x: Int, y: Int, w: Int, h: Int, value: Char) if message.name == "screen.fill" =>
-          screen.fill(x, y, w, h, value); None
+          instance.fill(x, y, w, h, value); None
         case Array(x: Int, y: Int, w: Int, h: Int, tx: Int, ty: Int) if message.name == "screen.copy" =>
-          screen.copy(x, y, w, h, tx, ty); None
+          instance.copy(x, y, w, h, tx, ty); None
         case _ => None
       }
     }
@@ -93,14 +94,14 @@ object Screen {
     override abstract def readFromNBT(nbt: NBTTagCompound) = {
       super.readFromNBT(nbt)
 
-      screen.readFromNBT(nbt.getCompoundTag("screen"))
+      instance.readFromNBT(nbt.getCompoundTag("screen"))
     }
 
     override abstract def writeToNBT(nbt: NBTTagCompound) = {
       super.writeToNBT(nbt)
 
       val screenNbt = new NBTTagCompound
-      screen.writeToNBT(screenNbt)
+      instance.writeToNBT(screenNbt)
       nbt.setCompoundTag("screen", screenNbt)
     }
 
diff --git a/li/cil/oc/common/item/GraphicsCard.scala b/li/cil/oc/common/item/GraphicsCard.scala
index 4892e63ff..c7b2742ac 100644
--- a/li/cil/oc/common/item/GraphicsCard.scala
+++ b/li/cil/oc/common/item/GraphicsCard.scala
@@ -3,12 +3,14 @@ package li.cil.oc.common.item
 import li.cil.oc.Config
 import net.minecraft.client.renderer.texture.IconRegister
 
-class GraphicsCard(val parent: Delegator) extends Delegate {
-  val unlocalizedName = "GraphicsCard"
+class GraphicsCard(val parent: Delegator, val tier: Int) extends Delegate {
+  val unlocalizedName = "GraphicsCard" + Array("Basic", "Advanced", "Professional").apply(tier)
+
+  val resolutions = Config.screenResolutionsByTier(tier)
 
   override def registerIcons(iconRegister: IconRegister) {
     super.registerIcons(iconRegister)
 
-    icon = iconRegister.registerIcon(Config.resourceDomain + ":gpu")
+    icon = iconRegister.registerIcon(Config.resourceDomain + ":gpu" + tier)
   }
 }
\ No newline at end of file
diff --git a/li/cil/oc/common/tileentity/Screen.scala b/li/cil/oc/common/tileentity/Screen.scala
index f73ce8107..19b0ae90c 100644
--- a/li/cil/oc/common/tileentity/Screen.scala
+++ b/li/cil/oc/common/tileentity/Screen.scala
@@ -12,7 +12,19 @@ import net.minecraft.util.AxisAlignedBB
 import net.minecraftforge.common.ForgeDirection
 import scala.collection.mutable
 
-class Screen extends Rotatable with component.Screen.Environment with Receiver {
+class ScreenTier1 extends Screen {
+  protected def resolutions = Config.screenResolutionsByTier(0)
+}
+
+class ScreenTier2 extends Screen {
+  protected def resolutions = Config.screenResolutionsByTier(1)
+}
+
+class ScreenTier3 extends Screen {
+  protected def resolutions = Config.screenResolutionsByTier(2)
+}
+
+abstract class Screen extends Rotatable with component.Screen.Environment with Receiver {
   var guiScreen: Option[gui.Screen] = None
 
   /**
@@ -29,6 +41,13 @@ class Screen extends Rotatable with component.Screen.Environment with Receiver {
    */
   private var shouldCheckForMultiBlock = true
 
+  private val ordering = new Ordering[Screen] {
+    def compare(a: Screen, b: Screen) =
+      if (a.xCoord != b.xCoord) a.xCoord - b.xCoord
+      else if (a.yCoord != b.yCoord) a.yCoord - b.yCoord
+      else a.zCoord - b.zCoord
+  }
+
   var width, height = 1
 
   var origin = this
@@ -90,7 +109,7 @@ class Screen extends Rotatable with component.Screen.Environment with Receiver {
       // any multi-block specific state information.
       // We use a very primitive hash for the coordinates, which should be
       // good enough for... "normal" screen sizes.
-      val pending = mutable.SortedSet(this)(Ordering[Int].on[Screen](s => (((23 + s.xCoord * 31) + s.yCoord) * 31) + s.zCoord))
+      val pending = mutable.SortedSet(this)(ordering)
       val queue = mutable.Queue(this)
       while (queue.nonEmpty) {
         val current = queue.dequeue()
@@ -127,7 +146,7 @@ class Screen extends Rotatable with component.Screen.Environment with Receiver {
           screen.componentVisibility = Visibility.Network
         else {
           screen.componentVisibility = Visibility.None
-          val s = screen.screen
+          val s = screen.instance
           val (w, h) = s.resolution
           s.fill(0, 0, w, h, ' ')
         }
@@ -148,7 +167,7 @@ class Screen extends Rotatable with component.Screen.Environment with Receiver {
     def tryMergeTowards(dx: Int, dy: Int) = {
       val (nx, ny, nz) = unproject(x + dx, y + dy, z)
       worldObj.getBlockTileEntity(nx, ny, nz) match {
-        case s: Screen if s.pitch == pitch && s.yaw == yaw && !screens.contains(s) =>
+        case s: Screen if s.resolutions == resolutions && s.pitch == pitch && s.yaw == yaw && !screens.contains(s) =>
           val (sx, sy, _) = project(s.origin)
           val canMergeAlongX = sy == y && s.height == height && s.width + width <= Config.maxScreenWidth
           val canMergeAlongY = sx == x && s.width == width && s.height + height <= Config.maxScreenHeight
diff --git a/li/cil/oc/server/PacketHandler.scala b/li/cil/oc/server/PacketHandler.scala
index cb85fd566..e5e0c1c3c 100644
--- a/li/cil/oc/server/PacketHandler.scala
+++ b/li/cil/oc/server/PacketHandler.scala
@@ -2,7 +2,6 @@ package li.cil.oc.server
 
 import cpw.mods.fml.common.network.Player
 import li.cil.oc.api.network.Node
-import li.cil.oc.common.PacketBuilder
 import li.cil.oc.common.PacketType
 import li.cil.oc.common.tileentity
 import li.cil.oc.common.{PacketHandler => CommonPacketHandler}
@@ -28,64 +27,59 @@ class PacketHandler extends CommonPacketHandler {
 
   def onScreenBufferRequest(p: PacketParser) =
     p.readTileEntity[tileentity.Screen]() match {
-      case None => // Invalid packet.
-      case Some(t) => {
-        val pb = new PacketBuilder(PacketType.ScreenBufferResponse)
-
-        pb.writeTileEntity(t)
-        pb.writeUTF(t.screen.text)
-
-        pb.sendToPlayer(p.player)
-      }
+      case Some(t) =>
+        val (w, h) = t.instance.resolution
+        PacketSender.sendScreenBufferState(t, w, h, t.instance.text, Option(p.player))
+      case _ => // Invalid packet.
     }
 
   def onComputerStateRequest(p: PacketParser) =
     p.readTileEntity[tileentity.Computer]() match {
-      case None => // Invalid packet.
-      case Some(t) => PacketSender.sendComputerState(t, t.isOn)
+      case Some(t) => PacketSender.sendComputerState(t, t.isOn, Option(p.player))
+      case _ => // Invalid packet.
     }
 
   def onRotatableStateRequest(p: PacketParser) =
     p.readTileEntity[tileentity.Rotatable]() match {
-      case None => // Invalid packet.
-      case Some(t) => PacketSender.sendRotatableState(t)
+      case Some(t) => PacketSender.sendRotatableState(t, Option(p.player))
+      case _ => // Invalid packet.
     }
 
   def onRedstoneStateRequest(p: PacketParser) =
     p.readTileEntity[TileEntity with Redstone]() match {
-      case None => // Invalid packet.
-      case Some(t) => PacketSender.sendRedstoneState(t)
+      case Some(t) => PacketSender.sendRedstoneState(t, Option(p.player))
+      case _ => // Invalid packet.
     }
 
   def onKeyDown(p: PacketParser) =
     p.readTileEntity[Node]() match {
-      case None => // Invalid packet.
       case Some(s: tileentity.Screen) =>
         val char = p.readChar()
         val code = p.readInt()
         val network = s.origin.network
         s.screens.foreach(n => network.foreach(_.sendToNeighbors(n, "keyboard.keyDown", p.player, char, code)))
       case Some(n) => n.network.foreach(_.sendToNeighbors(n, "keyboard.keyDown", p.player, p.readChar(), p.readInt()))
+      case _ => // Invalid packet.
     }
 
   def onKeyUp(p: PacketParser) =
     p.readTileEntity[Node]() match {
-      case None => // Invalid packet.
       case Some(s: tileentity.Screen) =>
         val char = p.readChar()
         val code = p.readInt()
         val network = s.origin.network
         s.screens.foreach(n => network.foreach(_.sendToNeighbors(n, "keyboard.keyUp", p.player, char, code)))
       case Some(n) => n.network.foreach(_.sendToNeighbors(n, "keyboard.keyUp", p.player, p.readChar(), p.readInt()))
+      case _ => // Invalid packet.
     }
 
   def onClipboard(p: PacketParser) =
     p.readTileEntity[Node]() match {
-      case None => // Invalid packet.
       case Some(s: tileentity.Screen) =>
         val value = p.readUTF()
         val network = s.origin.network
         s.screens.foreach(n => network.foreach(_.sendToNeighbors(n, "keyboard.clipboard", p.player, value)))
       case Some(n) => n.network.foreach(_.sendToNeighbors(n, "keyboard.clipboard", p.player, p.readUTF()))
+      case _ => // Invalid packet.
     }
 }
\ No newline at end of file
diff --git a/li/cil/oc/server/PacketSender.scala b/li/cil/oc/server/PacketSender.scala
index 7fa042d55..c676d4df0 100644
--- a/li/cil/oc/server/PacketSender.scala
+++ b/li/cil/oc/server/PacketSender.scala
@@ -1,5 +1,6 @@
 package li.cil.oc.server
 
+import cpw.mods.fml.common.network.Player
 import li.cil.oc.common.PacketBuilder
 import li.cil.oc.common.PacketType
 import li.cil.oc.common.tileentity.Rotatable
@@ -9,6 +10,20 @@ import net.minecraftforge.common.ForgeDirection
 
 /** Centralized packet dispatcher for sending updates to the client. */
 object PacketSender {
+  def sendScreenBufferState(t: TileEntity, w: Int, h: Int, text: String, player: Option[Player] = None) = {
+    val pb = new PacketBuilder(PacketType.ScreenBufferResponse)
+
+    pb.writeTileEntity(t)
+    pb.writeInt(w)
+    pb.writeInt(h)
+    pb.writeUTF(text)
+
+    player match {
+      case Some(p) => pb.sendToPlayer(p)
+      case _ => pb.sendToAllPlayers()
+    }
+  }
+
   def sendScreenResolutionChange(t: TileEntity, w: Int, h: Int) = {
     val pb = new PacketBuilder(PacketType.ScreenResolutionChange)
 
@@ -57,26 +72,32 @@ object PacketSender {
     pb.sendToAllPlayers()
   }
 
-  def sendComputerState(t: TileEntity, value: Boolean) = {
+  def sendComputerState(t: TileEntity, value: Boolean, player: Option[Player] = None) = {
     val pb = new PacketBuilder(PacketType.ComputerStateResponse)
 
     pb.writeTileEntity(t)
     pb.writeBoolean(value)
 
-    pb.sendToAllPlayers()
+    player match {
+      case Some(p) => pb.sendToPlayer(p)
+      case _ => pb.sendToAllPlayers()
+    }
   }
 
-  def sendRotatableState(t: Rotatable) = {
+  def sendRotatableState(t: Rotatable, player: Option[Player] = None) = {
     val pb = new PacketBuilder(PacketType.RotatableStateResponse)
 
     pb.writeTileEntity(t)
     pb.writeDirection(t.pitch)
     pb.writeDirection(t.yaw)
 
-    pb.sendToAllPlayers()
+    player match {
+      case Some(p) => pb.sendToPlayer(p)
+      case _ => pb.sendToAllPlayers()
+    }
   }
 
-  def sendRedstoneState(t: TileEntity with Redstone) = {
+  def sendRedstoneState(t: TileEntity with Redstone, player: Option[Player] = None) = {
     val pb = new PacketBuilder(PacketType.RedstoneStateResponse)
 
     pb.writeTileEntity(t)
@@ -85,6 +106,9 @@ object PacketSender {
       pb.writeByte(t.output(d))
     }
 
-    pb.sendToAllPlayers()
+    player match {
+      case Some(p) => pb.sendToPlayer(p)
+      case _ => pb.sendToAllPlayers()
+    }
   }
 }
\ No newline at end of file
diff --git a/li/cil/oc/server/component/Computer.scala b/li/cil/oc/server/component/Computer.scala
index 81f6796ea..24644fb22 100644
--- a/li/cil/oc/server/component/Computer.scala
+++ b/li/cil/oc/server/component/Computer.scala
@@ -560,6 +560,20 @@ class Computer(val owner: Computer.Environment) extends Persistable with Runnabl
       def parseArguments(lua: LuaState, start: Int) =
         for (index <- start to lua.getTop) yield parseArgument(lua, index)
 
+      def pushList(value: Iterator[(Any, Int)]) {
+        lua.newTable()
+        var count = 0
+        value.foreach {
+          case (entry, index) =>
+            pushResult(lua, entry)
+            lua.rawSet(-2, index + 1)
+            count = count + 1
+        }
+        lua.pushString("n")
+        lua.pushInteger(count)
+        lua.rawSet(-3)
+      }
+
       def pushResult(lua: LuaState, value: Any): Unit = value match {
         case value: Boolean => lua.pushBoolean(value)
         case value: Byte => lua.pushNumber(value)
@@ -570,15 +584,10 @@ class Computer(val owner: Computer.Environment) extends Persistable with Runnabl
         case value: Double => lua.pushNumber(value)
         case value: String => lua.pushString(value)
         case value: Array[Byte] => lua.pushByteArray(value)
-        case value: Array[_] => {
-          lua.newTable()
-          value.zipWithIndex.foreach {
-            case (entry, index) =>
-              pushResult(lua, entry)
-              lua.rawSet(-2, index)
-          }
-        }
-        // TODO maps, tuples/seqs?
+        case value: Array[_] => pushList(value.zipWithIndex.iterator)
+        case value: Product => pushList(value.productIterator.zipWithIndex)
+        case value: Seq[_] => pushList(value.zipWithIndex.iterator)
+        // TODO maps?
         // TODO I fear they are, but check if the following are really necessary for Java interop.
         case value: java.lang.Byte => lua.pushNumber(value.byteValue)
         case value: java.lang.Short => lua.pushNumber(value.shortValue)
diff --git a/li/cil/oc/server/component/GraphicsCard.scala b/li/cil/oc/server/component/GraphicsCard.scala
index e01dc4e0b..ce2a622f8 100644
--- a/li/cil/oc/server/component/GraphicsCard.scala
+++ b/li/cil/oc/server/component/GraphicsCard.scala
@@ -4,9 +4,7 @@ import li.cil.oc.api.network.{Component, Visibility, Message}
 import li.cil.oc.common.component
 import net.minecraft.nbt.NBTTagCompound
 
-class GraphicsCard extends Component {
-  val supportedResolutions = List(List(40, 24), List(80, 24))
-
+class GraphicsCard(val resolutions: List[(Int, Int)]) extends Component {
   private var screen: Option[String] = None
 
   override val name = "gpu"
@@ -31,14 +29,14 @@ class GraphicsCard extends Component {
         })
       case Array() if message.name == "system.disconnect" && message.source.address == screen => screen = None; None
       case Array(w: Double, h: Double) if message.name == "gpu.resolution=" =>
-        if (supportedResolutions.contains((w.toInt, h.toInt)))
+        if (resolutions.contains((w.toInt, h.toInt)))
           trySend("screen.resolution=", w.toInt, h.toInt)
         else
           result(Unit, "unsupported resolution")
       case Array() if message.name == "gpu.resolution" => trySend("screen.resolution")
       case Array() if message.name == "gpu.resolutions" => trySend("screen.resolutions") match {
         case Some(Array(resolutions@_*)) =>
-          result(supportedResolutions.intersect(resolutions): _*)
+          result(resolutions.intersect(resolutions): _*)
         case _ => None
       }
       case Array(x: Double, y: Double, value: Array[Byte]) if message.name == "gpu.set" =>
diff --git a/li/cil/oc/server/driver/GraphicsCard.scala b/li/cil/oc/server/driver/GraphicsCard.scala
index c48a8d590..860756206 100644
--- a/li/cil/oc/server/driver/GraphicsCard.scala
+++ b/li/cil/oc/server/driver/GraphicsCard.scala
@@ -2,6 +2,7 @@ package li.cil.oc.server.driver
 
 import li.cil.oc.api.driver
 import li.cil.oc.api.driver.Slot
+import li.cil.oc.common
 import li.cil.oc.server.component
 import li.cil.oc.{Config, Items}
 import net.minecraft.item.ItemStack
@@ -9,9 +10,14 @@ import net.minecraft.item.ItemStack
 object GraphicsCard extends driver.Item {
   override def api = Option(getClass.getResourceAsStream(Config.driverPath + "gpu.lua"))
 
-  override def worksWith(item: ItemStack) = WorksWith(Items.gpu)(item)
+  override def worksWith(item: ItemStack) = WorksWith(Items.gpu1, Items.gpu2, Items.gpu3)(item)
 
   override def slot(item: ItemStack) = Slot.Card
 
-  override def node(item: ItemStack) = Some(new component.GraphicsCard())
+  override def node(item: ItemStack) =
+    Items.multi.subItem(item) match {
+      case Some(gpu: common.item.GraphicsCard) =>
+        Some(new component.GraphicsCard(gpu.resolutions))
+      case _ => throw new IllegalArgumentException()
+    }
 }
\ No newline at end of file