diff --git a/CMakeLists.txt b/CMakeLists.txt
index 49c4879..64c0c9f 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,70 +15,72 @@ option(PD_BUILD_TOOLS "Build Palladium Tools" OFF)
 option(PD_INCLUDE_STB_IMAGE "Inlude stb image symbols in palladium" ON)
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
-	add_compile_options(-Wno-psabi)
+    add_compile_options(-Wno-psabi)
 endif()
 
 if(${PD_BUILD_TOOLS})
-	add_subdirectory(tools)
+    add_subdirectory(tools)
 endif()
 
 add_subdirectory(vendor)
 
 # # Include Library Source
 set(PD_SOURCES
-	# Common
-	source/common.cpp
+    # Common
+    source/common.cpp
 
-	# Core
-	source/core/bits.cpp
-	source/core/color.cpp
-	source/core/io.cpp
-	source/core/mat.cpp
-	source/core/strings.cpp
-	source/core/timer.cpp
-	source/core/timetrace.cpp
+    # Core
+    source/core/bits.cpp
+    source/core/color.cpp
+    source/core/io.cpp
+    source/core/mat.cpp
+    source/core/strings.cpp
+    source/core/timer.cpp
+    source/core/timetrace.cpp
 
-	# Image
-	source/image/image.cpp
+    # Image
+    source/image/image.cpp
 
-	# Drivers
-	source/drivers/os.cpp
-	source/drivers/gfx.cpp
+    # Drivers
+    source/drivers/os.cpp
+    source/drivers/gfx.cpp
+    source/drivers/hid.cpp
 
-	# Lithium
-	source/lithium/drawlist.cpp
-	source/lithium/font.cpp
-	source/lithium/math.cpp
-	source/lithium/pools.cpp
+    # Lithium
+    source/lithium/drawlist.cpp
+    source/lithium/font.cpp
+    source/lithium/math.cpp
+    source/lithium/pools.cpp
 
-	# Ultra
-	source/ultra/canvas.cpp
-	source/ultra/layout.cpp
-	source/ultra/elems/element.cpp
-	source/ultra/elems/rect.cpp
-	source/ultra/elems/text.cpp
-	source/ultra/elems/image.cpp
+    # Ultra
+    source/ultra/canvas.cpp
+    source/ultra/layout.cpp
+    source/ultra/elems/element.cpp
+    source/ultra/elems/rect.cpp
+    source/ultra/elems/text.cpp
+    source/ultra/elems/image.cpp
+    source/ultra/elems/button.cpp
 )
 
 if(${PD_BUILD_SHARED})
-	add_library(palladium SHARED ${PD_SOURCES})
-	target_compile_definitions(palladium PRIVATE PD_BUILD_SHARED)
+    add_library(palladium SHARED ${PD_SOURCES})
+    target_compile_definitions(palladium PRIVATE PD_BUILD_SHARED)
 else()
-	add_library(palladium STATIC ${PD_SOURCES})
-	target_compile_definitions(palladium PUBLIC PD_BUILD_STATIC)
+    add_library(palladium STATIC ${PD_SOURCES})
+    target_compile_definitions(palladium PUBLIC PD_BUILD_STATIC)
 endif()
 
 target_link_libraries(palladium
-	PUBLIC stb
+    PUBLIC stb
 )
 
 target_compile_definitions(palladium
-	PUBLIC
-		PD_DEBUG
-		$<$<OR:$<BOOL:${PD_INCLUDE_STB_IMAGE}>,$<BOOL:${PD_BUILD_SHARED}>>:PD_INCLUDE_STB_IMAGE> # Always on in shared build
+    PUBLIC
+    PD_DEBUG
+    $<$<OR:$<BOOL:${PD_INCLUDE_STB_IMAGE}>,$<BOOL:${PD_BUILD_SHARED}>>:PD_INCLUDE_STB_IMAGE> # Always on in shared build
 )
 target_compile_options(palladium
-	PUBLIC $<$<CXX_COMPILER_ID:GNU,Clang>:
+    PUBLIC $<$<CXX_COMPILER_ID:GNU,Clang>:
     -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/source=source
     -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/include=include
     >
@@ -87,75 +89,75 @@ target_compile_options(palladium
 add_library(palladium::palladium ALIAS palladium)
 
 target_include_directories(palladium
-	PUBLIC
-		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-		$<INSTALL_INTERFACE:include>
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
 )
 
 target_compile_options(palladium
-	PRIVATE
-		$<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:GNU,Clang>>:-O0 -g>
-		$<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:GNU,Clang>>:-O3>
+    PRIVATE
+    $<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:GNU,Clang>>:-O0 -g>
+    $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:GNU,Clang>>:-O3>
 
-		$<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:MSVC>>:/Od /Zi>
-		$<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:MSVC>>:/O2>
+    $<$<AND:$<CONFIG:Debug>,$<CXX_COMPILER_ID:MSVC>>:/Od /Zi>
+    $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:MSVC>>:/O2>
 )
 
 install(
-	TARGETS palladium
-	EXPORT palladiumTargets
-	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    TARGETS palladium
+    EXPORT palladiumTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 )
 install(
-	DIRECTORY include/
-	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    DIRECTORY include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 )
 install(EXPORT palladiumTargets
-	FILE palladiumTargets.cmake
-	NAMESPACE palladium::
-	DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+    FILE palladiumTargets.cmake
+    NAMESPACE palladium::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
 )
 
 include(CMakePackageConfigHelpers)
 configure_package_config_file(
-	cmake/palladiumConfig.cmake.in
-	${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
-	INSTALL_DESTINATION
-	${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+    cmake/palladiumConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
+    INSTALL_DESTINATION
+    ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
 )
 
 write_basic_package_version_file(
-	${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
-	VERSION
-	${PROJECT_VERSION}
-	COMPATIBILITY
-	SameMajorVersion
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
+    VERSION
+    ${PROJECT_VERSION}
+    COMPATIBILITY
+    SameMajorVersion
 )
 
 install(
-	FILES
-		${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
-		${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
-	DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+    FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
 )
 
 find_program(CLANG_FORMAT clang-format)
 
 file(GLOB_RECURSE PD_FMTFILES
-	CONFIGURE_DEPENDS
-	${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp
-	${CMAKE_CURRENT_SOURCE_DIR}/backends/source/*.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/backends/include/*.hpp
-	${CMAKE_CURRENT_SOURCE_DIR}/tests/core/source/*.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/tests/gfx/source/*.cpp
+    CONFIGURE_DEPENDS
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/include/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/core/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/gfx/source/*.cpp
 )
 
 add_custom_target(pd-clang-format
-	COMMAND ${CLANG_FORMAT} --style=file -i ${PD_FMTFILES}
-	COMMENT "Formatting Project Sources"
+    COMMAND ${CLANG_FORMAT} --style=file -i ${PD_FMTFILES}
+    COMMENT "Formatting Project Sources"
 )
 
 add_subdirectory(backends)
diff --git a/backends/CMakeLists.txt b/backends/CMakeLists.txt
index 15d475d..dccb689 100644
--- a/backends/CMakeLists.txt
+++ b/backends/CMakeLists.txt
@@ -7,51 +7,55 @@ option(PD_ENABLE_OPENGL3 "Enable OpenGL 3.3 (On Supported Hardware)" ON)
 option(PD_ENABLE_DIRECTX9 "Enable DirectX9 Support" ON)
 option(PD_ENABLE_CITRO3D "Enable Citro3D Support (3DS)" OFF)
 option(PD_ENABLE_VULKAN "Not implemented yet" OFF)
+option(PD_ENABLE_HID_GLFW "Enable GLFW Input Driver" ON)
 
 if(NOT WIN32) # cause we are not on windows...
-	set(PD_ENABLE_DIRECTX9 OFF)
+    set(PD_ENABLE_DIRECTX9 OFF)
 endif()
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
-	set(PD_ENABLE_OPENGL2 OFF)
-	set(PD_ENABLE_OPENGL3 OFF)
-	set(PD_ENABLE_VULKAN OFF)
-	set(PD_ENABLE_CITRO3D ON)
+    set(PD_ENABLE_OPENGL2 OFF)
+    set(PD_ENABLE_OPENGL3 OFF)
+    set(PD_ENABLE_VULKAN OFF)
+    set(PD_ENABLE_HID_GLFW OFF)
+    set(PD_ENABLE_CITRO3D ON)
 elseif(${CMAKE_SYSTEM_NAME} STREQUAL "NintendoSwitch")
-	set(PD_ENABLE_OPENGL2 OFF)
-	set(PD_ENABLE_OPENGL3 ON)
-	set(PD_ENABLE_VULKAN OFF)
-	set(PD_ENABLE_CITRO3D OFF)
+    set(PD_ENABLE_OPENGL2 OFF)
+    set(PD_ENABLE_OPENGL3 ON)
+    set(PD_ENABLE_VULKAN OFF)
+    set(PD_ENABLE_CITRO3D OFF)
 endif()
 
 add_library(pd-system STATIC
-	${CMAKE_CURRENT_SOURCE_DIR}/source/gl-helper.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_opengl2.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_opengl3.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_directx9.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_citro3d.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gl-helper.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_opengl2.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_opengl3.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_directx9.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_citro3d.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/hid_glfw.cpp
 )
 
 target_include_directories(pd-system
-	PUBLIC
-		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-		$<INSTALL_INTERFACE:include>
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
 )
 
 target_compile_options(palladium
-	PUBLIC $<$<CXX_COMPILER_ID:GNU,Clang>:
+    PUBLIC $<$<CXX_COMPILER_ID:GNU,Clang>:
     -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/source=source
     -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/include=include
     >
 )
 
 target_compile_definitions(pd-system
-	PUBLIC
-		$<$<BOOL:${PD_ENABLE_OPENGL2}>:PD_ENABLE_OPENGL2>
-		$<$<BOOL:${PD_ENABLE_OPENGL3}>:PD_ENABLE_OPENGL3>
-		$<$<BOOL:${PD_ENABLE_VULKAN}>:PD_ENABLE_VULKAN>
-		$<$<BOOL:${PD_ENABLE_DIRECTX9}>:PD_ENABLE_DIRECTX9>
-		$<$<BOOL:${PD_ENABLE_CITRO3D}>:PD_ENABLE_CITRO3D>
+    PUBLIC
+    $<$<BOOL:${PD_ENABLE_OPENGL2}>:PD_ENABLE_OPENGL2>
+    $<$<BOOL:${PD_ENABLE_OPENGL3}>:PD_ENABLE_OPENGL3>
+    $<$<BOOL:${PD_ENABLE_VULKAN}>:PD_ENABLE_VULKAN>
+    $<$<BOOL:${PD_ENABLE_DIRECTX9}>:PD_ENABLE_DIRECTX9>
+    $<$<BOOL:${PD_ENABLE_CITRO3D}>:PD_ENABLE_CITRO3D>
+    $<$<BOOL:${PD_ENABLE_HID_GLFW}>:PD_ENABLE_HID_GLFW>
 )
 
 # Palladium
@@ -59,34 +63,41 @@ target_link_libraries(pd-system PUBLIC palladium::palladium)
 
 # glad (if we have any OpenGL version included)
 if(PD_ENABLE_OPENGL2 OR PD_ENABLE_OPENGL3)
-	target_link_libraries(pd-system
-		PUBLIC glad
-	)
+    target_link_libraries(pd-system
+        PUBLIC glad
+    )
 endif()
 
 # DirectX9
 if(PD_ENABLE_DIRECTX9)
-	target_link_libraries(pd-system
-		PUBLIC
-			d3d9
-			d3dcompiler
-	)
+    target_link_libraries(pd-system
+        PUBLIC
+        d3d9
+        d3dcompiler
+    )
 endif()
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
-	target_link_libraries(pd-system
-		PUBLIC
-			pica::pica
-			citro3d
-			ctru
-	)
+    target_link_libraries(pd-system
+        PUBLIC
+        pica::pica
+        citro3d
+        ctru
+    )
 else()
-	if(${CMAKE_SYSTEM_NAME} STREQUAL "NintendoSwitch")
-		target_include_directories(pd-system
-			PUBLIC $ENV{DEVKITPRO}/portlibs/switch/include
-		)
-	endif()
-	target_link_libraries(pd-system
-		PUBLIC spirv-helper
-	)
+    if(${CMAKE_SYSTEM_NAME} STREQUAL "NintendoSwitch")
+        target_include_directories(pd-system
+            PUBLIC $ENV{DEVKITPRO}/portlibs/switch/include
+        )
+        if(PD_ENABLE_HID_GLFW)
+            target_link_libraries(pd-system PUBLIC glfw3) # use dkp glfw
+        endif()
+    else()
+        if(PD_ENABLE_HID_GLFW)
+            target_link_libraries(pd-system PUBLIC glfw) # use vendor glfw
+        endif()
+    endif()
+    target_link_libraries(pd-system
+        PUBLIC spirv-helper
+    )
 endif()
diff --git a/backends/include/pd_system/hid_glfw.hpp b/backends/include/pd_system/hid_glfw.hpp
new file mode 100644
index 0000000..d6f394c
--- /dev/null
+++ b/backends/include/pd_system/hid_glfw.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <pd/drivers/hid.hpp>
+
+typedef struct GLFWwindow GLFWwindow;
+
+namespace PD {
+class HidGlfw : public HidDriver {
+ public:
+  HidGlfw(GLFWwindow* window);
+  ~HidGlfw();
+
+  void Update() override;
+
+ private:
+  struct Impl;
+  Impl* impl;
+};
+}  // namespace PD
\ No newline at end of file
diff --git a/backends/include/pdsystem b/backends/include/pdsystem
index 06daadd..dcb97de 100644
--- a/backends/include/pdsystem
+++ b/backends/include/pdsystem
@@ -1,6 +1,10 @@
 #pragma once
 
+// Gfx
 #include <pd_system/gfx_citro3d.hpp>
 #include <pd_system/gfx_directx9.hpp>
 #include <pd_system/gfx_opengl2.hpp>
 #include <pd_system/gfx_opengl3.hpp>
+
+// Hid
+#include <pd_system/hid_glfw.hpp>
\ No newline at end of file
diff --git a/backends/source/hid_glfw.cpp b/backends/source/hid_glfw.cpp
new file mode 100644
index 0000000..05292c4
--- /dev/null
+++ b/backends/source/hid_glfw.cpp
@@ -0,0 +1,59 @@
+#include <pd_system/hid_glfw.hpp>
+#ifdef PD_ENABLE_HID_GLFW
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+namespace PD {
+struct HidGlfw::Impl {
+  GLFWwindow* Win;
+  int PrevState;
+  std::unordered_map<int, int> PrevStates;
+  GLFWcharfun OldTextCB;
+  std::string* Text;
+  bool InTextMode = false;
+};
+
+HidGlfw::HidGlfw(GLFWwindow* win) : HidDriver("HidGlfw") {
+  impl = new Impl;
+  impl->Win = win;
+  pFlags |= PDHidBackendFlags_HasMouse;
+  pFlags |= PDHidBackendFlags_HasKeyboard;
+  pGamepad[GLFW_MOUSE_BUTTON_LEFT] = HidInternal::Touch;
+}
+
+HidGlfw::~HidGlfw() {}
+
+void HidGlfw::Update() {
+  HidDriver::Update();  // clear stats
+  int state = glfwGetMouseButton(impl->Win, GLFW_MOUSE_BUTTON_LEFT);
+  if (state == GLFW_PRESS) {
+    if (impl->PrevState == GLFW_RELEASE) {
+      pGamepadEvents[0][Event::Down] |= HidInternal::Touch;
+    }
+    pGamepadEvents[0][Event::Held] |= HidInternal::Touch;
+  } else if (state == GLFW_RELEASE && impl->PrevState == GLFW_PRESS) {
+    pGamepadEvents[0][Event::Up] |= HidInternal::Touch;
+  }
+
+  impl->PrevState = state;
+  // if (pLocked) {
+  //   SwapTab();
+  // }
+  double x, y;
+  glfwGetCursorPos(impl->Win, &x, &y);
+  pMouse[1] = pMouse[0];  // Cycle pMouse pos
+  pMouse[0] = fvec2(x, y);
+}
+}  // namespace PD
+#else
+namespace PD {
+
+HidGlfw::HidGlfw(GLFWwindow* win) : HidDriver("HidGlfw") {}
+
+HidGlfw::~HidGlfw() {}
+
+void HidGlfw::Update() {
+  HidDriver::Update();  // clear stats
+}
+}  // namespace PD
+#endif
\ No newline at end of file
diff --git a/include/pd/drivers/drivers.hpp b/include/pd/drivers/drivers.hpp
index 7ad8d80..4d99cea 100755
--- a/include/pd/drivers/drivers.hpp
+++ b/include/pd/drivers/drivers.hpp
@@ -1,4 +1,5 @@
 #pragma once
 
 #include <pd/drivers/gfx.hpp>
+#include <pd/drivers/hid.hpp>
 #include <pd/drivers/os.hpp>
diff --git a/include/pd/drivers/hid.hpp b/include/pd/drivers/hid.hpp
new file mode 100644
index 0000000..20c20eb
--- /dev/null
+++ b/include/pd/drivers/hid.hpp
@@ -0,0 +1,175 @@
+#pragma once
+
+#include <pd/core/core.hpp>
+#include <pd/drivers/interface.hpp>
+
+using PDHidBackendFlags = PD::u32;
+enum PDHidBackendFlags_ {
+  PDHidBackendFlags_None = 0,
+  PDHidBackendFlags_HasTouch = 1 << 1,
+  PDHidBackendFlags_HasGamepad = 1 << 2,
+  PDHidBackendFlags_HasMouse = 1 << 3,
+  PDHidBackendFlags_HasKeyboard = 1 << 4,
+};
+
+namespace PD {
+namespace HidInternal {
+class Keyboard {
+ public:
+  Keyboard() = default;
+  virtual ~Keyboard() = default;
+  using Key = u128;
+  constexpr static Key No = 0;
+  constexpr static Key Escape = Key::Flag(0);
+  constexpr static Key Q = Key::Flag(1);
+  constexpr static Key W = Key::Flag(2);
+  constexpr static Key E = Key::Flag(3);
+  constexpr static Key R = Key::Flag(4);
+  constexpr static Key T = Key::Flag(5);
+  constexpr static Key Z = Key::Flag(6);
+  constexpr static Key U = Key::Flag(7);
+  constexpr static Key I = Key::Flag(8);
+  constexpr static Key O = Key::Flag(9);
+  constexpr static Key P = Key::Flag(10);
+  constexpr static Key A = Key::Flag(11);
+  constexpr static Key S = Key::Flag(12);
+  constexpr static Key D = Key::Flag(13);
+  constexpr static Key F = Key::Flag(14);
+  constexpr static Key G = Key::Flag(15);
+  constexpr static Key H = Key::Flag(16);
+  constexpr static Key J = Key::Flag(17);
+  constexpr static Key K = Key::Flag(18);
+  constexpr static Key L = Key::Flag(19);
+  constexpr static Key Y = Key::Flag(20);
+  constexpr static Key X = Key::Flag(21);
+  constexpr static Key C = Key::Flag(22);
+  constexpr static Key V = Key::Flag(23);
+  constexpr static Key B = Key::Flag(24);
+  constexpr static Key N = Key::Flag(25);
+  constexpr static Key M = Key::Flag(26);
+  constexpr static Key _1 = Key::Flag(27);
+  constexpr static Key _2 = Key::Flag(28);
+  constexpr static Key _3 = Key::Flag(29);
+  constexpr static Key _4 = Key::Flag(30);
+  constexpr static Key _5 = Key::Flag(31);
+  constexpr static Key _6 = Key::Flag(32);
+  constexpr static Key _7 = Key::Flag(33);
+  constexpr static Key _8 = Key::Flag(34);
+  constexpr static Key _9 = Key::Flag(35);
+  constexpr static Key _0 = Key::Flag(36);
+  constexpr static Key F1 = Key::Flag(37);
+  constexpr static Key F2 = Key::Flag(38);
+  constexpr static Key F3 = Key::Flag(39);
+  constexpr static Key F4 = Key::Flag(40);
+  constexpr static Key F5 = Key::Flag(41);
+  constexpr static Key F6 = Key::Flag(42);
+  constexpr static Key F7 = Key::Flag(43);
+  constexpr static Key F8 = Key::Flag(44);
+  constexpr static Key F9 = Key::Flag(45);
+  constexpr static Key F10 = Key::Flag(46);
+  constexpr static Key F11 = Key::Flag(47);
+  constexpr static Key F12 = Key::Flag(48);
+  constexpr static Key MouseLeft = Key::Flag(120);
+};
+
+using GamepadKey = u32;
+enum Gamepad : GamepadKey {
+  None = 0,                  ///< No Key
+  A = 1 << 0,                ///< A
+  B = 1 << 1,                ///< B
+  X = 1 << 2,                ///< X
+  Y = 1 << 3,                ///< Y
+  Start = 1 << 4,            ///< Start
+  Select = 1 << 5,           ///< Select
+  L = 1 << 6,                ///< L
+  R = 1 << 7,                ///< R
+  DUp = 1 << 8,              ///< Dpad Up
+  DDown = 1 << 9,            ///< Dpad down
+  DLeft = 1 << 10,           ///< Dpad left
+  DRight = 1 << 11,          ///< Dpad right
+  CPUp = 1 << 12,            ///< Cpad up
+  CPDown = 1 << 13,          ///< cpad down
+  CPLeft = 1 << 14,          ///< cpad left
+  CPRight = 1 << 15,         ///< Cpad right
+  CSUp = 1 << 16,            ///< Cstick up
+  CSDown = 1 << 17,          ///< cstick down
+  CSLeft = 1 << 18,          ///< cstick left
+  CSRight = 1 << 19,         ///< cstick right
+  ZL = 1 << 20,              ///< ZL
+  ZR = 1 << 21,              ///< ZR
+  Touch = 1 << 22,           ///< Touch
+  Up = DUp | CPUp,           ///< DPad or CPad Up
+  Down = DDown | CPDown,     ///< DPad or CPad Down
+  Left = DLeft | CPLeft,     ///< DPad or CPad Left
+  Right = DRight | CPRight,  ///< DPad or CPad Right
+};
+}  // namespace HidInternal
+// Pre interface class
+class PD_API HidDriver : public DriverInterface {
+ public:
+  enum class Event {
+    Null,  ///< Nothing happended
+    Down,  ///< Key Pressed
+    Held,  ///< Key held
+    Up,    ///< Key released
+  };
+  HidDriver(std::string_view name = "HidNull");
+  virtual ~HidDriver();
+
+  virtual void Init() {}
+  virtual void Deinit() {}
+  virtual const fvec2& MousePos() const { return pMouse[0]; }
+  virtual const fvec2& MousePosLast() const { return pMouse[1]; }
+  virtual const fvec2& TouchPos() const { return pMouse[0]; }
+  virtual const fvec2& TouchPosLast() const { return pMouse[1]; }
+  virtual void Update();
+  virtual bool IsEvent(Event e, HidInternal::GamepadKey keys);
+  virtual bool IsEvent(Event e, HidInternal::Keyboard::Key keys);
+
+  PDHidBackendFlags GetFlags() const { return pFlags; }
+
+ protected:
+  void SwapTab();
+  PDHidBackendFlags pFlags = PDHidBackendFlags_None;
+  fvec2 pMouse[2];  // Current And last pos
+  std::unordered_map<u32, u32> pGamepad;
+  std::unordered_map<u128, u128> pKeyboard;
+  std::unordered_map<Event, u32> pGamepadEvents[2];
+  std::unordered_map<Event, u128> pKeyboardEvents[2];
+};
+
+class PD_API Hid {
+ public:
+  using Gamepad = HidInternal::Gamepad;
+  using Keyboard = HidInternal::Keyboard;
+  using Event = HidDriver::Event;
+  Hid() = default;
+  ~Hid() = default;
+
+  template <typename T, typename... Args>
+  static void UseDriver(Args&&... args) {
+    // assert(driver == nullptr && "OS Driver already set");
+    driver = std::make_unique<T>(std::forward<Args>(args)...);
+  }
+
+  static void Init() { driver->Init(); }
+  static void Deinit() { driver->Deinit(); }
+  static const fvec2& MousePos() { return driver->MousePos(); }
+  static const fvec2& MousePosLast() { return driver->MousePosLast(); }
+  static const fvec2& TouchPos() { return driver->TouchPos(); }
+  static const fvec2& TouchPosLast() { return driver->TouchPosLast(); }
+  static void Update() { driver->Update(); }
+  static bool IsEvent(Event e, HidInternal::GamepadKey keys) {
+    return driver->IsEvent(e, keys);
+  }
+  static bool IsEvent(Event e, HidInternal::Keyboard::Key keys) {
+    return driver->IsEvent(e, keys);
+  }
+  static PDHidBackendFlags GetFlags() { return driver->GetFlags(); }
+
+  static const char* GetDriverName() { return driver->GetName(); }
+
+ private:
+  static std::unique_ptr<HidDriver> driver;
+};
+}  // namespace PD
\ No newline at end of file
diff --git a/source/drivers/hid.cpp b/source/drivers/hid.cpp
new file mode 100644
index 0000000..9573de9
--- /dev/null
+++ b/source/drivers/hid.cpp
@@ -0,0 +1,47 @@
+#include <pd/drivers/hid.hpp>
+
+namespace PD {
+PD_API std::unique_ptr<HidDriver> Hid::driver;
+
+PD_API HidDriver::HidDriver(std::string_view name) : DriverInterface(name) {}
+
+PD_API HidDriver::~HidDriver() {}
+
+PD_API bool HidDriver::IsEvent(Event e, HidInternal::GamepadKey keys) {
+  return pGamepadEvents[0][e] & keys;
+}
+
+PD_API bool HidDriver::IsEvent(Event e, HidInternal::Keyboard::Key keys) {
+  return pKeyboardEvents[0][e].Has(keys);
+}
+/**
+ * Todo: Keyboard support
+ */
+PD_API void HidDriver::SwapTab() {
+  auto tkd = pGamepadEvents[1][Event::Down];
+  auto tkh = pGamepadEvents[1][Event::Held];
+  auto tku = pGamepadEvents[1][Event::Up];
+  pGamepadEvents[1][Event::Down] = pGamepadEvents[0][Event::Down];
+  pGamepadEvents[1][Event::Held] = pGamepadEvents[0][Event::Held];
+  pGamepadEvents[1][Event::Up] = pGamepadEvents[0][Event::Up];
+  pGamepadEvents[0][Event::Down] = tkd;
+  pGamepadEvents[0][Event::Held] = tkh;
+  pGamepadEvents[0][Event::Up] = tku;
+}
+
+/**
+ * If this func has no verride, still clear the stats
+ * cause if they are empty this leads to a crash
+ */
+PD_API void HidDriver::Update() {
+  // Clear States
+  for (int i = 0; i < 2; i++) {
+    pGamepadEvents[i][Event::Down] = 0;
+    pGamepadEvents[i][Event::Held] = 0;
+    pGamepadEvents[i][Event::Up] = 0;
+    for (auto& it : pKeyboardEvents[i]) {
+      it.second = 0;  // ? why was this Event_Null
+    }
+  }
+}
+}  // namespace PD
\ No newline at end of file
diff --git a/tests/gfx/source/main.cpp b/tests/gfx/source/main.cpp
index bcc43cb..b47db88 100644
--- a/tests/gfx/source/main.cpp
+++ b/tests/gfx/source/main.cpp
@@ -88,9 +88,12 @@ int main(int argc, char** argv) {
   pList.SetFont(&font);
   App app(font);
   while (pOs->Mainloop()) {
+    PD::Hid::Update();
     pOs->ClearViewPort();
     PD::Li::ResetPools();  // Move to other place (or refactor this)
     app.Update(pOs->GetViewport(), pList);
+    pList.DrawText(5, std::format("Mouse: {}", PD::Hid::MousePos()).c_str(),
+                   PD::Color("#ffffffff"));
     PD::Gfx::Reset();
     PD::Gfx::Draw(pList);
     pList.Clear();
diff --git a/tests/gfx/source/os/desktopos.cpp b/tests/gfx/source/os/desktopos.cpp
index 109d0b9..02f9dc9 100644
--- a/tests/gfx/source/os/desktopos.cpp
+++ b/tests/gfx/source/os/desktopos.cpp
@@ -72,6 +72,7 @@ void DesktopOS::Init() {
   }
 #endif
   glfwSwapInterval(1);
+  PD::Hid::UseDriver<HidGlfw>(impl->win);
 }
 
 void DesktopOS::Deinit() {
diff --git a/tests/gfx/source/os/horizon-ctr.cpp b/tests/gfx/source/os/horizon-ctr.cpp
index a955534..805ef0c 100644
--- a/tests/gfx/source/os/horizon-ctr.cpp
+++ b/tests/gfx/source/os/horizon-ctr.cpp
@@ -42,6 +42,7 @@ void HorizonCtr::Init() {
   C3D_RenderTargetSetOutput(impl->Bottom, GFX_BOTTOM, GFX_LEFT,
                             DisplayTransferFlags);
   PD::Gfx::UseDriver<PD::GfxCitro3D>();
+  PD::Hid::UseDriver<PD::HidDriver>();
 }
 
 void HorizonCtr::Deinit() {
diff --git a/tests/gfx/source/os/horizon-nx.cpp b/tests/gfx/source/os/horizon-nx.cpp
index d552fed..cc1803d 100644
--- a/tests/gfx/source/os/horizon-nx.cpp
+++ b/tests/gfx/source/os/horizon-nx.cpp
@@ -29,6 +29,7 @@ void HorizonNX::Init() {
   gladLoadGL();
   glfwSwapInterval(1);
   PD::Gfx::UseDriver<PD::GfxOpenGL3>();
+  PD::Hid::UseDriver<PD::HidDriver>();
 }
 
 void HorizonNX::Deinit() {