diff --git a/examples/fixedsize.nim b/examples/fixedsize.nim
index 7369443..96eda91 100644
--- a/examples/fixedsize.nim
+++ b/examples/fixedsize.nim
@@ -1,6 +1,6 @@
 import opengl, windy
 
-let window = newWindow("Windy Basic", ivec2(500, 500))
+let window = newWindow("Windy Fixed Size", ivec2(500, 500))
 window.style = Decorated
 
 window.makeContextCurrent()
diff --git a/examples/fullscreen.nim b/examples/fullscreen.nim
index 06f19d2..6099a95 100644
--- a/examples/fullscreen.nim
+++ b/examples/fullscreen.nim
@@ -1,6 +1,6 @@
 import boxy, opengl, windy
 
-let window = newWindow("Toggle Fullscreen", ivec2(1280, 800))
+let window = newWindow("Windy Toggle Fullscreen", ivec2(1280, 800))
 
 window.makeContextCurrent()
 loadExtensions()
diff --git a/examples/gamepad.nim b/examples/gamepad.nim
new file mode 100644
index 0000000..b0699cf
--- /dev/null
+++ b/examples/gamepad.nim
@@ -0,0 +1,37 @@
+import opengl, windy
+
+# Global event handlers must be registered before the first window is created,
+# this enables them to receive events from gamepads that are already connected
+onGamepadConnected = proc(gamepadId: int) =
+  echo "Gamepad ", gamepadId, " connected: ", gamepadName(gamepadId)
+onGamepadDisconnected = proc(gamepadId: int) =
+  echo "Gamepad ", gamepadId, " disconnected"
+
+let window = newWindow("Windy Gamepad", ivec2(1280, 800))
+var color = vec4(0, 0, 0, 1)
+
+window.makeContextCurrent()
+loadExtensions()
+
+proc gamepad() =
+  for i in 0..<maxGamepads:
+    for btn in 0.GamepadButton..<GamepadButtonCount:
+      if gamepadButtonPressed(i, btn):
+        echo "Gamepad ", i, " button ", btn, " pressed"
+      if gamepadButtonReleased(i, btn):
+        echo "Gamepad ", i, " button ", btn, " released"
+      if gamepadButtonPressure(i, btn) > 0 and gamepadButtonPressure(i, btn) < 1:
+        echo "Gamepad ", i, " button ", btn, " pressure ", gamepadButtonPressure(i, btn)
+    for axis in 0.GamepadAxis..<GamepadAxisCount:
+      if gamepadAxis(i, axis) != 0:
+        echo "Gamepad ", i, " axis ", axis, " value ", gamepadAxis(i, axis)
+
+proc display() =
+  glClearColor(color.x, color.y, color.z, color.w)
+  glClear(GL_COLOR_BUFFER_BIT)
+  window.swapBuffers()
+
+while not window.closeRequested:
+  gamepad()
+  display()
+  pollEvents()
diff --git a/examples/httprequest.nim b/examples/httprequest.nim
index 0941e10..55a3803 100644
--- a/examples/httprequest.nim
+++ b/examples/httprequest.nim
@@ -23,6 +23,6 @@ req.onResponse = proc(response: HttpResponse) =
   echo "onResponse: code=", $response.code, ", len=", response.body.len
 
 # Closing the window exits the demo
-let window = newWindow("Windy Basic", ivec2(1280, 800))
+let window = newWindow("Windy HttpRequest", ivec2(1280, 800))
 while not window.closeRequested:
   pollEvents()
diff --git a/examples/websocket.nim b/examples/websocket.nim
index 798cc30..5850e7c 100644
--- a/examples/websocket.nim
+++ b/examples/websocket.nim
@@ -25,6 +25,6 @@ ws.onClose = proc() =
   echo "onClose"
 
 # Closing the window exits the demo
-let window = newWindow("Windy Basic", ivec2(1280, 800))
+let window = newWindow("Windy WebSocket", ivec2(1280, 800))
 while not window.closeRequested:
   pollEvents()
diff --git a/src/windy/common.nim b/src/windy/common.nim
index 5bc4cef..3f7a2db 100644
--- a/src/windy/common.nim
+++ b/src/windy/common.nim
@@ -69,6 +69,7 @@ type
     DecoratedResizable, Decorated, Undecorated, Transparent
 
   Callback* = proc()
+  GamepadCallback* = proc(gamepadId: int) {.raises: [].}
   ButtonCallback* = proc(button: Button)
   RuneCallback* = proc(rune: Rune)
   HttpErrorCallback* = proc(msg: string)
@@ -194,9 +195,46 @@ type
 
   ButtonView* = distinct set[Button]
 
+  # A button is an input whose value is a boolean with an optional pressure value between 0 and 1
+  # For buttons without pressure, the pressure value is 1 if the button is pressed, 0 otherwise
+  # NOTE These are the same as the HTML5 standard mapping, making the definition order important
+  GamepadButton* = enum
+    GamepadA
+    GamepadB
+    GamepadX
+    GamepadY
+    GamepadL1
+    GamepadR1
+    GamepadL2
+    GamepadR2
+    GamepadSelect
+    GamepadStart
+    GamepadL3
+    GamepadR3
+    GamepadUp
+    GamepadDown
+    GamepadLeft
+    GamepadRight
+    GamepadHome
+    GamepadTouchpad
+    GamepadButtonCount
+
+  # An axis is an input whose value is a float between -1 and 1
+  GamepadAxis* = enum
+    GamepadLStickX
+    GamepadLStickY
+    GamepadRStickX
+    GamepadRStickY
+    GamepadAxisCount
+
 const
+  maxGamepads* = 4 # GCController, XInput and other native APIs come with a limit of 4 gamepads
   defaultHttpDeadline*: float32 = -1
 
+var
+  onGamepadConnected*: GamepadCallback
+  onGamepadDisconnected*: GamepadCallback
+
 proc `==`*(a, b: HttpRequestHandle): bool =
   a.int == b.int
 
diff --git a/src/windy/internal.nim b/src/windy/internal.nim
index 65bd33d..a80d232 100644
--- a/src/windy/internal.nim
+++ b/src/windy/internal.nim
@@ -1,10 +1,19 @@
 import common, pixie, std/random
 
 const
+  gamepadDeadzone = 0.1
   multiClickRadius = 4
   CRLF* = "\r\n"
 
 type
+  GamepadState* = object
+    buttons*: uint32 # One bit per button, 32 buttons max
+    pressed*: uint32 # Buttons pressed this frame
+    released*: uint32 # Buttons released this frame
+    pressures*: array[GamepadButtonCount.int, float32] # Many APIs report a pressure per button; binary 0..1 otherwise
+    axes*: array[GamepadAxisCount.int, float32] # Values are in the range -1..1
+    name*: string
+
   WindowState* = object
     title*: string
     icon*: Image
@@ -162,3 +171,41 @@ proc addDefaultHeaders*(headers: var seq[HttpHeader]) =
   if headers["accept-encoding"].len == 0:
     # If there isn't a specific accept-encoding specified, enable gzip
     headers["accept-encoding"] = "gzip"
+
+template gamepadPlatform*() =
+  proc gamepadName*(gamepadId: int): string =
+    gamepadStates[gamepadId].name
+
+  proc gamepadButton*(gamepadId: int, button: GamepadButton): bool {.inline.} =
+    (gamepadStates[gamepadId].buttons and (1.uint32 shl button.int8)) != 0
+
+  proc gamepadButtonPressed*(gamepadId: int, button: GamepadButton): bool {.inline.} =
+    (gamepadStates[gamepadId].pressed and (1.uint32 shl button.int8)) != 0
+
+  proc gamepadButtonReleased*(gamepadId: int, button: GamepadButton): bool {.inline.} =
+    (gamepadStates[gamepadId].released and (1.uint32 shl button.int8)) != 0
+
+  proc gamepadButtonPressure*(gamepadId: int, button: GamepadButton): float {.inline.} =
+    gamepadStates[gamepadId].pressures[button.int8]
+
+  proc gamepadAxis*(gamepadId: int, axis: GamepadAxis): float {.inline.} =
+    gamepadStates[gamepadId].axes[axis.int8]
+
+func gamepadFilterDeadZone*(value: float): float {.inline.} =
+  if abs(value) < gamepadDeadzone: 0 else: value
+
+template gamepadUpdateButtons*() =
+  let prevButtons = state.buttons
+  state.buttons = buttons
+  state.pressed = buttons and (not prevButtons)
+  state.released = prevButtons and (not buttons)
+
+proc gamepadResetState*(state: var GamepadState) =
+  state.buttons = 0.uint32
+  state.pressed = 0.uint32
+  state.released = 0.uint32
+  for i in 0..<GamepadButtonCount.int:
+    state.pressures[i] = 0.float32
+  for i in 0..<GamepadAxisCount.int:
+    state.axes[i] = 0.float32
+  state.name = ""
diff --git a/src/windy/platforms/emscripten/emdefs.nim b/src/windy/platforms/emscripten/emdefs.nim
index 4763811..c17b151 100644
--- a/src/windy/platforms/emscripten/emdefs.nim
+++ b/src/windy/platforms/emscripten/emdefs.nim
@@ -128,8 +128,22 @@ proc emscripten_webgl_init_context_attributes*(attrs: ptr EmscriptenWebGLContext
 proc emscripten_webgl_create_context*(target: cstring, attrs: ptr EmscriptenWebGLContextAttributes): EMSCRIPTEN_WEBGL_CONTEXT_HANDLE {.importc, header: "<emscripten/html5.h>".}
 proc emscripten_webgl_make_context_current*(context: EMSCRIPTEN_WEBGL_CONTEXT_HANDLE): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
 
+const EM_HTML5_MEDIUM_STRING_LEN_BYTES* = 64
+
 # Mouse event handling
 type
+  EmscriptenGamepadEvent* {.importc: "EmscriptenGamepadEvent", header: "<emscripten/html5.h>".} = object
+    timestamp*: cdouble
+    numAxes*: cint
+    numButtons*: cint
+    axis*: array[64, cdouble]
+    analogButton*: array[64, cdouble]
+    digitalButton*: array[64, bool]
+    connected*: bool
+    index*: cint
+    id*: array[EM_HTML5_MEDIUM_STRING_LEN_BYTES, char]
+    mapping*: array[EM_HTML5_MEDIUM_STRING_LEN_BYTES, char]
+
   EmscriptenMouseEvent* {.importc: "EmscriptenMouseEvent", header: "<emscripten/html5.h>".} = object
     timestamp*: cdouble
     screenX*, screenY*: clong
@@ -181,7 +195,11 @@ type
   EmscriptenKeyboardEventCallback* = proc(eventType: cint, keyEvent: ptr EmscriptenKeyboardEvent, userData: pointer): EM_BOOL {.cdecl.}
   EmscriptenFocusEventCallback* = proc(eventType: cint, focusEvent: ptr EmscriptenFocusEvent, userData: pointer): EM_BOOL {.cdecl.}
   EmscriptenUiEventCallback* = proc(eventType: cint, uiEvent: ptr EmscriptenUiEvent, userData: pointer): EM_BOOL {.cdecl.}
+  EmscriptenGamepadEventCallback* = proc(eventType: cint, gamepadEvent: ptr EmscriptenGamepadEvent, userData: pointer): EM_BOOL {.cdecl.}
+  EmscriptenGamepadDisconnectedEventCallback* = proc(eventType: cint, gamepadEvent: ptr EmscriptenGamepadEvent, userData: pointer): EM_BOOL {.cdecl.}
 
+proc emscripten_set_gamepadconnected_callback_on_thread*(userData: pointer, useCapture: EM_BOOL, callback: EmscriptenGamepadEventCallback, targetThread: pointer): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
+proc emscripten_set_gamepaddisconnected_callback_on_thread*(userData: pointer, useCapture: EM_BOOL, callback: EmscriptenGamepadDisconnectedEventCallback, targetThread: pointer): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
 proc emscripten_set_mousedown_callback_on_thread*(target: cstring, userData: pointer, useCapture: EM_BOOL, callback: EmscriptenMouseEventCallback, targetThread: pointer): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
 proc emscripten_set_mouseup_callback_on_thread*(target: cstring, userData: pointer, useCapture: EM_BOOL, callback: EmscriptenMouseEventCallback, targetThread: pointer): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
 proc emscripten_set_mousemove_callback_on_thread*(target: cstring, userData: pointer, useCapture: EM_BOOL, callback: EmscriptenMouseEventCallback, targetThread: pointer): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
@@ -193,6 +211,9 @@ proc emscripten_set_blur_callback_on_thread*(target: cstring, userData: pointer,
 proc emscripten_set_focus_callback_on_thread*(target: cstring, userData: pointer, useCapture: EM_BOOL, callback: EmscriptenFocusEventCallback, targetThread: pointer): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
 proc emscripten_set_resize_callback_on_thread*(target: cstring, userData: pointer, useCapture: EM_BOOL, callback: EmscriptenUiEventCallback, targetThread: pointer): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
 
+proc emscripten_sample_gamepad_data*(): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
+proc emscripten_get_gamepad_status*(index: cint, status: ptr EmscriptenGamepadEvent): EMSCRIPTEN_RESULT {.importc, header: "<emscripten/html5.h>".}
+
 const
   EMSCRIPTEN_EVENT_KEYPRESS* = 1
   EMSCRIPTEN_EVENT_KEYDOWN* = 2
diff --git a/src/windy/platforms/emscripten/platform.nim b/src/windy/platforms/emscripten/platform.nim
index 017196c..5f41d06 100644
--- a/src/windy/platforms/emscripten/platform.nim
+++ b/src/windy/platforms/emscripten/platform.nim
@@ -54,10 +54,14 @@ var
   mainWindow: Window  # Track the main window for events
   httpRequests: Table[HttpRequestHandle, EmsHttpRequestState]
 
+  gamepadsConnectedMask: uint8
+  gamepadStates: array[maxGamepads, GamepadState]
+
 proc handleButtonPress(window: Window, button: Button)
 proc handleButtonRelease(window: Window, button: Button)
 proc handleRune(window: Window, rune: Rune)
 proc setupEventHandlers(window: Window)  # Forward declaration
+proc setupGamepads()
 
 proc init =
   if initialized:
@@ -242,6 +246,7 @@ proc newWindow*(
 
   # Setup event handlers
   setupEventHandlers(result)
+  setupGamepads()
 
   result.title = title
   if pos != ivec2(0, 0):
@@ -462,6 +467,59 @@ proc keyCodeToButton(keyCode: culong): Button =
   of 222: KeyApostrophe
   else: ButtonUnknown
 
+gamepadPlatform()
+
+proc gamepadConnected*(gamepadId: int): bool =
+  (gamepadsConnectedMask and (1.uint8 shl gamepadId)) != 0
+
+proc strcmp(a: cstring, b: cstring): cint {.importc, header: "<string.h>".}
+
+proc onGamepadConnected(eventType: cint, gamepadEvent: ptr EmscriptenGamepadEvent, userData: pointer): EM_BOOL {.cdecl.} =
+  # We can only ensure known stable mappings if the gamepad reports the standard mapping
+  if strcmp(cast[cstring](addr gamepadEvent.mapping), cstring "standard") == 0:
+    gamepadsConnectedMask = gamepadsConnectedMask or (1.uint8 shl gamepadEvent.index)
+    gamepadStates[gamepadEvent.index].name = $gamepadEvent.id
+    if common.onGamepadConnected != nil:
+      common.onGamepadConnected(gamepadEvent.index)
+  return 1
+
+proc onGamepadDisconnected(eventType: cint, gamepadEvent: ptr EmscriptenGamepadEvent, userData: pointer): EM_BOOL {.cdecl.} =
+  if (gamepadsConnectedMask and (1.uint8 shl gamepadEvent.index)) != 0:
+    gamepadsConnectedMask = gamepadsConnectedMask and (not (1.uint8 shl gamepadEvent.index))
+    gamepadResetState(gamepadStates[gamepadEvent.index])
+    if common.onGamepadDisconnected != nil:
+      common.onGamepadDisconnected(gamepadEvent.index)
+  return 1
+
+proc setupGamepads() =
+  discard emscripten_sample_gamepad_data() # Populate gamepad status data we're about to read
+
+  var gp: EmscriptenGamepadEvent
+  for i in 0..<maxGamepads:
+    if emscripten_get_gamepad_status(cint i, addr gp) == 0 and gp.connected:
+      discard onGamepadConnected(0, addr gp, nil)
+
+proc pollGamepads() =
+  discard emscripten_sample_gamepad_data()
+
+  var gp: EmscriptenGamepadEvent
+  for i in 0..<maxGamepads:
+    if (gamepadsConnectedMask and (1.uint8 shl i)) == 0:
+      continue
+
+    discard emscripten_get_gamepad_status(cint i, addr gp)
+
+    var state = addr gamepadStates[i]
+    var buttons = uint32 0
+    for j in 0..<GamepadButtonCount.int:
+      state.pressures[j] = gp.analogButton[j]
+      if gp.digitalButton[j]:
+        buttons = buttons or (uint32 1 shl j)
+    for j in 0..<GamepadAxisCount.int:
+      state.axes[j] = gp.axis[j]
+
+    gamepadUpdateButtons()
+
 proc mouseButtonToButton(button: cushort): Button =
   case button:
   of 0: MouseLeft
@@ -554,6 +612,10 @@ proc onCanvasResize(userData: pointer) {.cdecl, exportc.} =
       window.onResize()
 
 proc setupEventHandlers(window: Window) =
+  # Gamepad events
+  discard emscripten_set_gamepadconnected_callback_on_thread(nil, 1, onGamepadConnected, EM_CALLBACK_THREAD_CONTEXT)
+  discard emscripten_set_gamepaddisconnected_callback_on_thread(nil, 1, onGamepadDisconnected, EM_CALLBACK_THREAD_CONTEXT)
+
   # Mouse events
   discard emscripten_set_mousedown_callback_on_thread(window.canvas, cast[pointer](window), 1, onMouseDown, EM_CALLBACK_THREAD_CONTEXT)
   discard emscripten_set_mouseup_callback_on_thread(window.canvas, cast[pointer](window), 1, onMouseUp, EM_CALLBACK_THREAD_CONTEXT)
diff --git a/src/windy/platforms/linux/gamepad.nim b/src/windy/platforms/linux/gamepad.nim
new file mode 100644
index 0000000..480d67d
--- /dev/null
+++ b/src/windy/platforms/linux/gamepad.nim
@@ -0,0 +1,217 @@
+import std/[os, posix], lindefs, ../../[common, internal]
+
+# NOTE udev gets us userspace devices for initial discovery and hotplug events.
+#
+# Beyond that, there are 3 different ways to get device events on linux:
+# 1. the joystick subsystem, it's deprecated and we don't use it.
+# 2. the evdev subsystem, with standardized names at the kernel level.
+# 3. the hidraw subsystem, needing to parse raw vendor frames, but supporting features beyond axes and buttons.
+#
+# We only use the evdev subsystem as of now.
+
+var
+  epoll: cint
+  udev: ptr udev
+  udevMonitor: ptr udev_monitor
+  udevMonitorFd: cint
+  devices: array[maxGamepads, ptr libevdev]
+  devicePaths: array[maxGamepads, cstring]
+  deviceAbsInfo: array[maxGamepads, array[6, ptr input_absinfo]]
+  gamepadStates: array[maxGamepads, GamepadState]
+  defaultAbsInfo: input_absinfo = input_absinfo(minimum: -32768, maximum: 32767)
+
+gamepadPlatform()
+
+proc gamepadConnected*(gamepadId: int): bool =
+  devices[gamepadId] != nil
+
+proc gamepadResetAbsInfo*(gamepadId: int) =
+  for j in 0..<6:
+    deviceAbsInfo[gamepadId][j] = addr defaultAbsInfo
+
+proc strncmp(a: cstring, b: cstring, n: cint): cint {.importc, header: "<string.h>".}
+
+proc gamepadEvent(device: ptr udev_device, added: bool) =
+  # Final filtering and registration of gamepad devices,
+  # silently treating open errors as unavailable devices.
+  # The rare possible cases of failure, beyond code errors, are dire conditions like out of memory.
+  let devnode = udev_device_get_devnode(device)
+  if devnode != nil and strncmp(devnode, "/dev/input/event", 16) == 0:
+    let syspath = udev_device_get_syspath(device)
+    if added:
+      for i in 0..<maxGamepads:
+        if devices[i] == nil:
+          let fd = open(devnode, O_RDONLY or O_NONBLOCK)
+          if fd < 0:
+            return
+
+          var device: ptr libevdev
+          if libevdev_new_from_fd(fd, addr device) != 0:
+            discard close(fd)
+            return
+
+          var ev = epoll_event(events: EPOLLIN, data: epoll_data_t(u32: uint32 i))
+          if epoll_ctl(epoll, EPOLL_CTL_ADD, fd, addr ev) != 0:
+            libevdev_free(device)
+            discard close(fd)
+            return
+
+          devices[i] = device
+          devicePaths[i] = syspath
+          gamepadStates[i].name = $libevdev_get_name(device)
+
+          # Cache the absolute info for the supported device axes,
+          # handling odd cases where faulty drivers report broken ranges to prevent division by zero.
+          for j in 0..<6:
+            if not libevdev_has_event_code(device, EV_ABS, uint16 j):
+              continue # Device says it doesn't report this axis code.
+
+            let info = libevdev_get_abs_info(device, uint16 j)
+            if info != nil and info.maximum > info.minimum:
+              deviceAbsInfo[i][j] = info
+
+          if onGamepadConnected != nil: onGamepadConnected(i)
+          break
+    else:
+      for i in 0..<maxGamepads:
+        if devicePaths[i] == syspath:
+          gamepadResetAbsInfo(i)
+
+          let fd = libevdev_get_fd(devices[i])
+          discard epoll_ctl(epoll, EPOLL_CTL_DEL, fd, nil)
+          libevdev_free(devices[i])
+          discard close(fd)
+
+          devices[i] = nil
+          devicePaths[i] = nil
+          gamepadResetState(gamepadStates[i])
+
+          if onGamepadDisconnected != nil: onGamepadDisconnected(i)
+          break
+
+proc gamepadSetup() =
+  for i in 0..<maxGamepads:
+    gamepadResetAbsInfo(i)
+
+  epoll = epoll_create1(O_CLOEXEC)
+  if epoll < 0: raiseOSError(osLastError())
+  
+  udev = udev_new()
+  if udev == nil: raiseOSError(osLastError())
+
+  # Setup a udev monitor to listen for hotplug events.
+  udevMonitor = udev_monitor_new_from_netlink(udev, "udev")
+  if udev_monitor == nil: raiseOSError(osLastError())
+  discard udev_monitor_filter_add_match_subsystem_devtype(udevMonitor, "input", nil)
+  discard udev_monitor_enable_receiving(udevMonitor)
+
+  udevMonitorFd = udev_monitor_get_fd(udevMonitor)
+  let fl = fcntl(udevMonitorFd, F_GETFL)
+  if fl < 0: raiseOSError(osLastError())
+  discard fcntl(udevMonitorFd, F_SETFL, fl or O_NONBLOCK)
+
+  var ev = epoll_event(events: EPOLLIN, data: epoll_data_t(u32: 0xFFFFFFFF'u32))
+  let rc = epoll_ctl(epoll, EPOLL_CTL_ADD, udevMonitorFd, addr ev)
+  if rc < 0: raiseOSError(osLastError())
+
+  # Enumerate gamepads already connected.
+  let enumerate = udev_enumerate_new(udev)
+  discard udev_enumerate_add_match_subsystem(enumerate, "input")
+  discard udev_enumerate_add_match_property(enumerate, "ID_INPUT_JOYSTICK", "1") # Matches every input device otherwise.
+  discard udev_enumerate_scan_devices(enumerate)
+  var entry: ptr udev_list_entry
+  udev_list_entry_foreach(udev_enumerate_get_list_entry(enumerate)):
+    let name = udev_list_entry_get_name(entry)
+    let device = udev_device_new_from_syspath(udev, name)
+    gamepadEvent(device, true)
+    discard udev_device_unref(device)
+  discard udev_enumerate_unref(enumerate)
+
+proc gamepadPoll() =
+  for i in 0..<maxGamepads:
+    let state = addr gamepadStates[i]
+    state.pressed = 0
+    state.released = 0
+
+  const maxEvents = maxGamepads + 1
+  var events: array[maxEvents, epoll_event]
+  var event: input_event
+  let n = epoll_wait(epoll, addr events[0], maxEvents, 0)
+  for i in 0..<n:
+    # Ignore ERR and HUP events. These are always returned by epoll_wait.
+    if (events[i].events and EPOLLIN) == 0:
+      continue
+
+    # Hotplug events use an invalid gamepad index.
+    let index = events[i].data.u32
+    if index == 0xFFFFFFFF'u32:
+      let device = udev_monitor_receive_device(udevMonitor)
+      let action = udev_device_get_action(device)
+      if action != nil and udev_device_get_property_value(device, "ID_INPUT_JOYSTICK") == "1":
+        if action == "add": gamepadEvent(device, true)
+        elif action == "remove": gamepadEvent(device, false)
+      discard udev_device_unref(device)
+    # Gamepad events are read until there are none left for the device.
+    else:
+      let device = devices[index]
+      assert device != nil
+      let state = addr gamepadStates[index]
+      var buttons = state.buttons
+      template btn(value: bool, id: GamepadButton) =
+        let bit = uint32 1 shl id.int
+        if value: buttons = buttons or bit
+        else: buttons = buttons and (not bit)
+      var readFlag: cint = LIBEVDEV_READ_FLAG_NORMAL
+      while true:
+        case libevdev_next_event(device, readFlag, addr event)
+        # libev caught a SYN_DROPPED event, switch to sync mode.
+        of LIBEVDEV_READ_STATUS_SYNC:
+          readFlag = LIBEVDEV_READ_FLAG_SYNC
+        # done reading the device snapshot, resume after sync.
+        of -EAGAIN:
+          if readFlag == LIBEVDEV_READ_FLAG_SYNC:
+            readFlag = LIBEVDEV_READ_FLAG_NORMAL
+          else: break
+        # reading the device normally.
+        else: discard
+
+        # Translate the event into gamepad state.
+        case event.`type`
+        of EV_KEY: btn(event.value != 0, case event.code
+          of BTN_A: GamepadA
+          of BTN_B: GamepadB
+          of BTN_X: GamepadY
+          of BTN_Y: GamepadX
+          of BTN_TL: GamepadL1
+          of BTN_TR: GamepadR1
+          of BTN_TL2: GamepadL2
+          of BTN_TR2: GamepadR2
+          of BTN_SELECT: GamepadSelect
+          of BTN_START: GamepadStart
+          of BTN_MODE: GamepadHome
+          of BTN_THUMBL: GamepadL3
+          of BTN_THUMBR: GamepadR3
+          else: continue)
+        of EV_ABS:
+          template axis(): float32 =
+            let abs = deviceAbsInfo[index][event.code]
+            let norm = 2.0 * float32(event.value - abs.minimum) / float32(abs.maximum - abs.minimum) - 1.0
+            gamepadFilterDeadZone(norm)
+          template pressure(id: GamepadButton) =
+            state.pressures[id.int] = axis()
+            btn(event.value != 0, id)
+          template dpad(neg: GamepadButton, pos: GamepadButton) =
+            btn(event.value < 0, neg)
+            btn(event.value > 0, pos)
+          case event.code
+            of ABS_X: state.axes[GamepadLStickX.int] = axis()
+            of ABS_Y: state.axes[GamepadLStickY.int] = axis()
+            of ABS_RX: state.axes[GamepadRStickX.int] = axis()
+            of ABS_RY: state.axes[GamepadRStickY.int] = axis()
+            of ABS_Z: pressure(GamepadL2)
+            of ABS_RZ: pressure(GamepadR2)
+            of ABS_HAT0X: dpad(GamepadLeft, GamepadRight)
+            of ABS_HAT0Y: dpad(GamepadUp, GamepadDown)
+            else: discard
+        else: discard
+      gamepadUpdateButtons()
diff --git a/src/windy/platforms/linux/lindefs.nim b/src/windy/platforms/linux/lindefs.nim
new file mode 100644
index 0000000..76a8e68
--- /dev/null
+++ b/src/windy/platforms/linux/lindefs.nim
@@ -0,0 +1,211 @@
+{.passL: "-ludev -levdev."}
+
+# <sys/epoll.h>
+type
+  epoll_data_t* {.union.} = object
+    `ptr`*: pointer
+    fd*: cint
+    u32*: uint32
+    u64*: uint64
+  epoll_event* = object
+    events*: uint32
+    data*: epoll_data_t
+
+const
+  EPOLL_CTL_ADD* = 1
+  EPOLL_CTL_DEL* = 2
+  EPOLL_CTL_MOD* = 3
+  EPOLLIN* = 0x001
+
+{.push importc, cdecl.}
+
+proc epoll_create1*(flags: cint): cint
+proc epoll_ctl*(epfd: cint, op: cint, fd: cint, event: ptr epoll_event): cint
+proc epoll_wait*(epfd: cint, events: ptr epoll_event, maxevents: cint, timeout: cint): cint
+
+# <libudev.h>
+type
+  dev_t* = uint64
+
+  udev* = object
+  udev_list_entry* = object
+  udev_device* = object
+  udev_monitor* = object
+  udev_enumerate* = object
+
+proc udev_ref*(udev: ptr udev): ptr udev
+proc udev_unref*(udev: ptr udev): ptr udev
+proc udev_new*(): ptr udev
+
+proc udev_list_entry_get_next*(list_entry: ptr udev_list_entry): ptr udev_list_entry
+proc udev_list_entry_get_by_name*(list_entry: ptr udev_list_entry, name: cstring): ptr udev_list_entry
+proc udev_list_entry_get_name*(list_entry: ptr udev_list_entry): cstring
+proc udev_list_entry_get_value*(list_entry: ptr udev_list_entry): cstring
+
+template udev_list_entry_foreach*(first_entry: ptr udev_list_entry, body: untyped) =
+  entry = first_entry
+  while entry != nil:
+    body
+    entry = udev_list_entry_get_next(entry)
+
+proc udev_device_ref*(udev_device: ptr udev_device): ptr udev_device
+proc udev_device_unref*(udev_device: ptr udev_device): ptr udev_device
+proc udev_device_get_udev*(udev_device: ptr udev_device): ptr udev
+proc udev_device_new_from_syspath*(udev: ptr udev, syspath: cstring): ptr udev_device
+proc udev_device_new_from_devnum*(udev: ptr udev, `type`: cchar, devnum: dev_t): ptr udev_device
+proc udev_device_new_from_subsystem_sysname*(udev: ptr udev, subsystem: cstring, sysname: cstring): ptr udev_device
+proc udev_device_new_from_device_id*(udev: ptr udev, id: cstring): ptr udev_device
+proc udev_device_new_from_environment*(udev: ptr udev): ptr udev_device
+proc udev_device_get_parent*(udev_device: ptr udev_device): ptr udev_device
+proc udev_device_get_parent_with_subsystem_devtype*(udev_device: ptr udev_device, subsystem: cstring, devtype: cstring): ptr udev_device
+proc udev_device_get_devpath*(udev_device: ptr udev_device): cstring
+proc udev_device_get_subsystem*(udev_device: ptr udev_device): cstring
+proc udev_device_get_devtype*(udev_device: ptr udev_device): cstring
+proc udev_device_get_syspath*(udev_device: ptr udev_device): cstring
+proc udev_device_get_sysname*(udev_device: ptr udev_device): cstring
+proc udev_device_get_sysnum*(udev_device: ptr udev_device): cstring
+proc udev_device_get_devnode*(udev_device: ptr udev_device): cstring
+proc udev_device_get_is_initialized*(udev_device: ptr udev_device): cint
+proc udev_device_get_devlinks_list_entry*(udev_device: ptr udev_device): ptr udev_list_entry
+proc udev_device_get_properties_list_entry*(udev_device: ptr udev_device): ptr udev_list_entry
+proc udev_device_get_tags_list_entry*(udev_device: ptr udev_device): ptr udev_list_entry
+proc udev_device_get_current_tags_list_entry*(udev_device: ptr udev_device): ptr udev_list_entry
+proc udev_device_get_sysattr_list_entry*(udev_device: ptr udev_device): ptr udev_list_entry
+proc udev_device_get_property_value*(udev_device: ptr udev_device, key: cstring): cstring
+proc udev_device_get_driver*(udev_device: ptr udev_device): cstring
+proc udev_device_get_devnum*(udev_device: ptr udev_device): dev_t
+proc udev_device_get_action*(udev_device: ptr udev_device): cstring
+proc udev_device_get_seqnum*(udev_device: ptr udev_device): culong
+proc udev_device_get_usec_since_initialized*(udev_device: ptr udev_device): culong
+proc udev_device_get_sysattr_value*(udev_device: ptr udev_device, sysattr: cstring): cstring
+proc udev_device_set_sysattr_value*(udev_device: ptr udev_device, sysattr: cstring, value: cstring): cint
+proc udev_device_has_tag*(udev_device: ptr udev_device, tag: cstring): cint
+proc udev_device_has_current_tag*(udev_device: ptr udev_device, tag: cstring): cint
+
+proc udev_monitor_ref*(udev_monitor: ptr udev_monitor): ptr udev_monitor
+proc udev_monitor_unref*(udev_monitor: ptr udev_monitor): ptr udev_monitor
+proc udev_monitor_get_udev*(udev_monitor: ptr udev_monitor): ptr udev
+proc udev_monitor_new_from_netlink*(udev: ptr udev, name: cstring): ptr udev_monitor
+proc udev_monitor_enable_receiving*(udev_monitor: ptr udev_monitor): cint
+proc udev_monitor_set_receive_buffer_size*(udev_monitor: ptr udev_monitor, size: cint): cint
+proc udev_monitor_get_fd*(udev_monitor: ptr udev_monitor): cint
+proc udev_monitor_receive_device*(udev_monitor: ptr udev_monitor): ptr udev_device
+proc udev_monitor_filter_add_match_subsystem_devtype*(udev_monitor: ptr udev_monitor, subsystem: cstring, devtype: cstring): cint
+proc udev_monitor_filter_add_match_tag*(udev_monitor: ptr udev_monitor, tag: cstring): cint
+proc udev_monitor_filter_update*(udev_monitor: ptr udev_monitor): cint
+proc udev_monitor_filter_remove*(udev_monitor: ptr udev_monitor): cint
+
+proc udev_enumerate_ref*(udev_enumerate: ptr udev_enumerate): ptr udev_enumerate
+proc udev_enumerate_unref*(udev_enumerate: ptr udev_enumerate): ptr udev_enumerate
+proc udev_enumerate_get_udev*(udev_enumerate: ptr udev_enumerate): ptr udev
+proc udev_enumerate_new*(udev: ptr udev): ptr udev_enumerate
+proc udev_enumerate_add_match_subsystem*(udev_enumerate: ptr udev_enumerate, subsystem: cstring): cint
+proc udev_enumerate_add_match_sysname*(udev_enumerate: ptr udev_enumerate, sysname: cstring): cint
+proc udev_enumerate_add_match_property*(udev_enumerate: ptr udev_enumerate, property: cstring, value: cstring): cint
+proc udev_enumerate_add_match_tag*(udev_enumerate: ptr udev_enumerate, tag: cstring): cint
+proc udev_enumerate_add_match_parent*(udev_enumerate: ptr udev_enumerate, parent: ptr udev_device): cint
+proc udev_enumerate_add_match_is_initialized*(udev_enumerate: ptr udev_enumerate): cint
+proc udev_enumerate_add_syspath*(udev_enumerate: ptr udev_enumerate, syspath: cstring): cint
+proc udev_enumerate_scan_devices*(udev_enumerate: ptr udev_enumerate): cint
+proc udev_enumerate_scan_subsystems*(udev_enumerate: ptr udev_enumerate): cint
+proc udev_enumerate_get_list_entry*(udev_enumerate: ptr udev_enumerate): ptr udev_list_entry
+
+# <sys/time.h>
+type
+  timeval* = object
+    tv_sec*: clong
+    tv_usec*: clong
+
+# <linux/input.h>
+type
+  input_event* = object
+    time*: timeval
+    `type`*: uint16
+    code*: uint16
+    value*: int32
+  input_absinfo* = object
+    value*: int32
+    minimum*: int32
+    maximum*: int32
+    fuzz*: int32
+    flat*: int32
+    resolution*: int32
+
+# <linux/input-event-codes.h>
+const
+  EV_SYN* = 0
+  EV_KEY* = 1
+  EV_ABS* = 3
+
+  SYN_DROPPED* = 3
+
+  BTN_A* = 0x130
+  BTN_B* = 0x131
+  BTN_C* = 0x132
+  BTN_X* = 0x133
+  BTN_Y* = 0x134
+  BTN_Z* = 0x135
+  BTN_TL* = 0x136
+  BTN_TR* = 0x137
+  BTN_TL2* = 0x138
+  BTN_TR2* = 0x139
+  BTN_SELECT* = 0x13a
+  BTN_START* = 0x13b
+  BTN_MODE* = 0x13c
+  BTN_THUMBL* = 0x13d
+  BTN_THUMBR* = 0x13e
+
+  ABS_X* = 0x00
+  ABS_Y* = 0x01
+  ABS_Z* = 0x02
+  ABS_RX* = 0x03
+  ABS_RY* = 0x04
+  ABS_RZ* = 0x05
+  ABS_THROTTLE* = 0x06
+  ABS_RUDDER* = 0x07
+  ABS_WHEEL* = 0x08
+  ABS_GAS* = 0x09
+  ABS_BRAKE* = 0x0a
+  ABS_HAT0X* = 0x10
+  ABS_HAT0Y* = 0x11
+  ABS_HAT1X* = 0x12
+  ABS_HAT1Y* = 0x13
+  ABS_HAT2X* = 0x14
+  ABS_HAT2Y* = 0x15
+  ABS_HAT3X* = 0x16
+  ABS_HAT3Y* = 0x17
+  ABS_PRESSURE* = 0x18
+  ABS_DISTANCE* = 0x19
+  ABS_TILT_X* = 0x1a
+  ABS_TILT_Y* = 0x1b
+  ABS_TOOL_WIDTH* = 0x1c
+
+  ABS_VOLUME* = 0x20
+  ABS_PROFILE* = 0x21
+
+  ABS_MISC* = 0x28
+
+# <libevdev-1.0/libevdev/libevdev.h>
+type
+  libevdev* = object
+
+const
+  LIBEVDEV_READ_FLAG_SYNC* = 1
+  LIBEVDEV_READ_FLAG_NORMAL* = 2
+  LIBEVDEV_READ_STATUS_SYNC* = -1
+
+proc libevdev_new_from_fd*(fd: cint, dev: ptr ptr libevdev): cint
+proc libevdev_free*(dev: ptr libevdev)
+proc libevdev_get_fd*(dev: ptr libevdev): cint
+proc libevdev_get_name*(dev: ptr libevdev): cstring
+proc libevdev_get_phys*(dev: ptr libevdev): cstring
+proc libevdev_get_uniq*(dev: ptr libevdev): cstring
+proc libevdev_get_id_product*(dev: ptr libevdev): cint
+proc libevdev_get_id_vendor*(dev: ptr libevdev): cint
+proc libevdev_get_id_bustype*(dev: ptr libevdev): cint
+proc libevdev_get_id_version*(dev: ptr libevdev): cint
+proc libevdev_has_event_code*(dev: ptr libevdev, `type`: uint16, code: uint16): bool
+proc libevdev_get_abs_info*(dev: ptr libevdev, code: uint16): ptr input_absinfo
+proc libevdev_next_event*(dev: ptr libevdev, flags: cint, event: ptr input_event): cint
+
+{.pop.}
diff --git a/src/windy/platforms/linux/x11.nim b/src/windy/platforms/linux/x11.nim
index 2e0ab35..49a444f 100644
--- a/src/windy/platforms/linux/x11.nim
+++ b/src/windy/platforms/linux/x11.nim
@@ -7,6 +7,8 @@ import
 import ../../http
 export http
 
+include gamepad
+
 type
   XWindow = x.Window
 
@@ -118,6 +120,8 @@ proc init =
     else:
       WmForDecoratedKind.unsupported
 
+  gamepadSetup()
+
   initialized = true
 
 proc property(
@@ -786,6 +790,7 @@ proc newWindow*(
   windows.add result
 
 proc pollEvents(window: Window) =
+  gamepadPoll()
 
   # Clear all per-frame data
   window.perFrame = PerFrame()
diff --git a/src/windy/platforms/macos/macdefs.nim b/src/windy/platforms/macos/macdefs.nim
index fbb75c0..cb7ad2f 100644
--- a/src/windy/platforms/macos/macdefs.nim
+++ b/src/windy/platforms/macos/macdefs.nim
@@ -1,7 +1,7 @@
 import opengl, objc
 export objc
 
-{.passL: "-framework Cocoa".}
+{.passL: "-framework Cocoa -framework GameController".}
 
 type
   CGPoint* {.pure, bycopy.} = object
@@ -47,6 +47,7 @@ type
   NSPasteboardType* = distinct NSString
   NSApplication* = distinct NSObject
   NSNotification* = distinct NSObject
+  NSNotificationCenter* = distinct NSObject
   NSEvent* = distinct NSObject
   NSDate* = distinct NSObject
   NSRunLoopMode* = distinct NSString
@@ -66,6 +67,20 @@ type
   NSBitmapImageRep* = distinct NSObject
   NSDictionary* = distinct NSObject
 
+  GCDevice* = distinct NSObject
+  GCController* = distinct NSObject
+  GCPhysicalInputProfile* = distinct NSObject
+  GCControllerElement* = distinct NSObject
+  GCControllerAxisInput* = distinct GCControllerElement
+  GCControllerButtonInput* = distinct GCControllerElement
+  GCControllerDirectionPad* = distinct GCControllerElement
+  GCControllerTouchpad* = distinct GCControllerElement
+
+  GCSystemGestureState* = enum
+    GCSystemGestureStateEnabled
+    GCSystemGestureStateAlwaysReceive
+    GCSystemGestureStateDisabled
+
 const
   NSNotFound* = int.high
   kEmptyRange* = NSRange(location: cast[uint](NSNotFound), length: 0)
@@ -120,6 +135,26 @@ var
   NSPasteboardTypeString* {.importc.}: NSPasteboardType
   NSPasteboardTypeTIFF* {.importc.}: NSPasteboardType
   NSDefaultRunLoopMode* {.importc.}: NSRunLoopMode
+  GCControllerDidConnectNotification* {.importc.}: NSString
+  GCControllerDidDisconnectNotification* {.importc.}: NSString
+  GCInputLeftShoulder* {.importc.}: NSString
+  GCInputRightShoulder* {.importc.}: NSString
+  GCInputLeftBumper* {.importc.}: NSString
+  GCInputRightBumper* {.importc.}: NSString
+  GCInputLeftTrigger* {.importc.}: NSString
+  GCInputRightTrigger* {.importc.}: NSString
+  GCInputButtonMenu* {.importc.}: NSString
+  GCInputButtonHome* {.importc.}: NSString
+  GCInputButtonOptions* {.importc.}: NSString
+  GCInputButtonA* {.importc.}: NSString
+  GCInputButtonB* {.importc.}: NSString
+  GCInputButtonX* {.importc.}: NSString
+  GCInputButtonY* {.importc.}: NSString
+  GCInputDirectionPad* {.importc.}: NSString
+  GCInputLeftThumbstick* {.importc.}: NSString
+  GCInputRightThumbstick* {.importc.}: NSString
+  GCInputLeftThumbstickButton* {.importc.}: NSString
+  GCInputRightThumbstickButton* {.importc.}: NSString
 
 objc:
   proc isKindOfClass*(self: NSObject, x: Class): bool
@@ -155,6 +190,7 @@ objc:
   proc count*(self: NSArray): uint
   proc objectAtIndex*(self: NSArray, x: uint): ID
   proc containsObject*(self: NSArray, x: ID): bool
+  proc valueForKey*(self: NSDictionary, x: NSString): ID
   proc screens*(class: typedesc[NSScreen]): NSArray
   proc frame*(self: NSScreen): NSRect
   proc frame*(self: NSWindow): NSRect
@@ -300,6 +336,32 @@ objc:
     properties: NSDictionary
   ): NSData
 
+  proc `object`*(self: NSNotification): ID
+
+  proc defaultCenter*(class: typedesc[NSNotificationCenter]): NSNotificationCenter
+  proc addObserver*(self: NSNotificationCenter, x: ID, selector: SEL, name: NSString, object_mangle: ID)
+
+  proc vendorName*(self: GCDevice): NSString
+  proc controllers*(class: typedesc[GCController]): NSArray
+  proc startWirelessControllerDiscoveryWithCompletionHandler*(class: typedesc[GCController], x: ID)
+  proc playerIndex*(self: GCController): int
+  proc setPlayerIndex*(self: GCController, x: int)
+  proc physicalInputProfile*(self: GCController): GCPhysicalInputProfile
+  proc device*(self: GCPhysicalInputProfile): GCDevice
+  proc lastEventTimestamp*(self: GCPhysicalInputProfile): float64
+  proc buttons*(self: GCPhysicalInputProfile): NSDictionary
+  proc dpads*(self: GCPhysicalInputProfile): NSDictionary
+  proc setPreferredSystemGestureState*(self: GCControllerElement, x: GCSystemGestureState)
+  proc left*(self: GCControllerDirectionPad): GCControllerButtonInput
+  proc right*(self: GCControllerDirectionPad): GCControllerButtonInput
+  proc up*(self: GCControllerDirectionPad): GCControllerButtonInput
+  proc down*(self: GCControllerDirectionPad): GCControllerButtonInput
+  proc xAxis*(self: GCControllerDirectionPad): GCControllerAxisInput
+  proc yAxis*(self: GCControllerDirectionPad): GCControllerAxisInput
+  proc value*(self: GCControllerAxisInput): float32
+  proc value*(self: GCControllerButtonInput): float32
+  proc isPressed*(self: GCControllerButtonInput): bool
+
 {.push inline.}
 
 proc NSMakeRect*(x, y, w, h: float64): NSRect =
@@ -320,6 +382,9 @@ proc NSMakePoint*(x, y: float): NSPoint =
 proc `[]`*(arr: NSArray, index: int): ID =
   arr.objectAtIndex(index.uint)
 
+proc `[]`*(dict: NSDictionary, key: NSString): ID =
+  dict.valueForKey(key)
+
 proc callSuper*(sender: ID, cmd: SEL) =
   var super = objc_super(
     receiver: sender,
diff --git a/src/windy/platforms/macos/objc.nim b/src/windy/platforms/macos/objc.nim
index 507cb13..edd0f10 100644
--- a/src/windy/platforms/macos/objc.nim
+++ b/src/windy/platforms/macos/objc.nim
@@ -15,6 +15,7 @@ type
     super_class*: Class
 
 {.push cdecl, dynlib: "libobjc.dylib".}
+
 proc objc_msgSend*() {.importc.}
 proc objc_msgSendSuper*() {.importc.}
 when defined(amd64):
@@ -55,6 +56,7 @@ macro objc*(body: untyped) =
       numParams = 0
 
     sel.removeSuffix("*")
+    sel = sel.strip(true, true, {'`'})
 
     # Mark each proc inline:
     fn[4] = quote do: {.inline.}
diff --git a/src/windy/platforms/macos/platform.nim b/src/windy/platforms/macos/platform.nim
index 10f94b6..0141b79 100644
--- a/src/windy/platforms/macos/platform.nim
+++ b/src/windy/platforms/macos/platform.nim
@@ -6,6 +6,10 @@ import ../../http
 export http
 
 type
+  Gamepad* = object
+    numButtons*: int8
+    numAxes*: int8
+
   Window* = ref object
     onCloseRequest*: Callback
     onFrame*: Callback
@@ -40,6 +44,16 @@ var
   WindyAppDelegate, WindyWindow, WindyView: Class
   windows: seq[Window]
 
+  # Gamepad state is what we expose; profiles, lookups and inputs are cached for polling GCController each frame
+  gamepads: array[maxGamepads, Gamepad]
+  gamepadStates: array[maxGamepads, GamepadState]
+  gamepadProfiles: array[maxGamepads, GCPhysicalInputProfile]
+  gamepadTimestamps: array[maxGamepads, float64]
+  gamepadAxisLookup: array[maxGamepads, array[GamepadAxisCount.int, int8]]
+  gamepadAxisInputs: array[maxGamepads, array[GamepadAxisCount.int, GCControllerAxisInput]]
+  gamepadButtonLookup: array[maxGamepads, array[GamepadButtonCount.int, int8]]
+  gamepadButtonInputs: array[maxGamepads, array[GamepadButtonCount.int, GCControllerButtonInput]]
+
 proc indexForNSWindow(windows: seq[Window], inner: NSWindow): int =
   ## Returns the window for this handle, else -1
   for i, window in windows:
@@ -295,6 +309,117 @@ proc applicationDidFinishLaunching(
   NSApp.setActivationPolicy(NSApplicationActivationPolicyRegular)
   NSApp.activateIgnoringOtherApps(true)
 
+gamepadPlatform()
+
+proc gamepadConnected*(gamepadId: int): bool =
+  gamepadProfiles[gamepadId].int != 0
+
+proc pollGamepads() =
+  for i in 0..<gamepadProfiles.len:
+    let profile = gamepadProfiles[i]
+    if profile.int == 0:
+      continue
+
+    let epoch = profile.lastEventTimestamp()
+    var state = gamepadStates[i].addr
+    if epoch <= gamepadTimestamps[i]:
+      state.pressed = 0
+      state.released = 0
+    else:
+      gamepadTimestamps[i] = epoch
+
+      for j in 0..<gamepads[i].numAxes:
+        state.axes[gamepadAxisLookup[i][j]] = gamepadAxisInputs[i][j].value()
+
+      var buttons = 0.uint32
+      for j in 0..<gamepads[i].numButtons:
+        let button = gamepadButtonInputs[i][j]
+        let index = gamepadButtonLookup[i][j]
+        state.pressures[index] = button.value()
+
+        if button.isPressed():
+          buttons = buttons or (1.uint32 shl index)
+
+      gamepadUpdateButtons()
+
+proc profileForController(ctrl: GCController): GCPhysicalInputProfile =
+  for i in 0..<gamepadProfiles.len:
+    if gamepadProfiles[i].int == 0:
+      ctrl.setPlayerIndex(i)
+      let profile = ctrl.physicalInputProfile()
+      gamepadProfiles[i] = profile
+      return profile
+  return 0.GCPhysicalInputProfile
+
+proc addController(ctrl: GCController) =
+  let profile = profileForController(ctrl)
+  let i = ctrl.playerIndex
+  # NOTE GCController has buttons, dpads, axes and touchpads.
+  # However, axes are subcollections of dpads and touchpads are unpopulated by gamepads.
+  # Counter-intuitively, we take the gamepad dpad from buttons and the axes from dpads.
+  # This ends up matching the common gamepad interface with a single dpad consumed as 4 boolean buttons.
+  # Other axes can also be consumed as buttons, but they make more sense as axes with a neg/pos range.
+  # Buttons also make the distinction between analog and digital. Analog buttons also register as axes.
+  # For input names, we rely on Apple's mappings. Vendor names are available as a fallback but not used.
+  # Finally, it's possible for the same input element to appear in both buttons and dpads.
+  let dpads = profile.dpads()
+  let buttons = profile.buttons()
+  var numAxes = 0
+  var numButtons = 0
+  proc addButton(button: GCControllerButtonInput, index: GamepadButton) =
+    if button.int != 0:
+      button.GCControllerElement.setPreferredSystemGestureState(GCSystemGestureStateDisabled)
+      gamepadButtonInputs[i][numButtons] = button
+      gamepadButtonLookup[i][numButtons] = index.int8
+      numButtons += 1
+  proc addAxis(axis: GCControllerAxisInput, index: GamepadAxis) =
+    if axis.int != 0:
+      gamepadAxisInputs[i][numAxes] = axis
+      gamepadAxisLookup[i][numAxes] = index.int8
+      numAxes += 1
+  proc addStick(stick: GCControllerDirectionPad, x: GamepadAxis, y: GamepadAxis) =
+    if stick.int != 0:
+      addAxis(stick.xAxis, x)
+      addAxis(stick.yAxis, y)
+  let dpad = dpads[GCInputDirectionPad].GCControllerDirectionPad
+  if dpad.int != 0:
+    addButton(dpad.down, GamepadDown)
+    addButton(dpad.right, GamepadRight)
+    addButton(dpad.left, GamepadLeft)
+    addButton(dpad.up, GamepadUp)
+  addButton(buttons[GCInputButtonA].GCControllerButtonInput, GamepadA)
+  addButton(buttons[GCInputButtonB].GCControllerButtonInput, GamepadB)
+  addButton(buttons[GCInputButtonX].GCControllerButtonInput, GamepadX)
+  addButton(buttons[GCInputButtonY].GCControllerButtonInput, GamepadY)
+  addButton(buttons[GCInputLeftShoulder].GCControllerButtonInput, GamepadL1)
+  addButton(buttons[GCInputRightShoulder].GCControllerButtonInput, GamepadR1)
+  addButton(buttons[GCInputLeftTrigger].GCControllerButtonInput, GamepadL2)
+  addButton(buttons[GCInputRightTrigger].GCControllerButtonInput, GamepadR2)
+  addButton(buttons[GCInputLeftThumbstickButton].GCControllerButtonInput, GamepadL3)
+  addButton(buttons[GCInputRightThumbstickButton].GCControllerButtonInput, GamepadR3)
+  addButton(buttons[GCInputButtonOptions].GCControllerButtonInput, GamepadSelect)
+  addButton(buttons[GCInputButtonMenu].GCControllerButtonInput, GamepadStart)
+  addButton(buttons[GCInputButtonHome].GCControllerButtonInput, GamepadHome)
+  addStick(dpads[GCInputLeftThumbstick].GCControllerDirectionPad, GamepadLStickX, GamepadLStickY)
+  addStick(dpads[GCInputRightThumbstick].GCControllerDirectionPad, GamepadRStickX, GamepadRStickY)
+  gamepads[i].numButtons = numButtons.int8
+  gamepads[i].numAxes = numAxes.int8
+  gamepadStates[i].name = $profile.device().vendorName()
+  if onGamepadConnected != nil:
+    onGamepadConnected(i)
+
+proc controllerDidConnect(self: ID, cmd: SEL, notification: NSNotification): ID {.cdecl.} =
+  addController(notification.`object`.GCController)
+
+proc controllerDidDisconnect(self: ID, cmd: SEL, notification: NSNotification): ID {.cdecl.} =
+  let ctrl = notification.`object`.GCController
+  let index = ctrl.playerIndex
+  gamepadProfiles[index] = 0.GCPhysicalInputProfile
+  gamepadTimestamps[index] = 0.float64
+  gamepadResetState(gamepadStates[index])
+  if onGamepadDisconnected != nil:
+    onGamepadDisconnected(index)
+
 proc windowDidResize(
   self: ID,
   cmd: SEL,
@@ -686,7 +811,7 @@ proc resetCursorRects(self: ID, cmd: SEL): ID {.cdecl.} =
 
   self.NSView.addCursorRect(self.NSView.bounds, cursor)
 
-proc init() {.raises: [].} =
+proc init(withGamepad = true) {.raises: [].} =
   if initialized:
     return
 
@@ -696,6 +821,8 @@ proc init() {.raises: [].} =
     addClass "WindyAppDelegate", "NSObject", WindyAppDelegate:
       addMethod "applicationWillFinishLaunching:", applicationWillFinishLaunching
       addMethod "applicationDidFinishLaunching:", applicationDidFinishLaunching
+      addMethod "controllerDidConnect:", controllerDidConnect
+      addMethod "controllerDidDisconnect:", controllerDidDisconnect
 
     addClass "WindyWindow", "NSWindow", WindyWindow:
       addMethod "windowDidResize:", windowDidResize
@@ -737,12 +864,23 @@ proc init() {.raises: [].} =
       addMethod "resetCursorRects", resetCursorRects
 
     let appDelegate = WindyAppDelegate.new()
-    NSApp.setDelegate(appDelegate)
 
-    NSApp.finishLaunching()
+    if withGamepad:
+      let nc = NSNotificationCenter.defaultCenter()
+      nc.addObserver(appDelegate, s"controllerDidConnect:", GCControllerDidConnectNotification, 0.ID)
+      nc.addObserver(appDelegate, s"controllerDidDisconnect:", GCControllerDidDisconnectNotification, 0.ID)
+
+      GCController.startWirelessControllerDiscoveryWithCompletionHandler(0.ID)
+
+      let controllers = GCController.controllers()
+      for i in 0..<controllers.count():
+        addController(controllers[i.int].GCController)
 
     platformDoubleClickInterval = NSEvent.doubleClickInterval
 
+    NSApp.setDelegate(appDelegate)
+    NSApp.finishLaunching()
+
   initialized = true
 
 proc processKeyDown(event: NSEvent) =
@@ -773,6 +911,8 @@ proc processFlagsChanged(event: NSEvent) =
     window.handleButtonPress(button)
 
 proc pollEvents*() =
+  pollGamepads()
+
   # Draw first (in case a message closes a window or similar)
   for window in windows:
     if window.onFrame != nil:
@@ -875,7 +1015,6 @@ proc newWindow*(
     else:
       raise newException(WindyError, "Unsupported OpenGL version")
 
-
   autoreleasepool:
     result.inner = WindyWindow.alloc().NSWindow.initWithContentRect(
       NSMakeRect(0, 0, 400, 400),
diff --git a/src/windy/platforms/win32/platform.nim b/src/windy/platforms/win32/platform.nim
index be82222..e40fb60 100644
--- a/src/windy/platforms/win32/platform.nim
+++ b/src/windy/platforms/win32/platform.nim
@@ -153,6 +153,10 @@ var
   httpRequests: Table[HttpRequestHandle, ptr HttpRequestState]
   webSockets: Table[WebSocketHandle, ptr WebSocketState]
 
+  gameInput: ptr IGameInput
+  gamepadStates: array[maxGamepads, GamepadState]
+  gameInputDevices: array[maxGamepads, ptr IGameInputDevice] # NOTE GameInput's max is 8, but other platforms limit to 4
+
 proc indexForHandle(windows: seq[Window], hWnd: HWND): int =
   ## Returns the window for this handle, else -1
   for i, window in windows:
@@ -1024,6 +1028,92 @@ proc wndProc(
 
   DefWindowProcW(hWnd, uMsg, wParam, lParam)
 
+gamepadPlatform()
+
+proc gamepadConnected*(gamepadId: int): bool =
+  gameInputDevices[gamepadId] != nil
+
+proc pollGamepads() =
+  var reading: ptr IGameInputReading
+  var gamepad: GameInputGamepadState
+  for i in 0..<maxGamepads:
+    if gameInputDevices[i] == nil:
+      continue
+
+    # No reading this frame, so we don't change input state but reset derived state.
+    var state = addr gamepadStates[i]
+    if gameInput.lpVtbl.GetCurrentReading(gameInput,
+         GameInputKindGamepad, gameInputDevices[i], addr reading) != S_OK:
+      state.pressed = 0
+      state.released = 0
+      continue
+
+    # Only false if not a gamepad, but we only register gamepads.
+    discard reading.lpVtbl.GetGamepadState(reading, addr gamepad)
+
+    var buttons = uint32 0
+
+    template button(src: GameInputGamepadButtons, dst: GamepadButton) =
+      if (gamepad.buttons.uint32 and src.uint32) != 0:
+        buttons = buttons or (uint32 1 shl dst.int)
+
+    template remap(src: float, dst: GamepadButton) =
+      let val = gamepadFilterDeadZone(src)
+      state.pressures[dst.int] = val
+
+      if val > 0:
+        buttons = buttons or (uint32 1 shl dst.int)
+
+    template axis(src: float, dst: GamepadAxis) =
+      state.axes[dst.int] = gamepadFilterDeadZone(src)
+
+    axis(gamepad.leftThumbstickX, GamepadLStickX)
+    axis(gamepad.leftThumbstickY, GamepadLStickY)
+    axis(gamepad.rightThumbstickX, GamepadRStickX)
+    axis(gamepad.rightThumbstickY, GamepadRStickY)
+    remap(gamepad.leftTrigger, GamepadL2)
+    remap(gamepad.rightTrigger, GamepadR2)
+    button(GameInputGamepadMenu, GamepadStart)
+    button(GameInputGamepadView, GamepadSelect)
+    button(GameInputGamepadA, GamepadA)
+    button(GameInputGamepadB, GamepadB)
+    button(GameInputGamepadX, GamepadX)
+    button(GameInputGamepadY, GamepadY)
+    button(GameInputGamepadDPadUp, GamepadUp)
+    button(GameInputGamepadDPadDown, GamepadDown)
+    button(GameInputGamepadDPadLeft, GamepadLeft)
+    button(GameInputGamepadDPadRight, GamepadRight)
+    button(GameInputGamepadLeftShoulder, GamepadL1)
+    button(GameInputGamepadRightShoulder, GamepadR1)
+    button(GameInputGamepadLeftThumbstick, GamepadL3)
+    button(GameInputGamepadRightThumbstick, GamepadR3)
+
+    gamepadUpdateButtons()
+    comDispose(reading)
+
+proc gameInputDeviceCallback(callbackToken: GameInputCallbackToken, context: pointer, device: ptr IGameInputDevice, timestamp: uint64, currentStatus: GameInputDeviceStatus, previousStatus: GameInputDeviceStatus) {.stdcall.} =
+  if (currentStatus and GameInputDeviceConnected) == 0:
+    for i in 0..<maxGamepads:
+      if gameInputDevices[i] == device:
+        gameInputDevices[i] = nil
+        gamepadResetState(gamepadStates[i])
+        comDispose(device)
+        if onGamepadDisconnected != nil:
+          onGamepadDisconnected(i)
+        break
+  else:
+    for i in 0..<maxGamepads:
+      if gameInputDevices[i] == nil:
+        var info: ptr GameInputDeviceInfo
+        discard device.lpVtbl.GetDeviceInfo(device, addr info)
+        comAddRef(device)
+        gameInputDevices[i] = device
+        gamepadStates[i].name = $info.displayName
+        if onGamepadConnected != nil:
+          onGamepadConnected(i)
+        return
+    echo "No free gamepad slot found"
+
 proc init() {.raises: [].} =
   if initialized:
     return
@@ -1037,6 +1127,22 @@ proc init() {.raises: [].} =
   except:
     quit("Error creating helper window")
   platformDoubleClickInterval = GetDoubleClickTime().float64 / 1000
+
+  # Since GameInput requires a distributable install, we'll disable gamepad support if initializing it fails
+  var gameInputV0: ptr IGameInput
+  var hr = GameInputCreate(addr gameInputV0)
+  if hr != S_OK:
+    echo "Error creating GameInput, please ensure it is installed"
+  else:
+    # The factory method gets us a V0 interface, but we're using the V2 interface
+    if not gameInputV0.comQueryInterface(addr IID_IGameInput, addr gameInput):
+      echo "Error querying GameInput v2, please ensure the latest version is installed"
+    else:
+      comDispose(gameInputV0)
+      discard gameInput.lpVtbl.RegisterDeviceCallback(gameInput,
+        nil, GameInputKindGamepad, GameInputDeviceConnected, GameInputAsyncEnumeration,
+        nil, gameInputDeviceCallback, nil) # Also lists gamepads already connected
+
   initialized = true
 
 proc makeContextCurrent*(window: Window) =
@@ -2313,6 +2419,8 @@ elif compileOption("threads"):
       state.onClose()
 
 proc pollEvents*() =
+  pollGamepads()
+
   # Draw first (in case a message closes a window or similar)
   for window in windows:
     if window.onFrame != nil:
diff --git a/src/windy/platforms/win32/windefs.nim b/src/windy/platforms/win32/windefs.nim
index 14f4a84..2a77ba3 100644
--- a/src/windy/platforms/win32/windefs.nim
+++ b/src/windy/platforms/win32/windefs.nim
@@ -1,3 +1,5 @@
+import macros
+
 when defined(cpu64):
   type
     UINT_PTR* = int64
@@ -16,6 +18,7 @@ type
   BOOL* = int32
   LPBOOL* = ptr BOOL
   LONG* = int32
+  ULONG* = uint32
   USHORT* = uint16
   LANGID* = USHORT
   WORD* = uint16
@@ -154,7 +157,7 @@ type
     rcArea*: RECT
   LPCANDIDATEFORM* = ptr CANDIDATEFORM
   GUID* {.pure.} = object
-    Data1*: int32
+    Data1*: uint32
     Data2*: uint16
     Data3*: uint16
     Data4*: array[8, uint8]
@@ -1084,4 +1087,204 @@ proc WinHttpWebSocketClose*(
   dwReasonLength: DWORD
 ): DWORD {.dynlib: "winhttp".}
 
+{.pragma: com, stdcall, raises: [].}
+{.pragma: enum32, size: sizeof(uint32).}
+
+type
+  # COM
+  IID* = GUID
+  REFIID* = ptr IID
+
+  IUnknown* = object
+    lpVtbl*: ptr IUnknownVtbl
+  IUnknownVtbl* = object
+    QueryInterface*: proc(this: ptr IUnknown, riid: REFIID, ppv: ptr pointer): HRESULT {.com.}
+    AddRef*: proc(this: ptr IUnknown): ULONG {.com.}
+    Release*: proc(this: ptr IUnknown): ULONG {.com.}
+
+  # GameInput
+  GameInputKind* = uint32
+  GameInputEnumerationKind* = uint32
+  GameInputFocusPolicy* = uint32
+  GameInputDeviceStatus* = uint32
+  GameInputSystemButtons* = uint32
+  GameInputDeviceFamily* = uint32
+  GameInputRumbleMotors* = uint32
+  GameInputGamepadButtons* = uint32
+
+  APP_LOCAL_DEVICE_ID* = object
+    id*: array[32, uint8]
+
+  GameInputUsage* = object
+    page*: uint16
+    id*: uint16
+
+  GameInputVersion* = object
+    major*: uint16
+    minor*: uint16
+    build*: uint16
+    revision*: uint16
+
+  GameInputDeviceInfo* = object
+    vendorId*: uint16
+    productId*: uint16
+    revisionNumber*: uint16
+    usage*: GameInputUsage
+    hardwareVersion*: GameInputVersion
+    firmwareVersion*: GameInputVersion
+    deviceId*: APP_LOCAL_DEVICE_ID
+    deviceRootId*: APP_LOCAL_DEVICE_ID
+    deviceFamily*: GameInputDeviceFamily
+    supportedInput*: GameInputKind
+    supportedRumbleMotors*: GameInputRumbleMotors
+    supportedSystemButtons*: GameInputSystemButtons
+    containerId*: GUID
+    displayName*: cstring
+    pnpPath*: cstring
+    keyboardInfo*: ptr pointer # NOTE These have concrete types, but we don't need them
+    mouseInfo*: ptr pointer
+    sensorsInfo*: ptr pointer
+    arcadeStickInfo*: ptr pointer
+    flightStickInfo*: ptr pointer
+    gamepadInfo*: ptr pointer
+    racingWheelInfo*: ptr pointer
+    uiNavigationInfo*: ptr pointer
+    controllerAxisCount*: uint32
+    controllerAxisInfo*: ptr pointer
+    controllerButtonCount*: uint32
+    controllerButtonInfo*: ptr pointer
+    controllerSwitchCount*: uint32
+    controllerSwitchInfo*: ptr pointer
+    forceFeedbackMotorCount*: uint32
+    forceFeedbackMotorInfo*: ptr pointer
+
+  GameInputHapticInfo* = object
+  GameInputForceFeedbackParams* = object
+  GameInputRumbleParams* = object
+  GameInputSwitchPosition* = object
+  GameInputKeyState* = object
+  GameInputMouseState* = object
+  GameInputSensorsState* = object
+  GameInputArcadeStickState* = object
+  GameInputFlightStickState* = object
+  GameInputGamepadState* = object
+    buttons*: GameInputGamepadButtons
+    leftTrigger*: float32
+    rightTrigger*: float32
+    leftThumbstickX*: float32
+    leftThumbstickY*: float32
+    rightThumbstickX*: float32
+    rightThumbstickY*: float32
+  GameInputRacingWheelState* = object
+  GameInputUiNavigationState* = object
+
+  GameInputCallbackToken* = uint64
+  GameInputReadingCallback* = proc(callbackToken: GameInputCallbackToken, context: pointer, reading: ptr IGameInputReading) {.stdcall.}
+  GameInputDeviceCallback* = proc(callbackToken: GameInputCallbackToken, context: pointer, device: ptr IGameInputDevice, timestamp: uint64, currentStatus: GameInputDeviceStatus, previousStatus: GameInputDeviceStatus) {.stdcall.}
+  GameInputSystemButtonCallback* = proc(callbackToken: GameInputCallbackToken, context: pointer, device: ptr IGameInputDevice, timestamp: uint64, currentButtons: GameInputSystemButtons, previousButtons: GameInputSystemButtons) {.stdcall.}
+  GameInputKeyboardLayoutCallback* = proc(callbackToken: GameInputCallbackToken, context: pointer, device: ptr IGameInputDevice, timestamp: uint64, currentLayout: uint32, previousLayout: uint32) {.stdcall.}
+
+  IGameInput* = object
+    lpVtbl*: ptr IGameInputVtbl
+  IGameInputVtbl* = object
+    IUnknown*: IUnknownVtbl
+    GetCurrentTimestamp*: proc(this: ptr IGameInput): uint64 {.com.}
+    GetCurrentReading*: proc(this: ptr IGameInput, inputKind: GameInputKind, device: ptr IGameInputDevice, reading: ptr ptr IGameInputReading): HRESULT {.com.}
+    GetNextReading*: proc(this: ptr IGameInput, referenceReading: ptr IGameInputReading, inputKind: GameInputKind, device: ptr IGameInputDevice, reading: ptr ptr IGameInputReading): HRESULT {.com.}
+    GetPreviousReading*: proc(this: ptr IGameInput, referenceReading: ptr IGameInputReading, inputKind: GameInputKind, device: ptr IGameInputDevice, reading: ptr ptr IGameInputReading): HRESULT {.com.}
+    RegisterReadingCallback*: proc(this: ptr IGameInput, device: ptr IGameInputDevice, inputKind: GameInputKind, context: pointer, callbackFunc: GameInputReadingCallback, callbackToken: ptr GameInputCallbackToken): HRESULT {.com.}
+    RegisterDeviceCallback*: proc(this: ptr IGameInput, device: ptr IGameInputDevice, inputKind: GameInputKind, statusFilter: GameInputDeviceStatus, enumerationKind: GameInputEnumerationKind, context: pointer, callbackFunc: GameInputDeviceCallback, callbackToken: ptr GameInputCallbackToken): HRESULT {.com.}
+    RegisterSystemButtonCallback*: proc(this: ptr IGameInput, device: ptr IGameInputDevice, buttonFilter: GameInputSystemButtons, context: pointer, callbackFunc: GameInputSystemButtonCallback, callbackToken: ptr GameInputCallbackToken): HRESULT {.com.}
+    RegisterKeyboardLayoutCallback*: proc(this: ptr IGameInput, device: ptr IGameInputDevice, context: pointer, callbackFunc: GameInputKeyboardLayoutCallback, callbackToken: ptr GameInputCallbackToken): HRESULT {.com.}
+    StopCallback*: proc(this: ptr IGameInput, callbackToken: GameInputCallbackToken) {.com.}
+    UnregisterCallback*: proc(this: ptr IGameInput, callbackToken: GameInputCallbackToken, timeoutInMicroseconds: uint64): bool {.com.}
+    CreateDispatcher*: proc(this: ptr IGameInput, dispatcher: ptr IGameInputDispatcher): HRESULT {.com.}
+    FindDeviceFromId*: proc(this: ptr IGameInput, value: uint64, device: ptr ptr IGameInputDevice): HRESULT {.com.}
+    FindDeviceFromPlatformString*: proc(this: ptr IGameInput, value: LPCWSTR, device: ptr ptr IGameInputDevice): HRESULT {.com.}
+    SetFocusPolicy*: proc(this: ptr IGameInput, policy: GameInputFocusPolicy) {.com.}
+
+  IGameInputDevice* = object
+    lpVtbl*: ptr IGameInputDeviceVtbl
+  IGameInputDeviceVtbl* = object
+    IUnknown*: IUnknownVtbl
+    GetDeviceInfo*: proc(this: ptr IGameInputDevice, info: ptr ptr GameInputDeviceInfo): HRESULT {.com.}
+    GetHapticInfo*: proc(this: ptr IGameInputDevice, info: ptr GameInputHapticInfo): HRESULT {.com.}
+    GetDeviceStatus*: proc(this: ptr IGameInputDevice): GameInputDeviceStatus {.com.}
+    CreateForceFeedbackEffect*: proc(this: ptr IGameInputDevice, motorIndex: uint32, params: ptr GameInputForceFeedbackParams, effect: ptr ptr IGameInputForceFeedbackEffect): HRESULT {.com.}
+    IsForceFeedbackMotorPoweredOn*: proc(this: ptr IGameInputDevice, motorIndex: uint32): bool {.com.}
+    SetForceFeedbackMotorGain*: proc(this: ptr IGameInputDevice, motorIndex: uint32, masterGain: float32) {.com.}
+    SetRumbleState*: proc(this: ptr IGameInputDevice, params: ptr GameInputRumbleParams) {.com.}
+    DirectInputEscape*: proc(this: ptr IGameInputDevice, command: uint32, buffer: pointer, bufferInSize: uint32, bufferOut: pointer, bufferOutSize: uint32, bufferOutSizeWritten: ptr uint32): HRESULT {.com.}
+
+  IGameInputReading* = object
+    lpVtbl*: ptr IGameInputReadingVtbl
+  IGameInputReadingVtbl* = object
+    IUnknown*: IUnknownVtbl
+    GetInputKind*: proc(this: ptr IGameInputReading): GameInputKind {.com.}
+    GetTimestamp*: proc(this: ptr IGameInputReading): uint64 {.com.}
+    GetDevice*: proc(this: ptr IGameInputReading, device: ptr ptr IGameInputDevice) {.com.}
+    GetControllerAxisCount*: proc(this: ptr IGameInputReading): uint32 {.com.}
+    GetControllerAxisState*: proc(this: ptr IGameInputReading, stateArrayCount: uint32, stateArray: ptr float32): uint32 {.com.}
+    GetControllerButtonCount*: proc(this: ptr IGameInputReading): uint32 {.com.}
+    GetControllerButtonState*: proc(this: ptr IGameInputReading, stateArrayCount: uint32, stateArray: ptr bool): uint32 {.com.}
+    GetControllerSwitchCount*: proc(this: ptr IGameInputReading): uint32 {.com.}
+    GetControllerSwitchState*: proc(this: ptr IGameInputReading, stateArrayCount: uint32, stateArray: ptr GameInputSwitchPosition): uint32 {.com.}
+    GetKeyCount*: proc(this: ptr IGameInputReading): uint32 {.com.}
+    GetKeyState*: proc(this: ptr IGameInputReading, stateArrayCount: uint32, stateArray: ptr GameInputKeyState): uint32 {.com.}
+    GetMouseState*: proc(this: ptr IGameInputReading, state: ptr GameInputMouseState): bool {.com.}
+    GetSensorsState*: proc(this: ptr IGameInputReading, state: ptr GameInputSensorsState): bool {.com.}
+    GetArcadeStickState*: proc(this: ptr IGameInputReading, state: ptr GameInputArcadeStickState): bool {.com.}
+    GetFlightStickState*: proc(this: ptr IGameInputReading, state: ptr GameInputFlightStickState): bool {.com.}
+    GetGamepadState*: proc(this: ptr IGameInputReading, state: ptr GameInputGamepadState): bool {.com.}
+    GetRacingWheelState*: proc(this: ptr IGameInputReading, state: ptr GameInputRacingWheelState): bool {.com.}
+    GetUiNavigationState*: proc(this: ptr IGameInputReading, state: ptr GameInputUiNavigationState): bool {.com.}
+
+  IGameInputForceFeedbackEffect* = object
+  IGameInputDispatcher* = object
+
+const
+  GameInputKindGamepad* = 0x00040000
+  GameInputDeviceConnected* = 0x00000001
+  GameInputAsyncEnumeration* = 1
+
+  GameInputGamepadNone* = 0x00000000
+  GameInputGamepadMenu* = 0x00000001
+  GameInputGamepadView* = 0x00000002
+  GameInputGamepadA* = 0x00000004
+  GameInputGamepadB* = 0x00000008
+  GameInputGamepadX* = 0x00000010
+  GameInputGamepadY* = 0x00000020
+  GameInputGamepadDPadUp* = 0x00000040
+  GameInputGamepadDPadDown* = 0x00000080
+  GameInputGamepadDPadLeft* = 0x00000100
+  GameInputGamepadDPadRight* = 0x00000200
+  GameInputGamepadLeftShoulder* = 0x00000400
+  GameInputGamepadRightShoulder* = 0x00000800
+  GameInputGamepadLeftThumbstick* = 0x00001000
+  GameInputGamepadRightThumbstick* = 0x00002000
+
+  GameInputSystemButtonsGuide* = 0x00000001
+  GameInputSystemButtonsShare* = 0x00000002
+
+  IID_IGameInput* = IID(Data1: 0xbbaa66d2.uint32, Data2: 0x837a, Data3: 0x40f7, Data4: [0xa3, 0x03, 0x91, 0x7d, 0x50, 0x09, 0x55, 0xf4])
+
+proc GameInputCreate*(
+  gameInput: ptr ptr IGameInput
+): HRESULT {.dynlib: "GameInput".}
+
+{.pop.}
+{.push inline.}
+
+proc comQueryInterface*[T, U](p: T, riid: REFIID, ppv: ptr U): bool =
+  let obj = cast[ptr IUnknown](p)
+  obj.lpVtbl.QueryInterface(obj, riid, cast[ptr pointer](ppv)) == S_OK
+
+proc comAddRef*[T](p: T) =
+  let obj = cast[ptr IUnknown](p)
+  discard obj.lpVtbl.AddRef(obj)
+
+proc comDispose*[T](p: T) =
+  let obj = cast[ptr IUnknown](p)
+  discard obj.lpVtbl.Release(obj)
+
 {.pop.}