diff --git a/source/Cosmos.Core/DeviceIDAttribute.cs b/source/Cosmos.Core/DeviceIDAttribute.cs
deleted file mode 100644
index f58c55a7a..000000000
--- a/source/Cosmos.Core/DeviceIDAttribute.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Cosmos.Core {
-    [AttributeUsageAttribute(AttributeTargets.Class, AllowMultiple=true)]
-    public sealed class DeviceIDAttribute : Attribute {
-        public UInt16 VendorID;
-        public UInt16 DeviceID;
-    }
-}
diff --git a/source/Cosmos.Core/IOPort.cs b/source/Cosmos.Core/IOPort.cs
index ca423ee8f..3ff7f1dc3 100644
--- a/source/Cosmos.Core/IOPort.cs
+++ b/source/Cosmos.Core/IOPort.cs
@@ -1,8 +1,9 @@
-using System;
 using IL2CPU.API.Attribs;
 
-namespace Cosmos.Core {
-    public abstract class IOPortBase {
+namespace Cosmos.Core
+{
+    public abstract class IOPortBase
+    {
         //TODO Make it that IO port classes are exclusive to each port. For example
         // only one IOPort class can be created per port number. This will prevent
         // two instances of an IOPort from using the same port.
@@ -13,79 +14,83 @@ namespace Cosmos.Core {
         // class. Or maybe some base support can be added to this class, but its functionality
         // is optional and only used by classes that need concurrency control like ATA.
 
-        public readonly UInt16 Port;
+        protected readonly ushort Port;
 
         // all ctors are internal - Only Core ring can create it.. but hardware ring can use it.
-        protected IOPortBase(UInt16 aPort) {
+        protected IOPortBase(ushort aPort)
+        {
             Port = aPort;
         }
 
-        protected IOPortBase(UInt16 aBase, UInt16 aOffset) {
+        protected IOPortBase(ushort aBase, ushort aOffset)
+        {
             // C# math promotes things to integers, so we have this constructor
             // to relieve the use from having to do so many casts
-            Port = (UInt16)(aBase + aOffset);
+            Port = (ushort)(aBase + aOffset);
         }
 
         //TODO: Reads and writes can use this to get port instead of argument
         [PlugMethod(PlugRequired = true)]
-        static protected void Write8(UInt16 aPort, byte aData) {
-        } // Plugged
+        static protected void Write8(ushort aPort, byte aData) => throw null;
 
         [PlugMethod(PlugRequired = true)]
-        static protected void Write16(UInt16 aPort, UInt16 aData) {
-        } // Plugged
+        static protected void Write16(ushort aPort, ushort aData) => throw null;
 
         [PlugMethod(PlugRequired = true)]
-        static protected void Write32(UInt16 aPort, UInt32 aData) {
-        } // Plugged
+        static protected void Write32(ushort aPort, uint aData) => throw null;
 
         [PlugMethod(PlugRequired = true)]
-        static protected byte Read8(UInt16 aPort) {
-            return 0;
-        } // Plugged
+        static protected byte Read8(ushort aPort) => throw null;
 
         [PlugMethod(PlugRequired = true)]
-        static protected UInt16 Read16(UInt16 aPort) {
-            return 0;
-        } // Plugged
+        static protected ushort Read16(ushort aPort) => throw null;
 
         [PlugMethod(PlugRequired = true)]
-        static protected UInt32 Read32(UInt16 aPort) {
-            return 0;
-        } // Plugged
+        static protected uint Read32(ushort aPort) => throw null;
 
         //TODO: Plug these Reads with asm to read directly to RAM
         // REP INSW
-        public void Read8(byte[] aData) {
-            UInt16 xValue;
-            for (int i = 0; i < aData.Length / 2; i++) {
-                xValue = Read16(Port);
+        public void Read8(byte[] aData)
+        {
+            for (int i = 0; i < aData.Length / 2; i++)
+            {
+                var xValue = Read16(Port);
                 aData[i * 2] = (byte)xValue;
                 aData[i * 2 + 1] = (byte)(xValue >> 8);
             }
         }
 
-        public void Read16(UInt16[] aData) {
-            for (int i = 0; i < aData.Length; i++) {
+        public void Read16(ushort[] aData)
+        {
+            for (int i = 0; i < aData.Length; i++)
+            {
                 aData[i] = Read16(Port);
             }
         }
 
-        public void Read32(UInt32[] aData) {
-            for (int i = 0; i < aData.Length; i++) {
+        public void Read32(uint[] aData)
+        {
+            for (int i = 0; i < aData.Length; i++)
+            {
                 aData[i] = Read32(Port);
             }
         }
     }
 
-    public class IOPort : IOPortBase {
-        public IOPort(UInt16 aPort) : base(aPort) {
+    public class IOPort : IOPortBase
+    {
+        public IOPort(ushort aPort)
+            : base(aPort)
+        {
         }
 
-        public IOPort(UInt16 aBase, UInt16 aOffset) : base(aBase, aOffset) {
+        public IOPort(ushort aBase, ushort aOffset)
+            : base(aBase, aOffset)
+        {
         }
 
-        static public void Wait() {
+        static public void Wait()
+        {
             // Write to an unused port. This assures whatever we were waiting on for a previous
             // IO read/write has completed.
             // Port 0x80 is unused after BIOS POST.
@@ -95,86 +100,70 @@ namespace Cosmos.Core {
             Write8(0x80, 0x22);
         }
 
-        public byte Byte {
-            get {
-                return Read8(Port);
-            }
-            set {
-                Write8(Port, value);
-            }
+        public byte Byte
+        {
+            get => Read8(Port);
+            set => Write8(Port, value);
         }
 
-        public UInt16 Word {
-            get {
-                return Read16(Port);
-            }
-            set {
-                Write16(Port, value);
-            }
+        public ushort Word
+        {
+            get => Read16(Port);
+            set => Write16(Port, value);
         }
 
-        public UInt32 DWord {
-            get {
-                return Read32(Port);
-            }
-            set {
-                Write32(Port, value);
-            }
+        public uint DWord
+        {
+            get => Read32(Port);
+            set => Write32(Port, value);
         }
     }
 
     // I split these instead of adding CanRead/CanWrite because this enforces
     // at build time, and its also faster at runtime. Finally it allows future optimizations better
     // than checking at runtime.
-    public class IOPortRead : IOPortBase {
-        public IOPortRead(UInt16 aPort) : base(aPort) {
+    public class IOPortRead : IOPortBase
+    {
+        public IOPortRead(ushort aPort)
+            : base(aPort)
+        {
         }
 
-        public IOPortRead(UInt16 aBase, UInt16 aOffset) : base(aBase, aOffset) {
+        public IOPortRead(ushort aBase, ushort aOffset)
+            : base(aBase, aOffset)
+        {
         }
 
-        public byte Byte {
-            get {
-                return Read8(Port);
-            }
-        }
+        public byte Byte => Read8(Port);
 
-        public UInt16 Word {
-            get {
-                return Read16(Port);
-            }
-        }
+        public ushort Word => Read16(Port);
 
-        public UInt32 DWord {
-            get {
-                return Read32(Port);
-            }
-        }
+        public uint DWord => Read32(Port);
     }
 
-    public class IOPortWrite : IOPortBase {
-        public IOPortWrite(UInt16 aPort) : base(aPort) {
+    public class IOPortWrite : IOPortBase
+    {
+        public IOPortWrite(ushort aPort) : base(aPort)
+        {
         }
 
-        public IOPortWrite(UInt16 aBase, UInt16 aOffset) : base(aBase, aOffset) {
+        public IOPortWrite(ushort aBase, ushort aOffset) : base(aBase, aOffset)
+        {
         }
 
-        public byte Byte {
-            set {
-                Write8(Port, value);
-            }
+        public byte Byte
+        {
+            set => Write8(Port, value);
         }
 
-        public UInt16 Word {
-            set {
-                Write16(Port, value);
-            }
+        public ushort Word
+        {
+            set => Write16(Port, value);
         }
 
-        public UInt32 DWord {
-            set {
-                Write32(Port, value);
-            }
+        public uint DWord
+        {
+            set => Write32(Port, value);
         }
     }
 }
diff --git a/source/Cosmos.Core_Asm/IOPortImpl.cs b/source/Cosmos.Core_Asm/IOPortImpl.cs
index 29fd8124b..7cfcb086c 100644
--- a/source/Cosmos.Core_Asm/IOPortImpl.cs
+++ b/source/Cosmos.Core_Asm/IOPortImpl.cs
@@ -1,9 +1,9 @@
-using System;
-using XSharp.Assembler;
 using Cosmos.Core;
-using IL2CPU.API;
+
 using IL2CPU.API.Attribs;
+
 using XSharp;
+using XSharp.Assembler;
 
 namespace Cosmos.Core_Asm
 {
@@ -27,9 +27,7 @@ namespace Cosmos.Core_Asm
         }
 
         [PlugMethod(Assembler = typeof(Write8Assembler))]
-        public static void Write8(UInt16 aPort, byte aData)
-        {
-        }
+        public static void Write8(ushort aPort, byte aData) => throw null;
 
         #endregion
 
@@ -46,9 +44,7 @@ namespace Cosmos.Core_Asm
         }
 
         [PlugMethod(Assembler = typeof(Write16Assembler))]
-        public static void Write16(UInt16 aPort, UInt16 aData)
-        {
-        }
+        public static void Write16(ushort aPort, ushort aData) => throw null;
 
         #endregion
 
@@ -65,9 +61,7 @@ namespace Cosmos.Core_Asm
         }
 
         [PlugMethod(Assembler = typeof(Write32Assembler))]
-        public static void Write32(UInt16 aPort, UInt32 aData)
-        {
-        }
+        public static void Write32(ushort aPort, uint aData) => throw null;
 
         #endregion
 
@@ -87,10 +81,7 @@ namespace Cosmos.Core_Asm
         }
 
         [PlugMethod(Assembler = typeof(Read8Assembler))]
-        public static byte Read8(UInt16 aPort)
-        {
-            return 0;
-        }
+        public static byte Read8(ushort aPort) => throw null;
 
         #endregion
 
@@ -108,10 +99,7 @@ namespace Cosmos.Core_Asm
         }
 
         [PlugMethod(Assembler = typeof(Read16Assembler))]
-        public static UInt16 Read16(UInt16 aPort)
-        {
-            return 0;
-        }
+        public static ushort Read16(ushort aPort) => throw null;
 
         #endregion
 
@@ -128,10 +116,7 @@ namespace Cosmos.Core_Asm
         }
 
         [PlugMethod(Assembler = typeof(Read32Assembler))]
-        public static UInt32 Read32(UInt16 aPort)
-        {
-            return 0;
-        }
+        public static uint Read32(ushort aPort) => throw null;
 
         #endregion