diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000000..755550fdfc
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,53 @@
+
+[*]
+charset=utf-8
+end_of_line=crlf
+trim_trailing_whitespace=false
+insert_final_newline=false
+indent_style=space
+indent_size=4
+
+# Microsoft .NET properties
+csharp_new_line_before_members_in_object_initializers=false
+csharp_preferred_modifier_order=public, private, protected, internal, new, abstract, virtual, sealed, override, static, readonly, extern, unsafe, volatile, async:suggestion
+csharp_style_var_elsewhere=true:hint
+csharp_style_var_for_built_in_types=true:hint
+csharp_style_var_when_type_is_apparent=true:hint
+dotnet_style_predefined_type_for_locals_parameters_members=true:hint
+dotnet_style_predefined_type_for_member_access=true:hint
+dotnet_style_qualification_for_event=false:warning
+dotnet_style_qualification_for_field=false:warning
+dotnet_style_qualification_for_method=false:warning
+dotnet_style_qualification_for_property=false:warning
+dotnet_style_require_accessibility_modifiers=for_non_interface_members:hint
+
+# ReSharper properties
+resharper_autodetect_indent_settings=true
+resharper_braces_for_for=required
+resharper_braces_for_foreach=required
+resharper_braces_for_ifelse=required
+resharper_braces_for_while=required
+resharper_csharp_insert_final_newline=true
+resharper_csharp_wrap_before_declaration_lpar=true
+resharper_csharp_wrap_before_invocation_lpar=true
+resharper_csharp_wrap_extends_list_style=chop_if_long
+resharper_csharp_wrap_parameters_style=chop_if_long
+resharper_use_indent_from_vs=false
+resharper_wrap_after_declaration_lpar=true
+resharper_wrap_after_invocation_lpar=true
+resharper_wrap_before_declaration_rpar=true
+resharper_wrap_before_invocation_rpar=true
+resharper_wrap_chained_method_calls=chop_if_long
+resharper_xmldoc_indent_child_elements=DoNotTouch
+resharper_xmldoc_indent_text=DoNotTouch
+
+# ReSharper inspection severities
+resharper_invert_if_highlighting=none
+resharper_web_config_module_not_resolved_highlighting=warning
+resharper_web_config_type_not_resolved_highlighting=warning
+resharper_web_config_wrong_module_highlighting=warning
+
+[*.{appxmanifest,asax,ascx,aspx,build,config,cs,cshtml,csproj,dbml,discomap,dtd,fs,fsi,fsscript,fsx,htm,html,jsproj,lsproj,master,ml,mli,njsproj,nuspec,proj,props,razor,resw,resx,skin,StyleCop,targets,tasks,vb,vbproj,xaml,xamlx,xml,xoml,xsd}]
+indent_style=space
+indent_size=4
+tab_width=4
diff --git a/Silk.NET.sln b/Silk.NET.sln
index c72b13ae9f..9d91b00262 100644
--- a/Silk.NET.sln
+++ b/Silk.NET.sln
@@ -167,6 +167,12 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{0651C5EF-5
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Triangle", "examples\Triangle\Triangle.csproj", "{3478F392-7055-4ECC-B388-7F115AA7EA5A}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Input.Desktop", "src\Input\Silk.NET.Input.Desktop\Silk.NET.Input.Desktop.csproj", "{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Input", "src\Input\Silk.NET.Input\Silk.NET.Input.csproj", "{020A8E88-B607-4281-BA0D-5ED03484A201}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "InputTest", "examples\InputTest\InputTest.csproj", "{3E744E54-F450-4051-8919-04D9B591688E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -1044,6 +1050,42 @@ Global
 		{3478F392-7055-4ECC-B388-7F115AA7EA5A}.Release|x64.Build.0 = Release|Any CPU
 		{3478F392-7055-4ECC-B388-7F115AA7EA5A}.Release|x86.ActiveCfg = Release|Any CPU
 		{3478F392-7055-4ECC-B388-7F115AA7EA5A}.Release|x86.Build.0 = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|x64.Build.0 = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|x86.Build.0 = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|x64.ActiveCfg = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|x64.Build.0 = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|x86.ActiveCfg = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|x86.Build.0 = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|x64.Build.0 = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|x86.Build.0 = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|Any CPU.Build.0 = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x64.ActiveCfg = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x64.Build.0 = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x86.ActiveCfg = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x86.Build.0 = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|x64.Build.0 = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|x86.Build.0 = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|x64.ActiveCfg = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|x64.Build.0 = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|x86.ActiveCfg = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{BFE429EB-4C2E-4BF3-A302-C9C5A2FDA6D7} = {23324041-2076-477C-A4BF-B385B8066C6C}
@@ -1119,5 +1161,8 @@ Global
 		{FD24E9FF-1097-4777-A418-F2D88C558665} = {0651C5EF-50AA-4598-8D9C-8F210ADD8490}
 		{136C6154-D300-4B82-80D3-17B637841A2B} = {0651C5EF-50AA-4598-8D9C-8F210ADD8490}
 		{3478F392-7055-4ECC-B388-7F115AA7EA5A} = {E1F91563-7277-4E9B-A3B7-8D5FD9802A4A}
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4} = {FA9D1C95-5585-4DEC-B226-1447A486C376}
+		{020A8E88-B607-4281-BA0D-5ED03484A201} = {FA9D1C95-5585-4DEC-B226-1447A486C376}
+		{3E744E54-F450-4051-8919-04D9B591688E} = {E1F91563-7277-4E9B-A3B7-8D5FD9802A4A}
 	EndGlobalSection
 EndGlobal
diff --git a/documentation/proposals/Proposal - Input.md b/documentation/proposals/Proposal - Input.md
index 5cdb00bbe5..c7c248144e 100644
--- a/documentation/proposals/Proposal - Input.md	
+++ b/documentation/proposals/Proposal - Input.md	
@@ -1,4 +1,4 @@
-# Summary    
+# Summary    
 Proposal API for Input via keyboards, mice, and controllers.
 
 # Contributors
@@ -27,9 +27,9 @@ Proposal API for Input via keyboards, mice, and controllers.
 ```cs
 public interface IJoystick : IInputDevice
 {
-    IReadOnlyCollection<Axis> Axes { get; }
-    IReadOnlyCollection<Button> Buttons { get; }
-    IReadOnlyCollection<Hat> Hats { get; }
+    IReadOnlyList<Axis> Axes { get; }
+    IReadOnlyList<Button> Buttons { get; }
+    IReadOnlyList<Hat> Hats { get; }
     Deadzone Deadzone { get; set; }
     event Action<IJoystick, Button> ButtonDown;
     event Action<IJoystick, Button> ButtonUp;
@@ -42,9 +42,9 @@ public interface IJoystick : IInputDevice
 ```cs
 public interface IGamepad : IInputDevice
 {
-    IReadOnlyCollection<Button> Buttons { get; }
-    IReadOnlyCollection<Thumbstick> Thumbsticks { get; }
-    IReadOnlyCollection<Trigger> Triggers { get; }
+    IReadOnlyList<Button> Buttons { get; }
+    IReadOnlyList<Thumbstick> Thumbsticks { get; }
+    IReadOnlyList<Trigger> Triggers { get; }
     Deadzone Deadzone { get; set; }
     event Action<IGamepad, Button> ButtonDown;
     event Action<IGamepad, Button> ButtonUp;
@@ -57,7 +57,7 @@ public interface IGamepad : IInputDevice
 ```cs
 public interface IKeyboard : IInputDevice
 {
-    IReadOnlyCollection<Key> SupportedKeys { get; }
+    IReadOnlyList<Key> SupportedKeys { get; }
     bool IsKeyPressed(Key key);
     bool IsKeyPressed(uint scancode);
     event Action<IKeyboard, Key> KeyDown;
@@ -69,8 +69,8 @@ public interface IKeyboard : IInputDevice
 ```cs
 public interface IMouse : IInputDevice
 {
-    IReadOnlyCollection<MouseButton> SupportedButtons { get; }
-    IReadOnlyCollection<ScrollWheel> ScrollWheels { get; }
+    IReadOnlyList<MouseButton> SupportedButtons { get; }
+    IReadOnlyList<ScrollWheel> ScrollWheels { get; }
     bool IsButtonPressed(MouseButton btn);
     event Action<IMouse, MouseButton> MouseDown;
     event Action<IMouse, MouseButton> MouseUp;
@@ -94,11 +94,11 @@ public interface IInputDevice
 public interface IInputContext : IDisposable
 {
     IntPtr Handle { get; }
-    IReadOnlyCollection<IGamepad> Gamepads { get; }
-    IReadOnlyCollection<IJoystick> Joysticks { get; }
-    IReadOnlyCollection<IKeyboard> Keyboards { get; }
-    IReadOnlyCollection<IMouse> Mice { get; }
-    IReadOnlyCollection<IInputDevice> OtherDevices { get; }
+    IReadOnlyList<IGamepad> Gamepads { get; }
+    IReadOnlyList<IJoystick> Joysticks { get; }
+    IReadOnlyList<IKeyboard> Keyboards { get; }
+    IReadOnlyList<IMouse> Mice { get; }
+    IReadOnlyList<IInputDevice> OtherDevices { get; }
 }
 ```
 
@@ -162,7 +162,9 @@ public struct Axis
 ```cs
 public struct Thumbstick
 {
-    public int Index { get; }
+    public int Index { get; }
+    public float X { get; }
+    public float Y { get; }
     public float Position { get; }
     public float Direction { get; }
     
diff --git a/examples/InputTest/InputTest.csproj b/examples/InputTest/InputTest.csproj
new file mode 100644
index 0000000000..ba1d328a81
--- /dev/null
+++ b/examples/InputTest/InputTest.csproj
@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>netcoreapp2.1</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\src\Input\Silk.NET.Input.Desktop\Silk.NET.Input.Desktop.csproj" />
+      <ProjectReference Include="..\..\src\Input\Silk.NET.Input\Silk.NET.Input.csproj" />
+      <ProjectReference Include="..\..\src\Windowing\Silk.NET.Windowing\Silk.NET.Windowing.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
new file mode 100644
index 0000000000..491d4cd66c
--- /dev/null
+++ b/examples/InputTest/Program.cs
@@ -0,0 +1,209 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using Silk.NET.Input;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop;
+using Silk.NET.Windowing;
+using Silk.NET.Windowing.Common;
+using Silk.NET.Windowing.Desktop;
+
+namespace InputTest
+{
+    internal class Program
+    {
+        private static void Main()
+        {
+            var opts = WindowOptions.Default;
+            opts.UseSingleThreadedWindow = false;
+            opts.FramesPerSecond = 60;
+            opts.UpdatesPerSecond = 60;
+            var window = Window.Create(opts);
+            Task.Run(() => window.Run());
+            var input = window.GetInput();
+            input.ConnectionChanged += DoConnect;
+            Console.WriteLine("Now, go press buttons in the window and you'll see the feedback here.");
+            foreach (var gamepad in input.Gamepads)
+            {
+                if (!gamepad.IsConnected) continue;
+                DoConnect(gamepad, gamepad.IsConnected);
+            }
+            
+            foreach (var joystick in input.Joysticks)
+            {
+                if (!joystick.IsConnected) continue;
+                DoConnect(joystick, joystick.IsConnected);
+            }
+
+            foreach (var keyboard in input.Keyboards)
+            {
+                if (!keyboard.IsConnected) continue;
+                DoConnect(keyboard, keyboard.IsConnected);
+            }
+
+            foreach (var mouse in input.Mice)
+            {
+                if (!mouse.IsConnected) continue;
+                DoConnect(mouse, mouse.IsConnected);
+            }
+
+            Console.ReadLine();
+        }
+
+        private static void GamepadOnTriggerMoved(IGamepad g, Trigger t)
+        {
+            Console.WriteLine("G" + g.Index + "> " + t.Index + " trigger moved: " + t.Position);
+        }
+
+        private static void GamepadOnThumbstickMoved(IGamepad g, Thumbstick t)
+        {
+            Console.WriteLine("G" + g.Index + "> " + t.Index + " thumbstick moved: (" + t.X + ", " + t.Y + ")");
+        }
+
+        private static void JoystickOnHatMoved(IJoystick arg1, Hat arg2)
+        {
+            Console.WriteLine("J" + arg1.Index + "> " + arg2.Index + " hat moved: " + arg2.Position);
+        }
+
+        private static void JoystickOnAxisMoved(IJoystick arg1, Axis arg2)
+        {
+            Console.WriteLine("J" + arg1.Index + "> " + arg2.Index + " axis moved: " + arg2.Position);
+        }
+
+        private static void JoystickOnButtonUp(IJoystick arg1, Button arg2)
+        {
+            Console.WriteLine("J" + arg1.Index + "> " + arg2.Name + " down.");
+        }
+
+        private static void JoystickOnButtonDown(IJoystick arg1, Button arg2)
+        {
+            Console.WriteLine("J" + arg1.Index + "> " + arg2.Name + " down.");
+        }
+
+        private static void InputGamepadOnButtonDown(IGamepad arg1, Button arg2)
+        {
+            Console.WriteLine("G" + arg1.Index + "> " + arg2.Name + " down. " + (int)arg2.Name);
+        }
+
+        private static void InputGamepadOnButtonUp(IGamepad arg1, Button arg2)
+        {
+            Console.WriteLine("G" + arg1.Index + "> " + arg2.Name + " up.");
+        }
+
+        public static void DoConnect(IInputDevice device, bool isConnected)
+        {
+            Console.WriteLine(isConnected
+                ? $"Device {device.Name} connected"
+                : $"Device {device.Name} disconnected");
+            if (device is IGamepad gamepad && device.IsConnected)
+            {
+                Console.WriteLine("Discovered controller " + gamepad.Index + " (Connected: " + isConnected + ")");
+                if (isConnected)
+                {
+                    gamepad.ButtonDown += InputGamepadOnButtonDown;
+                    gamepad.ButtonUp += InputGamepadOnButtonUp;
+                    gamepad.ThumbstickMoved += GamepadOnThumbstickMoved;
+                    gamepad.TriggerMoved += GamepadOnTriggerMoved;
+                }
+                else
+                {
+                    gamepad.ButtonDown -= InputGamepadOnButtonDown;
+                    gamepad.ButtonUp -= InputGamepadOnButtonUp;
+                    gamepad.ThumbstickMoved -= GamepadOnThumbstickMoved;
+                    gamepad.TriggerMoved -= GamepadOnTriggerMoved;
+                }
+
+                Console.Write("    Buttons: ");
+                const string s = "\n             ";
+                Console.WriteLine(string.Join(s, gamepad.Buttons.Select(x => x.Name + (x.Pressed ? "(1)" : "(0)"))));
+                Console.WriteLine("    " + gamepad.Thumbsticks.Count + " thumbsticks found.");
+                Console.WriteLine("    " + gamepad.Triggers.Count + " triggers found.");
+            }
+            else if (device is IJoystick joystick)
+            {
+                Console.WriteLine("Discovered joystick " + joystick.Index + " (Connected: " + isConnected + ")");
+                if (isConnected)
+                {
+                    joystick.ButtonDown += JoystickOnButtonDown;
+                    joystick.ButtonUp += JoystickOnButtonUp;
+                    joystick.AxisMoved += JoystickOnAxisMoved;
+                    joystick.HatMoved += JoystickOnHatMoved;
+                }
+                else
+                {
+                    joystick.ButtonDown -= JoystickOnButtonDown;
+                    joystick.ButtonUp -= JoystickOnButtonUp;
+                    joystick.AxisMoved -= JoystickOnAxisMoved;
+                    joystick.HatMoved -= JoystickOnHatMoved;
+                }
+
+                Console.Write("    Buttons: ");
+                const string s = "\n             ";
+                Console.WriteLine(string.Join(s, joystick.Buttons.Select(x => x.Name + (x.Pressed ? "(1)" : "(0)"))));
+            }
+            else if (device is IKeyboard keyboard)
+            {
+                Console.WriteLine("Discovered keyboard " + keyboard.Index + " (Connected: " + isConnected + ")");
+                if (isConnected)
+                {
+                    keyboard.KeyDown += KeyboardOnKeyDown;
+                    keyboard.KeyUp += KeyboardOnKeyUp;
+                }
+                else
+                {
+                    keyboard.KeyDown -= KeyboardOnKeyDown;
+                    keyboard.KeyUp -= KeyboardOnKeyUp;
+                }
+
+                Console.Write("    Buttons: ");
+                Console.WriteLine(string.Join(", ", keyboard.SupportedKeys.Select(x => x)));
+            }
+            else if (device is IMouse mouse)
+            {
+                Console.WriteLine("Discovered mouse " + mouse.Index + " (Connected: " + isConnected + ")");
+                if (isConnected)
+                {
+                    mouse.MouseUp += MouseOnMouseUp;
+                    mouse.MouseDown += MouseOnMouseDown;
+                    mouse.Scroll += MouseOnScroll;
+                }
+                else
+                {
+                    mouse.MouseUp -= MouseOnMouseUp;
+                    mouse.MouseDown -= MouseOnMouseDown;
+                    mouse.Scroll -= MouseOnScroll;
+                }
+
+                Console.Write("    Buttons: ");
+                Console.WriteLine(string.Join(", ", mouse.SupportedButtons.Select(x => x)));
+                Console.WriteLine("    " + mouse.ScrollWheels.Count + " scroll wheels.");
+            }
+        }
+
+        private static void MouseOnScroll(IMouse arg1, ScrollWheel arg2)
+        {
+            Console.WriteLine("K" + arg1.Index + "> Scrolled: (" + arg2.X + ", " + arg2.Y + ")");
+        }
+
+        private static void MouseOnMouseDown(IMouse arg1, MouseButton arg2)
+        {
+            Console.WriteLine("M" + arg1.Index + "> " + arg2 + " down.");
+        }
+
+        private static void MouseOnMouseUp(IMouse arg1, MouseButton arg2)
+        {
+            Console.WriteLine("M" + arg1.Index + "> " + arg2 + " up.");
+        }
+
+        private static void KeyboardOnKeyUp(IKeyboard arg1, Key arg2)
+        {
+            Console.WriteLine("K" + arg1.Index + "> " + arg2 + " up.");
+        }
+
+        private static void KeyboardOnKeyDown(IKeyboard arg1, Key arg2)
+        {
+            Console.WriteLine("K" + arg1.Index + "> " + arg2 + " down.");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Deadzone.cs b/src/Input/Silk.NET.Input.Common/Deadzone.cs
index e7b0fc39cf..ac32532cd4 100644
--- a/src/Input/Silk.NET.Input.Common/Deadzone.cs
+++ b/src/Input/Silk.NET.Input.Common/Deadzone.cs
@@ -3,6 +3,8 @@
 // You may modify and distribute Silk.NET under the terms
 // of the MIT license. See the LICENSE file for details.
 
+using System;
+
 namespace Silk.NET.Input.Common
 {
     /// <summary>
@@ -30,5 +32,25 @@ public Deadzone(float value, DeadzoneMethod method)
             Value = value;
             Method = method;
         }
+
+        /// <summary>
+        /// Applies this deadzone to a raw input value.
+        /// </summary>
+        /// <param name="raw">The raw input value to apply the deadzone to.</param>
+        /// <returns>The input with deadzone applied.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">If the deadzone method isn't part of
+        /// <see cref="DeadzoneMethod"/></exception>
+        public float Apply(float raw)
+        {
+            switch (Method)
+            {
+                case DeadzoneMethod.Traditional:
+                    return Math.Abs(raw) < Value ? 0 : raw;
+                case DeadzoneMethod.AdaptiveGradient:
+                    return (1 - Value) * raw + Value * Math.Sign(raw);
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Enums/ButtonName.cs b/src/Input/Silk.NET.Input.Common/Enums/ButtonName.cs
index 481dac440e..6aa0e1afd7 100644
--- a/src/Input/Silk.NET.Input.Common/Enums/ButtonName.cs
+++ b/src/Input/Silk.NET.Input.Common/Enums/ButtonName.cs
@@ -22,10 +22,8 @@ public enum ButtonName
         DPadRight,
         LeftBumper,
         LeftStick,
-        LeftTrigger,
         RightBumper,
         RightStick,
-        RightTrigger,
         Start
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Enums/Position2D.cs b/src/Input/Silk.NET.Input.Common/Enums/Position2D.cs
index 2e82a5ea99..d9fff157eb 100644
--- a/src/Input/Silk.NET.Input.Common/Enums/Position2D.cs
+++ b/src/Input/Silk.NET.Input.Common/Enums/Position2D.cs
@@ -13,6 +13,7 @@ namespace Silk.NET.Input.Common
     [Flags]
     public enum Position2D
     {
+        Centered = 0,
         Up = 1,
         Down = 2,
         Left = 4,
diff --git a/src/Input/Silk.NET.Input.Common/InputWindowExtensions.cs b/src/Input/Silk.NET.Input.Common/InputWindowExtensions.cs
deleted file mode 100644
index c8514c5697..0000000000
--- a/src/Input/Silk.NET.Input.Common/InputWindowExtensions.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
-using System;
-using Silk.NET.Windowing.Common;
-
-namespace Silk.NET.Input.Common
-{
-    public static class InputWindowExtensions
-    {
-        public static void RegisterInputPlatform(IInputPlatform platform)
-        {
-            throw new NotImplementedException();
-        }
-
-        public static void UnregisterInputPlatform(IInputPlatform platform)
-        {
-            throw new NotImplementedException();
-        }
-
-        public static IInputContext GetInput(this IWindow window)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IGamepad.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IGamepad.cs
index e546fc4171..b6538687de 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IGamepad.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IGamepad.cs
@@ -16,17 +16,17 @@ public interface IGamepad : IInputDevice
         /// <summary>
         /// A list of all available buttons.
         /// </summary>
-        IReadOnlyCollection<Button> Buttons { get; }
+        IReadOnlyList<Button> Buttons { get; }
         
         /// <summary>
         /// A list of all available thumbsticks.
         /// </summary>
-        IReadOnlyCollection<Thumbstick> Thumbsticks { get; }
+        IReadOnlyList<Thumbstick> Thumbsticks { get; }
         
         /// <summary>
         /// A list of all available triggers.
         /// </summary>
-        IReadOnlyCollection<Trigger> Triggers { get; }
+        IReadOnlyList<Trigger> Triggers { get; }
         
         /// <summary>
         /// The deadzone for this gamepad.
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
index 21fbda8ff2..72d41f491e 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
@@ -11,7 +11,7 @@ namespace Silk.NET.Input.Common
     /// <summary>
     /// An interface representing the input context.
     /// </summary>
-    public interface IInputContext
+    public interface IInputContext : IDisposable
     {
         /// <summary>
         /// A handle to the underlying window.
@@ -21,26 +21,43 @@ public interface IInputContext
         /// <summary>
         /// A list of all available gamepads.
         /// </summary>
-        IReadOnlyCollection<IGamepad> Gamepads { get; }
+        IReadOnlyList<IGamepad> Gamepads { get; }
         
         /// <summary>
         /// A list of all available joysticks.
         /// </summary>
-        IReadOnlyCollection<IJoystick> Joysticks { get; }
+        IReadOnlyList<IJoystick> Joysticks { get; }
         
         /// <summary>
         /// A list of all available keyboards.
+        /// <remarks>
+        /// On some backends, this list may only contain 1 item. This is most likely because the underlying API doesn't
+        /// support multiple keyboards.
+        /// </remarks>
         /// </summary>
-        IReadOnlyCollection<IKeyboard> Keyboards { get; }
+        IReadOnlyList<IKeyboard> Keyboards { get; }
         
         /// <summary>
         /// A list of all available mice.
         /// </summary>
-        IReadOnlyCollection<IMouse> Mice { get; }
+        /// <remarks>
+        /// On some backends, this list may only contain 1 item. This is most likely because the underlying API doesn't
+        /// support multiple mice.
+        /// </remarks>
+        IReadOnlyList<IMouse> Mice { get; }
         
         /// <summary>
         /// A list of all other available input devices.
         /// </summary>
-        IReadOnlyCollection<IInputDevice> OtherDevices { get; }
+        /// <remarks>
+        /// On some backends, this list might be empty. This is most likely because the underlying API doesn't
+        /// support other devices.
+        /// </remarks>
+        IReadOnlyList<IInputDevice> OtherDevices { get; }
+        
+        /// <summary>
+        /// Called when the connection status of a device changes.
+        /// </summary>
+        event Action<IInputDevice, bool> ConnectionChanged;
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IInputDevice.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IInputDevice.cs
index d466bc2128..b5d5b929f3 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IInputDevice.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IInputDevice.cs
@@ -3,8 +3,6 @@
 // You may modify and distribute Silk.NET under the terms
 // of the MIT license. See the LICENSE file for details.
 
-using System;
-
 namespace Silk.NET.Input.Common
 {
     /// <summary>
@@ -26,10 +24,5 @@ public interface IInputDevice
         /// Whether or not this device is currently connected.
         /// </summary>
         bool IsConnected { get; }
-        
-        /// <summary>
-        /// Called when the connection of this device changes.
-        /// </summary>
-        event Action<IInputDevice, bool> ConnectionChanged;
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IJoystick.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IJoystick.cs
index 456452a51c..e0f590ded6 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IJoystick.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IJoystick.cs
@@ -1,62 +1,62 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
-using System;
-using System.Collections.Generic;
-
-namespace Silk.NET.Input.Common
-{
-    /// <summary>
-    /// Represents a joystick device with a set amount of axes, buttons, and hats.
-    /// </summary>
-    public interface IJoystick : IInputDevice
-    {
-        /// <summary>
-        /// A list of all axes reported by this joystick.
-        /// </summary>
-        IReadOnlyCollection<Axis> Axes { get; }
-        
-        /// <summary>
-        /// A list of all buttons reported by this joystick.
-        /// </summary>
-        IReadOnlyCollection<Button> Buttons { get; }
-        
-        /// <summary>
-        /// A list of all hats reported by this joystick.
-        /// </summary>
-        IReadOnlyCollection<Hat> Hats { get; }
-        
-        /// <summary>
-        /// The deadzone to use for this joystick's axes.
-        /// </summary>
-        Deadzone Deadzone { get; set; }
-        
-        /// <summary>
-        /// Called when a button on this joystick is pressed.
-        /// </summary>
-        /// <remarks>
-        /// This event is only called when the button is first pressed, and not every frame where the button is still pressed.
-        /// </remarks>
-        event Action<IJoystick, Button> ButtonDown;
-        
-        /// <summary>
-        /// Called when a button on this joystick is released.
-        /// </summary>
-        /// <remarks>
-        /// This event is only called when the button is first released, and not every frame where the button is still released.
-        /// </remarks>
-        event Action<IJoystick, Button> ButtonUp;
-        
-        /// <summary>
-        /// Called when an axis on this joystick is moved.
-        /// </summary>
-        event Action<IJoystick, Axis> AxisMoved;
-        
-        /// <summary>
-        /// Called when a hat on this joystick is moved.
-        /// </summary>
-        event Action<IJoystick, Hat> HatMoved;
-    }
-}
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+
+namespace Silk.NET.Input.Common
+{
+    /// <summary>
+    /// Represents a joystick device with a set amount of axes, buttons, and hats.
+    /// </summary>
+    public interface IJoystick : IInputDevice
+    {
+        /// <summary>
+        /// A list of all axes reported by this joystick.
+        /// </summary>
+        IReadOnlyList<Axis> Axes { get; }
+        
+        /// <summary>
+        /// A list of all buttons reported by this joystick.
+        /// </summary>
+        IReadOnlyList<Button> Buttons { get; }
+        
+        /// <summary>
+        /// A list of all hats reported by this joystick.
+        /// </summary>
+        IReadOnlyList<Hat> Hats { get; }
+        
+        /// <summary>
+        /// The deadzone to use for this joystick's axes.
+        /// </summary>
+        Deadzone Deadzone { get; set; }
+        
+        /// <summary>
+        /// Called when a button on this joystick is pressed.
+        /// </summary>
+        /// <remarks>
+        /// This event is only called when the button is first pressed, and not every frame where the button is still pressed.
+        /// </remarks>
+        event Action<IJoystick, Button> ButtonDown;
+        
+        /// <summary>
+        /// Called when a button on this joystick is released.
+        /// </summary>
+        /// <remarks>
+        /// This event is only called when the button is first released, and not every frame where the button is still released.
+        /// </remarks>
+        event Action<IJoystick, Button> ButtonUp;
+        
+        /// <summary>
+        /// Called when an axis on this joystick is moved.
+        /// </summary>
+        event Action<IJoystick, Axis> AxisMoved;
+        
+        /// <summary>
+        /// Called when a hat on this joystick is moved.
+        /// </summary>
+        event Action<IJoystick, Hat> HatMoved;
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IKeyboard.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IKeyboard.cs
index 3b139b722c..e396af73d0 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IKeyboard.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IKeyboard.cs
@@ -16,7 +16,7 @@ public interface IKeyboard : IInputDevice
         /// <summary>
         /// The keys this keyboard has available.
         /// </summary>
-        IReadOnlyCollection<Key> SupportedKeys { get; }
+        IReadOnlyList<Key> SupportedKeys { get; }
         
         /// <summary>
         /// Checks if a specific key is pressed.
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IMouse.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IMouse.cs
index d512765cea..3b6f2486ee 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IMouse.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IMouse.cs
@@ -16,12 +16,12 @@ public interface IMouse : IInputDevice
         /// <summary>
         /// The buttons this mouse has available.
         /// </summary>
-        IReadOnlyCollection<MouseButton> SupportedButtons { get; }
+        IReadOnlyList<MouseButton> SupportedButtons { get; }
         
         /// <summary>
         /// The scroll wheels this mouse has available.
         /// </summary>
-        IReadOnlyCollection<ScrollWheel> ScrollWheels { get; }
+        IReadOnlyList<ScrollWheel> ScrollWheels { get; }
         
         /// <summary>
         /// Checks if a specific button is currently pressed.
diff --git a/src/Input/Silk.NET.Input.Common/Thumbstick.cs b/src/Input/Silk.NET.Input.Common/Thumbstick.cs
index c164f0018b..ccc9b8ea9d 100644
--- a/src/Input/Silk.NET.Input.Common/Thumbstick.cs
+++ b/src/Input/Silk.NET.Input.Common/Thumbstick.cs
@@ -1,41 +1,53 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
-namespace Silk.NET.Input.Common
-{
-    /// <summary>
-    /// A thumbstick on an <see cref="IGamepad"/>
-    /// </summary>
-    public struct Thumbstick
-    {
-        /// <summary>
-        /// The index of this stick.
-        /// </summary>
-        public int Index { get; }
-        
-        /// <summary>
-        /// The current position of the stick, from 0.0 to 1.0.
-        /// </summary>
-        public float Position { get; }
-        
-        /// <summary>
-        /// The current direction of the stick, from 0.0 to 360.0.
-        /// </summary>
-        public float Direction { get; }
-
-        /// <summary>
-        /// Creates a new instance of the Thumbstick struct.
-        /// </summary>
-        /// <param name="index">The index of the stick.</param>
-        /// <param name="position">The position of the stick.</param>
-        /// <param name="direction">The direction of the stick.</param>
-        public Thumbstick(int index, float position, float direction)
-        {
-            Index = index;
-            Position = position;
-            Direction = direction;
-        }
-    }
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+
+namespace Silk.NET.Input.Common
+{
+    /// <summary>
+    /// A thumbstick on an <see cref="IGamepad"/>
+    /// </summary>
+    public struct Thumbstick
+    {
+        /// <summary>
+        /// The index of this stick.
+        /// </summary>
+        public int Index { get; }
+
+        /// <summary>
+        /// The x-axis of the stick, from -1.0 to 1.0
+        /// </summary>
+        public float X { get; }
+
+        /// <summary>
+        /// The y-axis of the stick, from -1.0 to 1.0
+        /// </summary>
+        public float Y { get; }
+        
+        /// <summary>
+        /// The current position of the stick, from 0.0 to 1.0.
+        /// </summary>
+        public float Position => (float)Math.Sqrt(X * X + Y * Y);
+
+        /// <summary>
+        /// The current direction of the stick, from 0.0 to 360.0.
+        /// </summary>
+        public float Direction => (float)Math.Atan2(Y, X);
+
+        /// <summary>
+        /// Creates a new instance of the Thumbstick struct.
+        /// </summary>
+        /// <param name="index">The index of the stick.</param>
+        /// <param name="position">The position of the stick.</param>
+        /// <param name="direction">The direction of the stick.</param>
+        public Thumbstick(int index, float x, float y)
+        {
+            Index = index;
+            X = x;
+            Y = y;
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
new file mode 100644
index 0000000000..08302940c6
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
@@ -0,0 +1,80 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwAxisCollection : IReadOnlyList<Axis>
+    {
+        private float* _floats;
+        private int _count;
+
+        public GlfwAxisCollection(float* floats, int count)
+        {
+            _floats = floats;
+            _count = count;
+        }
+        public IEnumerator<Axis> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public int Count => _count;
+
+        public Axis this[int index] => index < _count
+            ? new Axis(index, _floats[index])
+            : throw new ArgumentOutOfRangeException();
+        
+        private struct Enumerator : IEnumerator<Axis>
+        {
+            private GlfwAxisCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwAxisCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+            
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Axis(_current, _col._floats[_current]);
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Axis Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
new file mode 100644
index 0000000000..665cea6023
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -0,0 +1,77 @@
+using Silk.NET.Input.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwButtonCollection : IReadOnlyList<Button>
+    {
+        private byte* _bytes;
+        private int _count;
+
+        public GlfwButtonCollection(byte* bytes, int count)
+        {
+            _bytes = bytes;
+            _count = count;
+        }
+
+        public int Count => _count;
+
+        public Button this[int index] => index < _count
+            ? new Button (Util.IntToSilkButton(index), index, _bytes[index] != 0)
+            : throw new ArgumentOutOfRangeException();
+
+        public IEnumerator<Button> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private struct Enumerator : IEnumerator<Button>
+        {
+            private GlfwButtonCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwButtonCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Button(Util.IntToSilkButton(_current), _current, _col._bytes[_current] != 0);
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Button Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
new file mode 100644
index 0000000000..b7270b5b10
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
@@ -0,0 +1,38 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwGamepadCollection : IReadOnlyList<IGamepad>
+    {
+        private GlfwInputContext _ctx;
+
+        public GlfwGamepadCollection(GlfwInputContext ctx)
+        {
+            _ctx = ctx;
+        }
+        
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        IEnumerator<IGamepad> IEnumerable<IGamepad>.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        public IEnumerator<IGamepad> GetEnumerator()
+        {
+            return _ctx._gamepads.GetEnumerator();
+        }
+
+        public int Count => 16;
+
+        public IGamepad this[int i] => _ctx._gamepads[i];
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
new file mode 100644
index 0000000000..a2db2e64fe
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
@@ -0,0 +1,77 @@
+using Silk.NET.Input.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwHatCollection : IReadOnlyList<Hat>
+    {
+        public Position2D* _positions;
+        public int _count;
+
+        public GlfwHatCollection(Position2D* positions, int count)
+        {
+            _positions = positions;
+            _count = count;
+        }
+
+        public Hat this[int index] => index < _count
+            ? new Hat(index, _positions[index])
+            : throw new ArgumentOutOfRangeException();
+
+        public int Count => _count;
+
+        public IEnumerator<Hat> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private struct Enumerator : IEnumerator<Hat>
+        {
+            private GlfwHatCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwHatCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Hat(_current, _col._positions[_current]);
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Hat Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
new file mode 100644
index 0000000000..95936f1807
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
@@ -0,0 +1,38 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwJoystickCollection : IReadOnlyList<IJoystick>
+    {
+        private readonly GlfwInputContext _glfwInputContext;
+
+        public GlfwJoystickCollection(GlfwInputContext glfwInputContext)
+        {
+            _glfwInputContext = glfwInputContext;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        IEnumerator<IJoystick> IEnumerable<IJoystick>.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        public IEnumerator<IJoystick> GetEnumerator()
+        {
+            return _glfwInputContext._joysticks.GetEnumerator();
+        }
+
+        public int Count => 16;
+
+        public IJoystick this[int index] => _glfwInputContext._joysticks[index];
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwKeyboardCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwKeyboardCollection.cs
new file mode 100644
index 0000000000..5856362434
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwKeyboardCollection.cs
@@ -0,0 +1,70 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwKeyboardCollection : IReadOnlyList<IKeyboard>
+    {
+        private readonly GlfwInputContext _ctx;
+
+        public GlfwKeyboardCollection(GlfwInputContext ctx)
+        {
+            _ctx = ctx;
+        }
+        public IEnumerator<IKeyboard> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public int Count { get; } = 1;
+
+        public IKeyboard this[int index] => index == 0 ? _ctx._keyboard : throw new ArgumentOutOfRangeException();
+        
+        public struct Enumerator : IEnumerator<IKeyboard>
+        {
+            private readonly GlfwKeyboardCollection _col;
+            private bool _done;
+
+            public Enumerator(GlfwKeyboardCollection col)
+            {
+                _col = col;
+                _done = false;
+                Current = null;
+            }
+            
+            public bool MoveNext()
+            {
+                Current = _done ? null : _col._ctx._keyboard;
+                var ret = !_done;
+                _done = true;
+                return ret;
+            }
+
+            public void Reset()
+            {
+                _done = false;
+                Current = null;
+            }
+
+            public IKeyboard Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwMouseCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwMouseCollection.cs
new file mode 100644
index 0000000000..caacd166bd
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwMouseCollection.cs
@@ -0,0 +1,70 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwMouseCollection : IReadOnlyList<IMouse>
+    {
+        private readonly GlfwInputContext _ctx;
+
+        public GlfwMouseCollection(GlfwInputContext ctx)
+        {
+            _ctx = ctx;
+        }
+        public IEnumerator<IMouse> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public int Count { get; } = 1;
+
+        public IMouse this[int index] => index == 0 ? _ctx._mouse : throw new ArgumentOutOfRangeException();
+        
+        public struct Enumerator : IEnumerator<IMouse>
+        {
+            private readonly GlfwMouseCollection _col;
+            private bool _done;
+
+            public Enumerator(GlfwMouseCollection col)
+            {
+                _col = col;
+                _done = false;
+                Current = null;
+            }
+            
+            public bool MoveNext()
+            {
+                Current = _done ? null : _col._ctx._mouse;
+                var ret = !_done;
+                _done = true;
+                return ret;
+            }
+
+            public void Reset()
+            {
+                _done = false;
+                Current = null;
+            }
+
+            public IMouse Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
new file mode 100644
index 0000000000..293ccc9d00
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
@@ -0,0 +1,78 @@
+using Silk.NET.Input.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwThumbstickCollection : IReadOnlyList<Thumbstick>
+    {
+        private float* _x, _y;
+        private int _count;
+
+        public GlfwThumbstickCollection(float* x, float* y, int count)
+        {
+            _x = x;
+            _y = y;
+            _count = count;
+        }
+
+        public int Count => _count;
+
+        public Thumbstick this[int index] => index < _count
+            ? new Thumbstick(index, _x[index], _y[index])
+            : throw new ArgumentOutOfRangeException();
+
+        public IEnumerator<Thumbstick> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private struct Enumerator : IEnumerator<Thumbstick>
+        {
+            private GlfwThumbstickCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwThumbstickCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Thumbstick(_current, _col._x[_current], _col._y[_current]);
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Thumbstick Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
new file mode 100644
index 0000000000..0381895bce
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
@@ -0,0 +1,77 @@
+using Silk.NET.Input.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwTriggerCollection : IReadOnlyList<Trigger>
+    {
+        private float* _floats;
+        private int _count;
+
+        public GlfwTriggerCollection(float* floats, int count)
+        {
+            _count = count;
+            _floats = floats;
+        }
+
+        public Trigger this[int index] => index < Count
+            ? new Trigger(index, _floats[index])
+            : throw new ArgumentOutOfRangeException();
+
+        public int Count => _count;
+
+        public IEnumerator<Trigger> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private struct Enumerator : IEnumerator<Trigger>
+        {
+            private GlfwTriggerCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwTriggerCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Trigger(_current, _col._floats[_current]);
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Trigger Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwWheelCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwWheelCollection.cs
new file mode 100644
index 0000000000..224a8b7bd9
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwWheelCollection.cs
@@ -0,0 +1,78 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwWheelCollection : IReadOnlyList<ScrollWheel>
+    {
+        private GlfwMouse _mouse;
+
+        public GlfwWheelCollection(GlfwMouse mouse)
+        {
+            _mouse = mouse;
+        }
+
+        public ScrollWheel this[int index] => index != 0
+            ? _mouse._wheel
+            : throw new ArgumentOutOfRangeException();
+
+        public int Count { get; } = 1;
+
+        public IEnumerator<ScrollWheel> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private struct Enumerator : IEnumerator<ScrollWheel>
+        {
+            private GlfwWheelCollection _col;
+            private bool _done;
+
+            public Enumerator(GlfwWheelCollection col)
+            {
+                _col = col;
+                _done = false;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (!_done)
+                {
+                    Current = _col._mouse._wheel;
+                    _done = true;
+                    return true;
+                }
+
+                Current = default;
+                return false;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _done = false;
+            }
+
+            public ScrollWheel Current { get; private set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
new file mode 100644
index 0000000000..64a1f0caa8
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -0,0 +1,82 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+using Silk.NET.Windowing.Common;
+using Silk.NET.Windowing.Desktop;
+
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwInputContext : IInputContext
+    {
+        internal List<GlfwGamepad> _gamepads;
+        internal List<GlfwJoystick> _joysticks;
+        internal GlfwKeyboard _keyboard;
+        internal GlfwMouse _mouse;
+        internal GlfwWindow _window;
+
+        public GlfwInputContext(GlfwWindow window)
+        {
+            Handle = window.Handle;
+            _window = window;
+            InputHandler.RegisterContext(this);
+            
+            // initialize auto-properties
+            Gamepads = new GlfwGamepadCollection(this);
+            Joysticks = new GlfwJoystickCollection(this);
+            Keyboards = new GlfwKeyboardCollection(this);
+            Mice = new GlfwMouseCollection(this);
+
+            // initialize joysticks
+            _joysticks = new List<GlfwJoystick>(Enumerable.Range(0, 16).Select(i => new GlfwJoystick(i)));
+            _gamepads = new List<GlfwGamepad>(Enumerable.Range(0, 16).Select(i => new GlfwGamepad(i)));
+            _keyboard = new GlfwKeyboard(this);
+            _mouse = new GlfwMouse(this);
+        }
+
+        public IntPtr Handle { get; }
+        public IReadOnlyList<IGamepad> Gamepads { get; }
+        public IReadOnlyList<IJoystick> Joysticks { get; }
+        public IReadOnlyList<IKeyboard> Keyboards { get; }
+        public IReadOnlyList<IMouse> Mice { get; }
+        public IReadOnlyList<IInputDevice> OtherDevices { get; } = Array.Empty<IInputDevice>(); // not supported in GLFW
+
+        public void Dispose()
+        {
+            InputHandler.UnregisterContext(this);
+        }
+
+        ~GlfwInputContext()
+        {
+            Dispose();
+        }
+
+        public void WindowUpdate(double obj)
+        {
+            for (int i = 0; i < _joysticks.Count; i++)
+            {
+                _joysticks[i].Update();
+            }
+            for (int i = 0; i < _gamepads.Count; i++)
+            {
+                _gamepads[i].Update();
+            }
+        }
+        
+        /// <inheritdoc />
+        public event Action<IInputDevice, bool> ConnectionChanged;
+
+        public void RaiseConnectionChange(int joystick, ConnectedState state)
+        {
+            ConnectionChanged?.Invoke(Joysticks[joystick], state == ConnectedState.Connected);
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputPlatform.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputPlatform.cs
new file mode 100644
index 0000000000..ebcb6d1e61
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputPlatform.cs
@@ -0,0 +1,21 @@
+using System;
+using Silk.NET.Input.Common;
+using Silk.NET.Windowing.Common;
+using Silk.NET.Windowing.Desktop;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwInputPlatform : IInputPlatform
+    {
+        public bool IsApplicable(IWindow window)
+        {
+            return window is GlfwWindow;
+        }
+
+        public IInputContext GetInput(IWindow window)
+        {
+            // the cast isn't needed, but is used to make sure that what we've got is actually a GlfwWindow
+            return new GlfwInputContext((GlfwWindow)window);
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
new file mode 100644
index 0000000000..be6e2685ec
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -0,0 +1,129 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+using Ultz.Dispatcher.Unsafe;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwGamepad : IGamepad
+    {
+        private List<Button> _cachedButtons = new List<Button>();
+        private List<Thumbstick> _cachedThumbsticks = new List<Thumbstick>();
+        private List<Trigger> _cachedTriggers = new List<Trigger>();
+        public GlfwGamepad(int i)
+        {
+            Index = i;
+        }
+
+        public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
+        public int Index { get; }
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index) && Util.Glfw.JoystickIsGamepad(Index));
+        public IReadOnlyList<Button> Buttons => IsConnected ? GetButtons(Index) : null;
+        public IReadOnlyList<Thumbstick> Thumbsticks => IsConnected ? GetThumbsticks(Index) : null;
+        public IReadOnlyList<Trigger> Triggers => IsConnected ? GetTriggers(Index) : null;
+        public Deadzone Deadzone { get; set; }
+        public event Action<IGamepad, Button> ButtonDown;
+        public event Action<IGamepad, Button> ButtonUp;
+        public event Action<IGamepad, Thumbstick> ThumbstickMoved;
+        public event Action<IGamepad, Trigger> TriggerMoved;
+
+        public void Update()
+        {
+            if (!Util.Glfw.JoystickIsGamepad(Index))
+            {
+                return;
+            }
+
+            var buttons = Buttons;
+            for (var i = 0; i < buttons.Count; i++)
+            {
+                if (_cachedButtons.Count <= i)
+                {
+                    _cachedButtons[i] = default;
+                }
+                
+                if (buttons[i].Pressed != _cachedButtons[i].Pressed)
+                {
+                    _cachedButtons[i] = buttons[i];
+                    (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
+                }
+            }
+            
+            var thumbsticks = Thumbsticks;
+            for (var i = 0; i < thumbsticks.Count; i++)
+            {
+                if (_cachedThumbsticks.Count <= i)
+                {
+                    _cachedThumbsticks[i] = default;
+                }
+
+                if (thumbsticks[i].X != _cachedThumbsticks[i].X || thumbsticks[i].Y != _cachedThumbsticks[i].Y)
+                {
+                    _cachedThumbsticks[i] = thumbsticks[i];
+                    ThumbstickMoved?.Invoke(this, Util.ApplyDeadzone(thumbsticks[i], Deadzone));
+                }
+            }
+            
+            var triggers = Triggers;
+            for (var i = 0; i < triggers.Count; i++)
+            {
+                if (_cachedTriggers.Count <= i)
+                {
+                    _cachedTriggers[i] = default;
+                }
+
+                if (triggers[i].Position != _cachedTriggers[i].Position)
+                {
+                    _cachedTriggers[i] = triggers[i];
+                    TriggerMoved?.Invoke(this, triggers[i]);
+                }
+            }
+        }
+        private unsafe IReadOnlyList<Button> GetButtons(int i)
+        {
+            var count = 0;
+            var bytes = Util.Do(() => (UnsafeDispatch<byte>)Util.Glfw.GetJoystickButtons(i, out count));
+            if (count != _cachedButtons.Count)
+            {
+                _cachedButtons = new List<Button>();
+                _cachedButtons.AddRange(Enumerable.Range(0, count).Select(_ => (Button)default));
+            }
+            return new GlfwButtonCollection(bytes, count);
+        }
+        private unsafe IReadOnlyList<Thumbstick> GetThumbsticks(int i)
+        {
+            var count = 0;
+            var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            if (count != _cachedThumbsticks.Count)
+            {
+                _cachedThumbsticks = new List<Thumbstick>();
+                _cachedThumbsticks.AddRange(Enumerable.Range(0, count).Select(_ => (Thumbstick)default));
+            }
+            fixed(float* x = new[] { floats[0], floats[2] }, y = new[] { floats[1], floats[3] })
+            {
+                return new GlfwThumbstickCollection(x, y, count);
+            }
+        }
+        private unsafe IReadOnlyList<Trigger> GetTriggers(int i)
+        {
+            var count = 0;
+            var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            if (count != _cachedTriggers.Count)
+            {
+                _cachedTriggers = new List<Trigger>();
+                _cachedTriggers.AddRange(Enumerable.Range(0, count).Select(_ => (Trigger)default));
+            }
+            fixed(float* triggers = new float[] { floats[4], floats[5] })
+            {
+                return new GlfwTriggerCollection(triggers, count);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
new file mode 100644
index 0000000000..a2ef42522b
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -0,0 +1,94 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+using Ultz.Dispatcher.Unsafe;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwJoystick : IJoystick
+    {
+        private List<Axis> _cachedAxes = new List<Axis>();
+        private List<Button> _cachedButtons = new List<Button>();
+        private List<Hat> _cachedHats = new List<Hat>();
+        public GlfwJoystick(int i)
+        {
+            Index = i;
+        }
+
+        public string Name => Util.Do(() => Util.Glfw.GetJoystickName(Index));
+        public int Index { get; }
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index) && !Util.Glfw.JoystickIsGamepad(Index));
+        public IReadOnlyList<Axis> Axes => GetAxes(Index);
+        public IReadOnlyList<Button> Buttons => GetButtons(Index);
+        public IReadOnlyList<Hat> Hats => GetHats(Index);
+        public Deadzone Deadzone { get; set; }
+        public event Action<IJoystick, Button> ButtonDown;
+        public event Action<IJoystick, Button> ButtonUp;
+        public event Action<IJoystick, Axis> AxisMoved;
+        public event Action<IJoystick, Hat> HatMoved;
+
+        public void Update()
+        {
+            if (Util.Glfw.JoystickIsGamepad(Index))
+            {
+                return;
+            }
+
+            var axes = Axes;
+            for (var i = 0; i < axes.Count; i++)
+            {
+                if (axes[i].Position != (_cachedAxes.Count > i ? _cachedAxes[i] : axes[i]).Position)
+                {
+                    _cachedAxes[i] = axes[i];
+                    AxisMoved?.Invoke(this, Util.ApplyDeadzone(axes[i], Deadzone));
+                }
+            }
+            var buttons = Buttons;
+            for (var i = 0; i < buttons.Count; i++)
+            {
+                if (buttons[i].Pressed != (_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]).Pressed)
+                {
+                    _cachedButtons[i] = buttons[i];
+                    (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
+                }
+            }
+            var hats = Hats;
+            for (var i = 0; i < hats.Count; i++)
+            {
+                if (hats[i].Position != (_cachedHats.Count > i ? _cachedHats[i] : hats[i]).Position)
+                {
+                    _cachedHats[i] = hats[i];
+                    HatMoved?.Invoke(this, hats[i]);
+                }
+            }
+        }
+
+        private static unsafe IReadOnlyList<Axis> GetAxes(int i)
+        {
+            var count = 0;
+            var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            return new GlfwAxisCollection(floats, count);
+        }
+
+        private static unsafe IReadOnlyList<Button> GetButtons(int i)
+        {
+            var count = 0;
+            var bytes = Util.Do(() => (UnsafeDispatch<byte>)Util.Glfw.GetJoystickButtons(i, out count));
+            return new GlfwButtonCollection(bytes, count);
+        }
+
+        private static unsafe IReadOnlyList<Hat> GetHats(int i)
+        {
+            var count = 0;
+            var hats = Util.Do(() => (UnsafeDispatch<JoystickHats>)Util.Glfw.GetJoystickHats(i, out count));
+            return new GlfwHatCollection((Position2D*)hats, count);
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
new file mode 100644
index 0000000000..a71fd17d41
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
@@ -0,0 +1,49 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwKeyboard : IKeyboard
+    {
+        private GlfwInputContext _gic;
+
+        public GlfwKeyboard(GlfwInputContext gic)
+        {
+            _gic = gic;
+        }
+        public string Name { get; } = $"Silk.NET Keyboard (GLFW)";
+        public int Index { get; } = 0;
+        public bool IsConnected { get; } = true;
+        public IReadOnlyList<Key> SupportedKeys { get; } = Util.SupportedKeys;
+        public unsafe bool IsKeyPressed(Key key)
+        {
+            return Util.Do(() => Util.Glfw.GetKey((WindowHandle*)_gic._window.Handle, Util.SilkKeyToGlfwKey(key))) == 1;
+        }
+
+        public unsafe bool IsKeyPressed(uint scancode)
+        {
+            return Util.Do(() => Util.Glfw.GetKey((WindowHandle*)_gic._window.Handle, (Keys)scancode)) == 1;
+        }
+
+        public event Action<IKeyboard, Key> KeyDown;
+        public event Action<IKeyboard, Key> KeyUp;
+
+        internal void RaisePressEvent(Keys key, int scancode, KeyModifiers mods)
+        {
+            KeyDown?.Invoke(this, Util.GlfwKeyToSilkKey(key));
+        }
+
+        internal void RaiseReleaseEvent(Keys key, int scancode, KeyModifiers mods)
+        {
+            KeyUp?.Invoke(this, Util.GlfwKeyToSilkKey(key));
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
new file mode 100644
index 0000000000..b256508e9c
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
@@ -0,0 +1,54 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwMouse : IMouse
+    {
+        private List<MouseButton> _down = new List<MouseButton>();
+        internal ScrollWheel _wheel;
+        public GlfwMouse(GlfwInputContext inputContext)
+        {
+            ScrollWheels = new GlfwWheelCollection(this);
+        }
+
+        public string Name { get; } = "Silk.NET Mouse (GLFW)";
+        public int Index { get; } = 0;
+        public bool IsConnected { get; } = true;
+        public IReadOnlyList<MouseButton> SupportedButtons { get; } = Util.SupportedButtons;
+        public IReadOnlyList<ScrollWheel> ScrollWheels { get; }
+        public bool IsButtonPressed(MouseButton btn)
+        {
+            return _down.Contains(btn);
+        }
+
+        public event Action<IMouse, MouseButton> MouseDown;
+        public event Action<IMouse, MouseButton> MouseUp;
+        public event Action<IMouse, ScrollWheel> Scroll;
+
+        internal void RaiseMouseDown(MouseButton btn)
+        {
+            _down.Add(btn);
+            MouseDown?.Invoke(this, btn);
+        }
+
+        internal void RaiseMouseUp(MouseButton btn)
+        {
+            _down.Remove(btn);
+            MouseUp?.Invoke(this, btn);
+        }
+
+        internal void RaiseScroll(ScrollWheel wheel)
+        {
+            _wheel = wheel;
+            Scroll?.Invoke(this, wheel);
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
new file mode 100644
index 0000000000..a9b6f42d39
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
@@ -0,0 +1,123 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+using MouseButton = Silk.NET.GLFW.MouseButton;
+
+namespace Silk.NET.Input.Desktop
+{
+    internal class InputHandler
+    {
+        public static List<GlfwInputContext> Contexts { get; }
+        
+        static InputHandler()
+        {
+            Contexts = new List<GlfwInputContext>();
+            Util.Do(() => Util.Glfw.SetJoystickCallback(JoystickCallback));
+        }
+
+        public static unsafe void RegisterContext(GlfwInputContext ctx)
+        {
+            if (Contexts.Any(x => x._window == ctx._window))
+            {
+                return;
+            }
+            
+            Contexts.Add(ctx);
+
+            // register callbacks
+            var handle = (WindowHandle*) ctx._window.Handle;
+            Util.Do(() => Util.Glfw.SetKeyCallback(handle, KeyCallback));
+            Util.Do(() => Util.Glfw.SetMouseButtonCallback(handle, MouseCallback));
+            Util.Do(() => Util.Glfw.SetScrollCallback(handle, ScrollCallback));
+            ctx._window.OnUpdate += ctx.WindowUpdate;
+        }
+
+        private static unsafe void ScrollCallback(WindowHandle* window, double offsetx, double offsety)
+        {
+            // run on a separate thread to prevent deadlocks on single-threaded windows
+            Task.Run
+            (
+                () =>
+                {
+                    // multiple contexts for one window should be allowed, but frowned upon
+                    var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+
+                    foreach (var context in allContexts)
+                    {
+                        ((GlfwMouse) context._mouse).RaiseScroll(new ScrollWheel((float) offsetx, (float) offsety));
+                    }
+                }
+            );
+        }
+
+        private static void JoystickCallback(int joystick, ConnectedState state)
+        {
+            // run on a separate thread to prevent deadlocks on single-threaded windows
+            Task.Run(() => Contexts.ForEach(x => x.RaiseConnectionChange(joystick, state)));
+        }
+
+        private static unsafe void MouseCallback(WindowHandle* window, MouseButton button, InputAction action, KeyModifiers mods)
+        {
+            // run on a separate thread to prevent deadlocks on single-threaded windows
+            Task.Run
+            (
+                () =>
+                {
+                    // multiple contexts for one window should be allowed, but frowned upon
+                    var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+
+                    foreach (var context in allContexts)
+                    {
+                        if (action == InputAction.Press)
+                        {
+                            ((GlfwMouse) context._mouse).RaiseMouseDown(Util.GlfwButtonToSilkButton(button));
+                        }
+                        else if (action == InputAction.Release)
+                        {
+                            ((GlfwMouse) context._mouse).RaiseMouseUp(Util.GlfwButtonToSilkButton(button));
+                        }
+                    }
+                }
+            );
+        }
+
+        private static unsafe void KeyCallback(WindowHandle* window, Keys key, int scancode, InputAction action, KeyModifiers mods)
+        {
+            // run on a separate thread to prevent deadlocks on single-threaded windows
+            Task.Run
+            (
+                () =>
+                {
+                    // multiple contexts for one window should be allowed, but frowned upon
+                    var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+
+                    foreach (var context in allContexts)
+                    {
+                        if (action == InputAction.Press)
+                        {
+                            ((GlfwKeyboard) context._keyboard).RaisePressEvent(key, scancode, mods);
+                        }
+                        else if (action == InputAction.Release)
+                        {
+                            ((GlfwKeyboard) context._keyboard).RaiseReleaseEvent(key, scancode, mods);
+                        }
+                    }
+                }
+            );
+        }
+
+        public static void UnregisterContext(GlfwInputContext ctx)
+        {
+            Contexts.Remove(ctx);
+            ctx._window.OnUpdate -= ctx.WindowUpdate;
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj b/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj
new file mode 100644
index 0000000000..7b36b0dfae
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+        <LangVersion>latest</LangVersion>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\Windowing\Silk.NET.Windowing.Desktop\Silk.NET.Windowing.Desktop.csproj" />
+      <ProjectReference Include="..\Silk.NET.Input.Common\Silk.NET.Input.Common.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="System.Memory" Version="4.5.3" />
+    </ItemGroup>
+    
+    <Import Project="..\..\..\build\props\common.props" />
+
+</Project>
diff --git a/src/Input/Silk.NET.Input.Desktop/Util.cs b/src/Input/Silk.NET.Input.Desktop/Util.cs
new file mode 100644
index 0000000000..6e7135e2d9
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Util.cs
@@ -0,0 +1,112 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Linq;
+using System.Threading;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+using Ultz.Dispatcher.Unsafe;
+using MouseButton = Silk.NET.Input.Common.MouseButton;
+
+namespace Silk.NET.Input.Desktop
+{
+    internal static class Util
+    {
+        private static string[] _glfwKeys = Enum.GetNames(typeof(Keys));
+        private static string[] _glfwButtons = Enum.GetNames(typeof(GLFW.MouseButton));
+        public static object Do(Delegate @delegate)
+        {
+            return GlfwProvider.ThreadDispatcher.Invoke(@delegate);
+        }
+        
+        public static void Do(Action @delegate)
+        {
+            GlfwProvider.ThreadDispatcher.Invoke(@delegate);
+        }
+
+        public static T Do<T>(Func<T> @delegate)
+        {
+            return GlfwProvider.ThreadDispatcher.Invoke(@delegate);
+        }
+
+        public static unsafe T* Do<T>(Func<UnsafeDispatch<T>> @delegate)
+            where T:unmanaged
+        {
+            return GlfwProvider.ThreadDispatcher.Invoke(@delegate);
+        }
+
+        public static Glfw Glfw => GlfwProvider.GLFW.Value;
+        public static Key[] SupportedKeys { get; } // this is expensive, but only runs once.
+            = Enum.GetNames(typeof(Key)).Where(_glfwKeys.Contains).Select(StringToSilkKey).ToArray();
+        public static MouseButton[] SupportedButtons { get; } // this is expensive, but only runs once.
+            = Enum.GetNames(typeof(MouseButton)).Where(_glfwButtons.Contains).Select(StringToSilkButton).ToArray();
+
+        public static Key StringToSilkKey(string s)
+        {
+            if (Enum.TryParse<Key>(s, out var k))
+            {
+                return k;
+            }
+            throw new ArgumentOutOfRangeException(nameof(s), $"Key name mismatch (couldn't find a Key value for {s})");
+        }
+        
+        public static ButtonName IntToSilkButton(int i)
+        {
+            var s = ((GamepadButton) i).ToString();
+            if (Enum.TryParse<ButtonName>(s, out var k))
+            {
+                return k;
+            }
+            throw new ArgumentOutOfRangeException(nameof(s), $"Button name mismatch (couldn't find a ButtonName value for {s})");
+        }
+
+        public static Keys SilkKeyToGlfwKey(Key k)
+        {
+            if (Enum.TryParse<Keys>(k.ToString(), out var gk))
+            {
+                return gk;
+            }
+            throw new ArgumentOutOfRangeException(nameof(k));
+        }
+
+        public static Key GlfwKeyToSilkKey(Keys k)
+        {
+            if (Enum.TryParse<Key>(k.ToString(), out var sk))
+            {
+                return sk;
+            }
+            throw new ArgumentOutOfRangeException(nameof(k));
+        }
+
+        public static MouseButton StringToSilkButton(string s)
+        {
+            if (Enum.TryParse<MouseButton>(s, out var k))
+            {
+                return k;
+            }
+            throw new ArgumentOutOfRangeException(nameof(s), $"Button name mismatch (couldn't find a MouseButton value for {s})");
+        }
+
+        public static MouseButton GlfwButtonToSilkButton(GLFW.MouseButton k)
+        {
+            if (Enum.TryParse<MouseButton>(k.ToString(), out var sk))
+            {
+                return sk;
+            }
+            throw new ArgumentOutOfRangeException(nameof(k));
+        }
+
+        public static Thumbstick ApplyDeadzone(Thumbstick thumbstick, Deadzone deadzone)
+        {
+            return new Thumbstick(thumbstick.Index, deadzone.Apply(thumbstick.X), deadzone.Apply(thumbstick.Y));
+        }
+
+        public static Axis ApplyDeadzone(Axis axis, Deadzone deadzone)
+        {
+            return new Axis(axis.Index, deadzone.Apply(axis.Position));
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input/InputWindowExtensions.cs b/src/Input/Silk.NET.Input/InputWindowExtensions.cs
new file mode 100644
index 0000000000..6adf5f8569
--- /dev/null
+++ b/src/Input/Silk.NET.Input/InputWindowExtensions.cs
@@ -0,0 +1,38 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop;
+using Silk.NET.Windowing.Common;
+
+namespace Silk.NET.Input
+{
+    public static class InputWindowExtensions
+    {
+        private static List<IInputPlatform> _platforms = new List<IInputPlatform>();
+        static InputWindowExtensions()
+        {
+            RegisterInputPlatform(new GlfwInputPlatform());
+        }
+        public static void RegisterInputPlatform(IInputPlatform platform)
+        {
+            _platforms.Add(platform);
+        }
+
+        public static void UnregisterInputPlatform(IInputPlatform platform)
+        {
+            _platforms.Remove(platform);
+        }
+
+        public static IInputContext GetInput(this IWindow window)
+        {
+            return _platforms.FirstOrDefault(x => x.IsApplicable(window))?.GetInput(window) 
+                ?? throw new NotSupportedException("Couldn't find a suitable input platform for this window.");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input/Silk.NET.Input.csproj b/src/Input/Silk.NET.Input/Silk.NET.Input.csproj
new file mode 100644
index 0000000000..d4d8837c01
--- /dev/null
+++ b/src/Input/Silk.NET.Input/Silk.NET.Input.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Silk.NET.Input.Common\Silk.NET.Input.Common.csproj" />
+      <ProjectReference Include="..\Silk.NET.Input.Desktop\Silk.NET.Input.Desktop.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/src/Windowing/Silk.NET.GLFW/Enums/GamepadButton.cs b/src/Windowing/Silk.NET.GLFW/Enums/GamepadButton.cs
new file mode 100644
index 0000000000..d4e2390869
--- /dev/null
+++ b/src/Windowing/Silk.NET.GLFW/Enums/GamepadButton.cs
@@ -0,0 +1,26 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+namespace Silk.NET.GLFW
+{
+    public enum GamepadButton
+    {
+        A,
+        B,
+        X,
+        Y,
+        LeftBumper,
+        RightBumper,
+        Back,
+        Start,
+        Home,
+        LeftStick,
+        RightStick,
+        DPadUp,
+        DPadRight,
+        DPadDown,
+        DPadLeft
+    }
+}
diff --git a/src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs b/src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs
index 12678cb420..b2c74f74cc 100644
--- a/src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs
+++ b/src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs
@@ -14,12 +14,12 @@ public enum InputAction
         /// <summary>
         /// The key or mouse button was pressed.
         /// </summary>
-        Press = 0,
+        Press = 1,
 
         /// <summary>
         /// The key or mouse button was released.
         /// </summary>
-        Release = 1,
+        Release = 0,
 
         /// <summary>
         /// The key was held down until it repeated.
diff --git a/src/Windowing/Silk.NET.GLFW/Enums/Keys.cs b/src/Windowing/Silk.NET.GLFW/Enums/Keys.cs
index 8b2d8a7edf..66fe86819c 100644
--- a/src/Windowing/Silk.NET.GLFW/Enums/Keys.cs
+++ b/src/Windowing/Silk.NET.GLFW/Enums/Keys.cs
@@ -573,42 +573,42 @@ public enum Keys
         /// <summary>
         /// The left shift key.
         /// </summary>
-        LeftShift = 340,
+        ShiftLeft = 340,
 
         /// <summary>
         /// The left control key.
         /// </summary>
-        LeftControl = 341,
+        ControlLeft = 341,
 
         /// <summary>
         /// The left alt key.
         /// </summary>
-        LeftAlt = 342,
+        AltLeft = 342,
 
         /// <summary>
         /// The left super key.
         /// </summary>
-        LeftSuper = 343,
+        SuperLeft = 343,
 
         /// <summary>
         /// The right shift key.
         /// </summary>
-        RightShift = 344,
+        ShiftRight = 344,
 
         /// <summary>
         /// The right control key.
         /// </summary>
-        RightControl = 345,
+        ControlRight = 345,
 
         /// <summary>
         /// The right alt key.
         /// </summary>
-        RightAlt = 346,
+        AltRight = 346,
 
         /// <summary>
         /// The right super key.
         /// </summary>
-        RightSuper = 347,
+        SuperRight = 347,
 
         /// <summary>
         /// The menu key.
diff --git a/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs b/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
index 3d4e3d8756..11cbeb5742 100644
--- a/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
+++ b/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
@@ -10,17 +10,13 @@ namespace Silk.NET.GLFW
     /// </summary>
     public enum MouseButton
     {
-        MouseButton1 = 0,
-        MouseButton2,
-        MouseButton3,
-        MouseButton4,
-        MouseButton5,
-        MouseButton6,
-        MouseButton7,
-        MouseButton8,
-        MouseButtonLast = MouseButton8,
-        MouseButtonLeft = MouseButton1,
-        MouseButtonRight = MouseButton2,
-        MouseButtonMiddle = MouseButton3
+        Left = 0,
+        Right,
+        Middle,
+        Button4,
+        Button5,
+        Button6,
+        Button7,
+        Button8
     }
 }
\ No newline at end of file
diff --git a/src/Windowing/Silk.NET.GLFW/Glfw.cs b/src/Windowing/Silk.NET.GLFW/Glfw.cs
index 10783e80fc..a6fea84398 100644
--- a/src/Windowing/Silk.NET.GLFW/Glfw.cs
+++ b/src/Windowing/Silk.NET.GLFW/Glfw.cs
@@ -125,7 +125,7 @@ public abstract unsafe void GetWindowFrameSize(WindowHandle* window, out int lef
         public abstract int GetKeyScancode(int key);
 
         /// <inheritdoc />
-        public abstract unsafe int GetKey(WindowHandle* window, int key);
+        public abstract unsafe int GetKey(WindowHandle* window, Keys key);
 
         /// <inheritdoc />
         public abstract unsafe int GetMouseButton(WindowHandle* window, int button);
diff --git a/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs b/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
index 6da83af415..82b78d55c8 100644
--- a/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
+++ b/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
@@ -981,7 +981,7 @@ public interface IGlfw
         /// Possible errors include <see cref="ErrorCode.NotInitialized" /> and <see cref="ErrorCode.InvalidEnum" />.
         /// </para>
         /// </remarks>
-        unsafe int GetKey(WindowHandle* window, int key);
+        unsafe int GetKey(WindowHandle* window, Keys key);
 
         /// <summary>
         /// <para>
@@ -2336,7 +2336,7 @@ public interface IGlfw
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        unsafe GlfwCallbacks.CharCallback SetCharCallback(WindowHandle* window, GlfwCallbacks.CharCallback callback);
+        unsafe GlfwCallbacks.CharCallback SetCharCallback(WindowHandle* window, [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.CharCallback callback);
 
         /// <summary>
         /// <para>
@@ -2369,7 +2369,7 @@ public interface IGlfw
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.CharModsCallback SetCharModsCallback(WindowHandle* window,
-            GlfwCallbacks.CharModsCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.CharModsCallback callback);
 
         /// <summary>
         /// <para>
@@ -2412,7 +2412,7 @@ unsafe GlfwCallbacks.CharModsCallback SetCharModsCallback(WindowHandle* window,
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.CursorEnterCallback SetCursorEnterCallback(WindowHandle* window,
-            GlfwCallbacks.CursorEnterCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.CursorEnterCallback callback);
 
         /// <summary>
         /// <para>
@@ -2438,7 +2438,7 @@ unsafe GlfwCallbacks.CursorEnterCallback SetCursorEnterCallback(WindowHandle* wi
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window,
-            GlfwCallbacks.CursorPosCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.CursorPosCallback callback);
 
         /// <summary>
         /// <para>
@@ -2464,7 +2464,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        unsafe GlfwCallbacks.DropCallback SetDropCallback(WindowHandle* window, GlfwCallbacks.DropCallback callback);
+        unsafe GlfwCallbacks.DropCallback SetDropCallback(WindowHandle* window, [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.DropCallback callback);
 
         /// <summary>
         /// <para>
@@ -2494,7 +2494,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// This function must only be called from the main thread.
         /// </para>
         /// </remarks>
-        GlfwCallbacks.ErrorCallback SetErrorCallback(GlfwCallbacks.ErrorCallback callback);
+        GlfwCallbacks.ErrorCallback SetErrorCallback([DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.ErrorCallback callback);
 
         /// <summary>
         /// <para>
@@ -2583,7 +2583,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        GlfwCallbacks.JoystickCallback SetJoystickCallback(GlfwCallbacks.JoystickCallback callback);
+        GlfwCallbacks.JoystickCallback SetJoystickCallback([DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.JoystickCallback callback);
 
         /// <summary>
         /// <para>
@@ -2624,7 +2624,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        unsafe GlfwCallbacks.KeyCallback SetKeyCallback(WindowHandle* window, GlfwCallbacks.KeyCallback callback);
+        unsafe GlfwCallbacks.KeyCallback SetKeyCallback(WindowHandle* window, [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.KeyCallback callback);
 
         /// <summary>
         /// <para>
@@ -2649,7 +2649,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.ScrollCallback SetScrollCallback(WindowHandle* window,
-            GlfwCallbacks.ScrollCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.ScrollCallback callback);
 
         /// <summary>
         /// <para>
@@ -2669,7 +2669,7 @@ unsafe GlfwCallbacks.ScrollCallback SetScrollCallback(WindowHandle* window,
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        GlfwCallbacks.MonitorCallback SetMonitorCallback(GlfwCallbacks.MonitorCallback callback);
+        GlfwCallbacks.MonitorCallback SetMonitorCallback([DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.MonitorCallback callback);
 
         /// <summary>
         /// <para>
@@ -2698,7 +2698,7 @@ unsafe GlfwCallbacks.ScrollCallback SetScrollCallback(WindowHandle* window,
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.MouseButtonCallback SetMouseButtonCallback(WindowHandle* window,
-            GlfwCallbacks.MouseButtonCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.MouseButtonCallback callback);
 
         /// <summary>
         /// <para>
@@ -2731,7 +2731,7 @@ unsafe GlfwCallbacks.MouseButtonCallback SetMouseButtonCallback(WindowHandle* wi
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowCloseCallback SetWindowCloseCallback(WindowHandle* window,
-            GlfwCallbacks.WindowCloseCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowCloseCallback callback);
 
         /// <summary>
         /// <para>
@@ -2758,7 +2758,7 @@ unsafe GlfwCallbacks.WindowCloseCallback SetWindowCloseCallback(WindowHandle* wi
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowFocusCallback SetWindowFocusCallback(WindowHandle* window,
-            GlfwCallbacks.WindowFocusCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowFocusCallback callback);
 
         /// <summary>
         /// <para>
@@ -2813,7 +2813,7 @@ unsafe GlfwCallbacks.WindowFocusCallback SetWindowFocusCallback(WindowHandle* wi
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowIconifyCallback SetWindowIconifyCallback(WindowHandle* window,
-            GlfwCallbacks.WindowIconifyCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowIconifyCallback callback);
 
         /// <summary>
         /// <para>
@@ -2835,7 +2835,7 @@ unsafe GlfwCallbacks.WindowIconifyCallback SetWindowIconifyCallback(WindowHandle
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowMaximizeCallback SetWindowMaximizeCallback(WindowHandle* window,
-            GlfwCallbacks.WindowMaximizeCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowMaximizeCallback callback);
 
         /// <summary>
         /// <para>
@@ -2936,7 +2936,7 @@ unsafe void SetWindowMonitor(WindowHandle* window, Monitor* monitor, int x, int
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowPosCallback SetWindowPosCallback(WindowHandle* window,
-            GlfwCallbacks.WindowPosCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowPosCallback callback);
 
         /// <summary>
         /// <para>
@@ -2967,7 +2967,7 @@ unsafe GlfwCallbacks.WindowPosCallback SetWindowPosCallback(WindowHandle* window
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowRefreshCallback SetWindowRefreshCallback(WindowHandle* window,
-            GlfwCallbacks.WindowRefreshCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowRefreshCallback callback);
 
         /// <summary>
         /// <para>
@@ -3026,7 +3026,7 @@ unsafe GlfwCallbacks.WindowRefreshCallback SetWindowRefreshCallback(WindowHandle
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowSizeCallback SetWindowSizeCallback(WindowHandle* window,
-            GlfwCallbacks.WindowSizeCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowSizeCallback callback);
 
         /// <summary>
         /// <para>
diff --git a/src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj b/src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj
index 5a756f42b1..1afec9161a 100644
--- a/src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj
+++ b/src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj
@@ -7,7 +7,6 @@
     </PropertyGroup>
     
     <ItemGroup>
-      <PackageReference Include="AdvancedDLSupport" Version="3.0.0" />
       <PackageReference Include="Ultz.Dispatcher" Version="1.1.0" />
     </ItemGroup>
 
diff --git a/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs b/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
index 4b833767c5..093bd055fc 100644
--- a/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
+++ b/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
@@ -47,7 +47,7 @@ public class GlfwWindow : IWindow
         private GlfwCallbacks.WindowSizeCallback onResize;
 
         // Main loop-related things
-        
+
         // The stopwatches. Used to calculate delta.
         private Stopwatch renderStopwatch;
         private Stopwatch updateStopwatch;
@@ -55,95 +55,38 @@ public class GlfwWindow : IWindow
         // Invoke method variables
         private ConcurrentQueue<Task> InvokeQueue;
         private int MainThread = -1;
-        
+
         // Update and render period. Represents the time in seconds that each frame should take.
         private double updatePeriod;
         private double renderPeriod;
 
+        private WindowOptions initialOptions;
+        private bool running;
+
         /// <summary>
         /// Create and open a new GlfwWindow.
         /// </summary>
         /// <param name="options">The options to use for this window.</param>
         public GlfwWindow(WindowOptions options)
         {
-            unsafe {
+            unsafe
+            {
                 // Title and Size must be set before the window is created.
                 _title = options.Title;
                 _size = options.Size;
 
                 _windowBorder = WindowBorder;
 
-                glfwThread.Invoke(() =>
-                {
-                    // Set window border.
-                    switch (options.WindowBorder) {
-                        case WindowBorder.Hidden:
-                            glfw.WindowHint(WindowHintBool.Decorated, false);
-                            glfw.WindowHint(WindowHintBool.Resizable, false);
-                            break;
-
-                        case WindowBorder.Resizable:
-                            glfw.WindowHint(WindowHintBool.Decorated, true);
-                            glfw.WindowHint(WindowHintBool.Resizable, true);
-                            break;
-
-                        case WindowBorder.Fixed:
-                            glfw.WindowHint(WindowHintBool.Decorated, true);
-                            glfw.WindowHint(WindowHintBool.Resizable, false);
-                            break;
-                    }
-
-                    // Set window API.
-                    switch (options.API.API) {
-                        case ContextAPI.None:
-                        case ContextAPI.Vulkan:
-                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.NoApi);
-                            break;
-                        case ContextAPI.OpenGL:
-                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.OpenGL);
-                            break;
-                        case ContextAPI.OpenGLES:
-                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.OpenGLES);
-                            break;
-                    }
-
-                    // Set API version.
-                    glfw.WindowHint(WindowHintInt.ContextVersionMajor, options.API.Version.MajorVersion);
-                    glfw.WindowHint(WindowHintInt.ContextVersionMinor, options.API.Version.MinorVersion);
-
-                    // Set API flags
-                    if (options.API.Flags.HasFlag(ContextFlags.ForwardCompatible)) {
-                        glfw.WindowHint(WindowHintBool.OpenGLForwardCompat, true);
-                    }
-
-                    if (options.API.Flags.HasFlag(ContextFlags.Debug)) {
-                        glfw.WindowHint(WindowHintBool.OpenGLDebugContext, true);
-                    }
-
-                    // Set API profile
-                    glfw.WindowHint(WindowHintOpenGlProfile.OpenGlProfile,
-                        options.API.Profile == ContextProfile.Core ? OpenGlProfile.Core : OpenGlProfile.Compat);
-
-                    // Create window
-                    WindowPtr = glfw.CreateWindow(_size.Width, _size.Height, _title, null, null);
-                });
-            
-                InvokeQueue = new ConcurrentQueue<Task>();
-                MainThread = Thread.CurrentThread.ManagedThreadId;
-
-                glfw.MakeContextCurrent(WindowPtr);
-
                 FramesPerSecond = options.FramesPerSecond;
                 UpdatesPerSecond = options.UpdatesPerSecond;
 
-                WindowState = options.WindowState;
-                Position = options.Position;
-                VSync = options.VSync;
                 RunningSlowTolerance = options.RunningSlowTolerance;
                 UseSingleThreadedWindow = options.UseSingleThreadedWindow;
+
+                initialOptions = options;
             }
         }
-        
+
         /// <inheritdoc />
         public int RunningSlowTolerance { get; set; }
 
@@ -155,23 +98,38 @@ public bool IsVisible
         {
             get
             {
-                unsafe {
-                    return glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Visible);
+                unsafe
+                {
+                    return running
+                        ? glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Visible)
+                        : initialOptions.IsVisible;
                 }
             }
             set
             {
-                glfwThread.Invoke(() =>
+                if (running)
                 {
-                    unsafe {
-                        if (value) {
-                            glfw.ShowWindow(WindowPtr);
-                        }
-                        else {
-                            glfw.HideWindow(WindowPtr);
+                    glfwThread.Invoke
+                    (
+                        () =>
+                        {
+                            Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
+                            unsafe
+                            {
+                                if (value)
+                                {
+                                    glfw.ShowWindow(WindowPtr);
+                                }
+                                else
+                                {
+                                    glfw.HideWindow(WindowPtr);
+                                }
+                            }
                         }
-                    }
-                });
+                    );
+                }
+
+                initialOptions.IsVisible = value;
             }
         }
 
@@ -180,8 +138,9 @@ public IntPtr Handle
         {
             get
             {
-                unsafe {
-                    return (IntPtr) WindowPtr;
+                unsafe
+                {
+                    return running ? (IntPtr) WindowPtr : IntPtr.Zero;
                 }
             }
         }
@@ -195,14 +154,22 @@ public Point Position
             get => _position;
             set
             {
-                glfwThread.Invoke(() =>
+                if (running)
                 {
-                    unsafe {
-                        glfw.SetWindowPos(WindowPtr, value.X, value.Y);
-                    }
-                });
+                    glfwThread.Invoke
+                    (
+                        () =>
+                        {
+                            unsafe
+                            {
+                                glfw.SetWindowPos(WindowPtr, value.X, value.Y);
+                            }
+                        }
+                    );
+                }
 
                 _position = value;
+                initialOptions.Position = value;
             }
         }
 
@@ -212,13 +179,21 @@ public Size Size
             get => _size;
             set
             {
-                glfwThread.Invoke(() =>
+                if (running)
                 {
-                    unsafe {
-                        glfw.SetWindowSize(WindowPtr, value.Width, value.Height);
-                    }
-                });
+                    glfwThread.Invoke
+                    (
+                        () =>
+                        {
+                            unsafe
+                            {
+                                glfw.SetWindowSize(WindowPtr, value.Width, value.Height);
+                            }
+                        }
+                    );
+                }
 
+                initialOptions.Size = value;
                 _size = value;
             }
         }
@@ -229,11 +204,12 @@ public double FramesPerSecond
             get => 1.0 / renderPeriod;
             set
             {
-                if (value <= double.Epsilon) {
+                if (value <= double.Epsilon)
+                {
                     renderPeriod = 0.0;
                     return;
                 }
-                
+
                 renderPeriod = 1.0 / value;
             }
         }
@@ -244,10 +220,12 @@ public double UpdatesPerSecond
             get => 1.0 / updatePeriod;
             set
             {
-                if (value <= double.Epsilon) {
+                if (value <= double.Epsilon)
+                {
                     updatePeriod = 0.0;
                     return;
                 }
+
                 updatePeriod = 1.0 / value;
             }
         }
@@ -261,13 +239,21 @@ public string Title
             get => _title;
             set
             {
-                glfwThread.Invoke(() =>
+                if (running)
                 {
-                    unsafe {
-                        glfw.SetWindowTitle(WindowPtr, value);
-                    }
-                });
+                    glfwThread.Invoke
+                    (
+                        () =>
+                        {
+                            unsafe
+                            {
+                                glfw.SetWindowTitle(WindowPtr, value);
+                            }
+                        }
+                    );
+                }
 
+                initialOptions.Title = value;
                 _title = value;
             }
         }
@@ -278,29 +264,41 @@ public WindowState WindowState
             get => _windowState;
             set
             {
-                glfwThread.Invoke(() =>
+                if (running)
                 {
-                    unsafe {
-                        switch (value) {
-                            case WindowState.Normal:
-                                glfw.RestoreWindow(WindowPtr);
-                                break;
-                            case WindowState.Minimized:
-                                glfw.IconifyWindow(WindowPtr);
-                                break;
-                            case WindowState.Maximized:
-                                glfw.MaximizeWindow(WindowPtr);
-                                break;
-                            case WindowState.Fullscreen:
-                                var monitor = glfw.GetPrimaryMonitor();
-                                var mode = glfw.GetVideoMode(monitor);
-                                glfw.SetWindowMonitor(WindowPtr, monitor, 0, 0, mode->Width, mode->Height,
-                                    mode->RefreshRate);
-                                break;
+                    glfwThread.Invoke
+                    (
+                        () =>
+                        {
+                            unsafe
+                            {
+                                switch (value)
+                                {
+                                    case WindowState.Normal:
+                                        glfw.RestoreWindow(WindowPtr);
+                                        break;
+                                    case WindowState.Minimized:
+                                        glfw.IconifyWindow(WindowPtr);
+                                        break;
+                                    case WindowState.Maximized:
+                                        glfw.MaximizeWindow(WindowPtr);
+                                        break;
+                                    case WindowState.Fullscreen:
+                                        var monitor = glfw.GetPrimaryMonitor();
+                                        var mode = glfw.GetVideoMode(monitor);
+                                        glfw.SetWindowMonitor
+                                        (
+                                            WindowPtr, monitor, 0, 0, mode->Width, mode->Height,
+                                            mode->RefreshRate
+                                        );
+                                        break;
+                                }
+                            }
                         }
-                    }
-                });
+                    );
+                }
 
+                initialOptions.WindowState = value;
                 _windowState = value;
             }
         }
@@ -310,29 +308,38 @@ public WindowBorder WindowBorder
         {
             get => _windowBorder;
             set
-            {   
-                glfwThread.Invoke(() =>
+            {
+                if (running)
                 {
-                    unsafe {
-                        switch (value) {
-                            case WindowBorder.Hidden:
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, false);
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
-                                break;
-
-                            case WindowBorder.Resizable:
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, true);
-                                break;
-
-                            case WindowBorder.Fixed:
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
-                                break;
+                    glfwThread.Invoke
+                    (
+                        () =>
+                        {
+                            unsafe
+                            {
+                                switch (value)
+                                {
+                                    case WindowBorder.Hidden:
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, false);
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
+                                        break;
+
+                                    case WindowBorder.Resizable:
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, true);
+                                        break;
+
+                                    case WindowBorder.Fixed:
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
+                                        break;
+                                }
+                            }
                         }
-                    }
-                });
+                    );
+                }
 
+                initialOptions.WindowBorder = value;
                 _windowBorder = value;
             }
         }
@@ -343,28 +350,33 @@ public VSyncMode VSync
             get => _vSync;
             set
             {
-                this.Invoke
-                (
-                    () =>
-                    {
-                        switch (value)
+                if (running)
+                {
+                    this.Invoke
+                    (
+                        () =>
                         {
-                            case VSyncMode.Off:
-                                glfw.SwapInterval(0);
-                                break;
-
-                            case VSyncMode.On:
-                                glfw.SwapInterval(1);
-                                break;
-
-                            default:
-                                glfw.SwapInterval(IsRunningSlowly ? 0 : 1);
-                                break;
+                            switch (value)
+                            {
+                                case VSyncMode.Off:
+                                    glfw.SwapInterval(0);
+                                    break;
+
+                                case VSyncMode.On:
+                                    glfw.SwapInterval(1);
+                                    break;
+
+                                default:
+                                    glfw.SwapInterval(IsRunningSlowly ? 0 : 1);
+                                    break;
+                            }
+
+                            _vSync = value;
                         }
-
-                        _vSync = value;
-                    }
-                );
+                    );
+                }
+                initialOptions.VSync = value;
+                _vSync = value;
             }
         }
 
@@ -377,11 +389,16 @@ public object Invoke(Delegate d)
         /// <inheritdoc />
         public object Invoke(Delegate d, params object[] args)
         {
-            if (UseSingleThreadedWindow || Thread.CurrentThread.ManagedThreadId == MainThread)
+            if (!running)
             {
-                return d.DynamicInvoke(args);
+                throw new InvalidOperationException("The window must be running to be able to invoke it.");
             }
             
+            if (Thread.CurrentThread.ManagedThreadId == MainThread)
+            {
+                return d.DynamicInvoke(args);
+            }
+
             var task = new Task<object>(() => d.DynamicInvoke(args));
             InvokeQueue.Enqueue(task);
             SpinWait.SpinUntil(() => task.IsCompleted);
@@ -391,6 +408,79 @@ public object Invoke(Delegate d, params object[] args)
         /// <inheritdoc />
         public unsafe void Run()
         {
+            running = true;
+            glfwThread.Invoke
+            (
+                () =>
+                {
+                    // Set window border.
+                    switch (initialOptions.WindowBorder)
+                    {
+                        case WindowBorder.Hidden:
+                            glfw.WindowHint(WindowHintBool.Decorated, false);
+                            glfw.WindowHint(WindowHintBool.Resizable, false);
+                            break;
+
+                        case WindowBorder.Resizable:
+                            glfw.WindowHint(WindowHintBool.Decorated, true);
+                            glfw.WindowHint(WindowHintBool.Resizable, true);
+                            break;
+
+                        case WindowBorder.Fixed:
+                            glfw.WindowHint(WindowHintBool.Decorated, true);
+                            glfw.WindowHint(WindowHintBool.Resizable, false);
+                            break;
+                    }
+
+                    // Set window API.
+                    switch (initialOptions.API.API)
+                    {
+                        case ContextAPI.None:
+                        case ContextAPI.Vulkan:
+                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.NoApi);
+                            break;
+                        case ContextAPI.OpenGL:
+                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.OpenGL);
+                            break;
+                        case ContextAPI.OpenGLES:
+                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.OpenGLES);
+                            break;
+                    }
+
+                    // Set API version.
+                    glfw.WindowHint(WindowHintInt.ContextVersionMajor, initialOptions.API.Version.MajorVersion);
+                    glfw.WindowHint(WindowHintInt.ContextVersionMinor, initialOptions.API.Version.MinorVersion);
+
+                    // Set API flags
+                    if (initialOptions.API.Flags.HasFlag(ContextFlags.ForwardCompatible))
+                    {
+                        glfw.WindowHint(WindowHintBool.OpenGLForwardCompat, true);
+                    }
+
+                    if (initialOptions.API.Flags.HasFlag(ContextFlags.Debug))
+                    {
+                        glfw.WindowHint(WindowHintBool.OpenGLDebugContext, true);
+                    }
+
+                    // Set API profile
+                    glfw.WindowHint
+                    (
+                        WindowHintOpenGlProfile.OpenGlProfile,
+                        initialOptions.API.Profile == ContextProfile.Core ? OpenGlProfile.Core : OpenGlProfile.Compat
+                    );
+
+                    // Create window
+                    WindowPtr = glfw.CreateWindow(_size.Width, _size.Height, _title, null, null);
+                }
+            );
+
+            InvokeQueue = new ConcurrentQueue<Task>();
+            MainThread = Thread.CurrentThread.ManagedThreadId;
+
+            glfw.MakeContextCurrent(WindowPtr);
+            WindowState = initialOptions.WindowState;
+            Position = initialOptions.Position;
+            VSync = initialOptions.VSync;
             if (glfw.GetCurrentContext() != WindowPtr)
             {
                 glfw.MakeContextCurrent(WindowPtr);
@@ -403,10 +493,10 @@ public unsafe void Run()
 
             // Initialize some variables
             _isRunningSlowlyTries = 0;
-            
+
             renderStopwatch = new Stopwatch();
             updateStopwatch = new Stopwatch();
-            
+
             MainThread = Thread.CurrentThread.ManagedThreadId;
 
             // Start the update loop.
@@ -414,11 +504,13 @@ public unsafe void Run()
             {
                 ProcessEvents();
 
-                if (UseSingleThreadedWindow) {
+                if (UseSingleThreadedWindow)
+                {
                     RaiseUpdateFrame();
                     RaiseRenderFrame();
                 }
-                else {
+                else
+                {
                     // Raise UpdateFrame, but don't await it yet.
                     var task = Task.Run(RaiseUpdateFrame);
 
@@ -435,16 +527,21 @@ public unsafe void Run()
                     RaiseRenderFrame();
                 }
 
-                if (VSync == VSyncMode.Adaptive) {
+                if (VSync == VSyncMode.Adaptive)
+                {
                     glfw.SwapInterval(IsRunningSlowly ? 0 : 1);
                 }
             }
+
+            running = false;
+            glfwThread.Invoke(() => glfw.DestroyWindow(WindowPtr));
         }
 
         /// <inheritdoc />
         public void Close()
         {
-            unsafe {
+            unsafe
+            {
                 glfw.SetWindowShouldClose(WindowPtr, true);
             }
         }
@@ -458,7 +555,8 @@ public void ProcessEvents()
         /// <inheritdoc />
         public void SwapBuffers()
         {
-            unsafe {
+            unsafe
+            {
                 glfw.SwapBuffers(WindowPtr);
             }
         }
@@ -512,16 +610,19 @@ private void RaiseUpdateFrame()
             // If using a capped framerate without vsync, we have to do some synchronization-related things
             // before rendering.
             if (UpdatesPerSecond > double.Epsilon
-                && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly)) {
+                && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly))
+            {
                 // Calculate the amount of time to sleep.
                 var sleepTime = updatePeriod - updateStopwatch.Elapsed.TotalSeconds;
 
                 // If the result is negative, that means the frame is running slowly. Mark as such and don't sleep.
-                if (sleepTime < 0.0) {
+                if (sleepTime < 0.0)
+                {
                     _isRunningSlowlyTries += 1;
                 }
                 // Else, sleep for that amount of time.
-                else {
+                else
+                {
                     _isRunningSlowlyTries = 0;
                     Thread.Sleep((int) (1000 * sleepTime));
                 }
@@ -540,10 +641,12 @@ private void RaiseRenderFrame()
         {
             // Identical to RaiseUpdateFrame.
             if (FramesPerSecond > double.Epsilon
-                && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly)) {
+                && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly))
+            {
                 var sleepTime = renderPeriod - renderStopwatch.Elapsed.TotalSeconds;
 
-                if (sleepTime > 0.0) {
+                if (sleepTime > 0.0)
+                {
                     Thread.Sleep((int) (1000 * sleepTime));
                 }
             }
@@ -551,9 +654,10 @@ private void RaiseRenderFrame()
             var delta = renderStopwatch.Elapsed.TotalSeconds;
             OnRender?.Invoke(delta);
             renderStopwatch.Restart();
-            
+
             // This has to be called on the thread with the graphics context
-            if (VSync == VSyncMode.Adaptive) {
+            if (VSync == VSyncMode.Adaptive)
+            {
                 glfw.SwapInterval(IsRunningSlowly ? 0 : 1);
             }
         }
@@ -585,18 +689,23 @@ private unsafe void InitializeCallbacks()
             {
                 WindowState state;
                 // If minimized, we immediately know what value the new WindowState is.
-                if (isMinimized) {
+                if (isMinimized)
+                {
                     state = WindowState.Minimized;
                 }
-                else {
+                else
+                {
                     // Otherwise, we have to querry a few things to figure out out.
-                    if (glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Maximized)) {
+                    if (glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Maximized))
+                    {
                         state = WindowState.Maximized;
                     }
-                    else if (glfw.GetWindowMonitor(WindowPtr) != null) {
+                    else if (glfw.GetWindowMonitor(WindowPtr) != null)
+                    {
                         state = WindowState.Fullscreen;
                     }
-                    else {
+                    else
+                    {
                         state = WindowState.Normal;
                     }
                 }
@@ -609,17 +718,22 @@ private unsafe void InitializeCallbacks()
             {
                 // Same here as in onMinimized.
                 WindowState state;
-                if (isMaximized) {
+                if (isMaximized)
+                {
                     state = WindowState.Maximized;
                 }
-                else {
-                    if (glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Iconified)) {
+                else
+                {
+                    if (glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Iconified))
+                    {
                         state = WindowState.Minimized;
                     }
-                    else if (glfw.GetWindowMonitor(WindowPtr) != null) {
+                    else if (glfw.GetWindowMonitor(WindowPtr) != null)
+                    {
                         state = WindowState.Fullscreen;
                     }
-                    else {
+                    else
+                    {
                         state = WindowState.Normal;
                     }
                 }
@@ -632,11 +746,13 @@ private unsafe void InitializeCallbacks()
             {
                 var arrayOfPaths = new string[count];
 
-                if (count == 0 || paths == IntPtr.Zero) {
+                if (count == 0 || paths == IntPtr.Zero)
+                {
                     return;
                 }
 
-                for (var i = 0; i < count; i++) {
+                for (var i = 0; i < count; i++)
+                {
                     var p = Marshal.ReadIntPtr(paths, i * IntPtr.Size);
                     arrayOfPaths[i] = Marshal.PtrToStringAnsi(p);
                 }
@@ -644,16 +760,19 @@ private unsafe void InitializeCallbacks()
                 OnFileDrop?.Invoke(arrayOfPaths);
             };
 
-            glfwThread.Invoke(() =>
-            {
-                glfw.SetWindowPosCallback(WindowPtr, onMove);
-                glfw.SetWindowSizeCallback(WindowPtr, onResize);
-                glfw.SetWindowCloseCallback(WindowPtr, onClosing);
-                glfw.SetWindowFocusCallback(WindowPtr, onFocusChanged);
-                glfw.SetWindowIconifyCallback(WindowPtr, onMinimized);
-                glfw.SetWindowMaximizeCallback(WindowPtr, onMaximized);
-                glfw.SetDropCallback(WindowPtr, onFileDrop);
-            });
+            glfwThread.Invoke
+            (
+                () =>
+                {
+                    glfw.SetWindowPosCallback(WindowPtr, onMove);
+                    glfw.SetWindowSizeCallback(WindowPtr, onResize);
+                    glfw.SetWindowCloseCallback(WindowPtr, onClosing);
+                    glfw.SetWindowFocusCallback(WindowPtr, onFocusChanged);
+                    glfw.SetWindowIconifyCallback(WindowPtr, onMinimized);
+                    glfw.SetWindowMaximizeCallback(WindowPtr, onMaximized);
+                    glfw.SetDropCallback(WindowPtr, onFileDrop);
+                }
+            );
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Windowing/Silk.NET.Windowing.Desktop/Silk.NET.Windowing.Desktop.csproj b/src/Windowing/Silk.NET.Windowing.Desktop/Silk.NET.Windowing.Desktop.csproj
index e1d1d19f28..5eaadaf854 100644
--- a/src/Windowing/Silk.NET.Windowing.Desktop/Silk.NET.Windowing.Desktop.csproj
+++ b/src/Windowing/Silk.NET.Windowing.Desktop/Silk.NET.Windowing.Desktop.csproj
@@ -11,7 +11,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="Ultz.Dispatcher" Version="1.1.0" />
+      <PackageReference Include="Ultz.Dispatcher" Version="2.0.0" />
     </ItemGroup>
 
     <Import Project="..\..\..\build\props\common.props" />