diff --git a/src/frontend-common/CMakeLists.txt b/src/frontend-common/CMakeLists.txt
index 48a5f6c7d..d4d323aa0 100644
--- a/src/frontend-common/CMakeLists.txt
+++ b/src/frontend-common/CMakeLists.txt
@@ -62,6 +62,8 @@ if(NOT BUILD_LIBRETRO_CORE)
 
   if(WIN32)
     target_sources(frontend-common PRIVATE
+      dinput_controller_interface.cpp
+      dinput_controller_interface.h
       xinput_controller_interface.cpp
       xinput_controller_interface.h
     )
diff --git a/src/frontend-common/controller_interface.cpp b/src/frontend-common/controller_interface.cpp
index c27f093fc..9a0730457 100644
--- a/src/frontend-common/controller_interface.cpp
+++ b/src/frontend-common/controller_interface.cpp
@@ -89,6 +89,7 @@ static constexpr std::array<const char*, static_cast<u32>(ControllerInterface::B
 #endif
 #ifdef WIN32
   TRANSLATABLE("ControllerInterface", "XInput"),
+  TRANSLATABLE("ControllerInterface", "DInput"),
 #endif
 }};
 
@@ -124,6 +125,7 @@ ControllerInterface::Backend ControllerInterface::GetDefaultBackend()
 #include "sdl_controller_interface.h"
 #endif
 #ifdef WIN32
+#include "dinput_controller_interface.h"
 #include "xinput_controller_interface.h"
 #endif
 
@@ -136,6 +138,8 @@ std::unique_ptr<ControllerInterface> ControllerInterface::Create(Backend type)
 #ifdef WIN32
   if (type == Backend::XInput)
     return std::make_unique<XInputControllerInterface>();
+  if (type == Backend::DInput)
+    return std::make_unique<DInputControllerInterface>();
 #endif
 
   return {};
diff --git a/src/frontend-common/controller_interface.h b/src/frontend-common/controller_interface.h
index d40c167e5..5b012b264 100644
--- a/src/frontend-common/controller_interface.h
+++ b/src/frontend-common/controller_interface.h
@@ -22,6 +22,7 @@ public:
 #endif
 #ifdef WIN32
     XInput,
+    DInput,
 #endif
     Count
   };
@@ -29,7 +30,12 @@ public:
   enum : int
   {
     MAX_NUM_AXISES = 7,
-    MAX_NUM_BUTTONS = 15
+    MAX_NUM_BUTTONS = 15,
+    NUM_HAT_DIRECTIONS = 4,
+    HAT_DIRECTION_UP = 0,
+    HAT_DIRECTION_DOWN = 1,
+    HAT_DIRECTION_LEFT = 2,
+    HAT_DIRECTION_RIGHT = 3,
   };
 
   enum AxisSide
diff --git a/src/frontend-common/dinput_controller_interface.cpp b/src/frontend-common/dinput_controller_interface.cpp
new file mode 100644
index 000000000..292f04c13
--- /dev/null
+++ b/src/frontend-common/dinput_controller_interface.cpp
@@ -0,0 +1,448 @@
+#define INITGUID
+
+#include "dinput_controller_interface.h"
+#include "common/assert.h"
+#include "common/file_system.h"
+#include "common/log.h"
+#include "common/string_util.h"
+#include "core/controller.h"
+#include "core/host_interface.h"
+#include "core/system.h"
+#include <cmath>
+#include <limits>
+Log_SetChannel(DInputControllerInterface);
+
+using PFNDIRECTINPUT8CREATE = HRESULT(WINAPI*)(HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPVOID* ppvOut,
+                                               LPUNKNOWN punkOuter);
+using PFNGETDFDIJOYSTICK = LPCDIDATAFORMAT(WINAPI*)();
+
+DInputControllerInterface::DInputControllerInterface() = default;
+
+DInputControllerInterface::~DInputControllerInterface()
+{
+  if (m_dinput_module)
+    FreeLibrary(m_dinput_module);
+}
+
+ControllerInterface::Backend DInputControllerInterface::GetBackend() const
+{
+  return ControllerInterface::Backend::XInput;
+}
+
+bool DInputControllerInterface::Initialize(CommonHostInterface* host_interface)
+{
+  m_dinput_module = LoadLibraryW(L"dinput8");
+  if (!m_dinput_module)
+  {
+    Log_ErrorPrintf("Failed to load DInput module.");
+    return false;
+  }
+
+  PFNDIRECTINPUT8CREATE create =
+    reinterpret_cast<PFNDIRECTINPUT8CREATE>(GetProcAddress(m_dinput_module, "DirectInput8Create"));
+  PFNGETDFDIJOYSTICK get_joystick_data_format =
+    reinterpret_cast<PFNGETDFDIJOYSTICK>(GetProcAddress(m_dinput_module, "GetdfDIJoystick"));
+  if (!create || !get_joystick_data_format)
+  {
+    Log_ErrorPrintf("Failed to get DInput function pointers.");
+    return false;
+  }
+
+  if (!ControllerInterface::Initialize(host_interface))
+    return false;
+
+  HRESULT hr = create(GetModuleHandleA(nullptr), DIRECTINPUT_VERSION, IID_IDirectInput8A,
+                      reinterpret_cast<LPVOID*>(m_dinput.GetAddressOf()), nullptr);
+  m_joystick_data_format = get_joystick_data_format();
+  if (FAILED(hr) || !m_joystick_data_format)
+  {
+    Log_ErrorPrintf("DirectInput8Create() failed: %08X", hr);
+    return false;
+  }
+
+  AddDevices();
+
+  return true;
+}
+
+void DInputControllerInterface::Shutdown()
+{
+  ControllerInterface::Shutdown();
+}
+
+static BOOL CALLBACK EnumCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef)
+{
+  static_cast<std::vector<DIDEVICEINSTANCE>*>(pvRef)->push_back(*lpddi);
+  return DIENUM_CONTINUE;
+}
+
+void DInputControllerInterface::AddDevices()
+{
+  std::vector<DIDEVICEINSTANCE> devices;
+  m_dinput->EnumDevices(DI8DEVCLASS_GAMECTRL, EnumCallback, &devices, DIEDFL_ATTACHEDONLY);
+
+  Log_InfoPrintf("Enumerated %zud evices", devices.size());
+
+  for (DIDEVICEINSTANCE inst : devices)
+  {
+    ControllerData cd;
+    HRESULT hr = m_dinput->CreateDevice(inst.guidInstance, cd.device.GetAddressOf(), nullptr);
+    if (FAILED(hr))
+    {
+      Log_WarningPrintf("Failed to create instance of device [%s, %s]", inst.tszProductName, inst.tszInstanceName);
+      continue;
+    }
+
+    if (AddDevice(cd, inst.tszProductName))
+      m_controllers.push_back(std::move(cd));
+  }
+}
+
+bool DInputControllerInterface::AddDevice(ControllerData& cd, const char* name)
+{
+  HRESULT hr = cd.device->SetCooperativeLevel(static_cast<HWND>(m_host_interface->GetTopLevelWindowHandle()),
+                                              DISCL_BACKGROUND | DISCL_EXCLUSIVE);
+  if (FAILED(hr))
+  {
+    hr = cd.device->SetCooperativeLevel(static_cast<HWND>(m_host_interface->GetTopLevelWindowHandle()),
+                                        DISCL_BACKGROUND | DISCL_NONEXCLUSIVE);
+    if (FAILED(hr))
+    {
+      Log_ErrorPrintf("Failed to set cooperative level for '%s'", name);
+      return false;
+    }
+
+    Log_WarningPrintf("Failed to set exclusive mode for '%s'", name);
+  }
+
+  hr = cd.device->SetDataFormat(m_joystick_data_format);
+  if (FAILED(hr))
+  {
+    Log_ErrorPrintf("Failed to set data format for '%s'", name);
+    return false;
+  }
+
+  hr = cd.device->Acquire();
+  if (FAILED(hr))
+  {
+    Log_ErrorPrintf("Failed to acquire device '%s'", name);
+    return false;
+  }
+
+  DIDEVCAPS caps = {};
+  caps.dwSize = sizeof(caps);
+  hr = cd.device->GetCapabilities(&caps);
+  if (FAILED(hr))
+  {
+    Log_ErrorPrintf("Failed to get capabilities for '%s'", name);
+    return false;
+  }
+
+  cd.num_buttons = caps.dwButtons;
+  if (cd.num_buttons > NUM_BUTTONS)
+  {
+    Log_WarningPrintf("Device '%s' has too many buttons (%u), using %u instead.", name, cd.num_buttons, NUM_BUTTONS);
+    cd.num_buttons = NUM_BUTTONS;
+  }
+
+  static constexpr std::array<u32, NUM_AXISES> axis_offsets = {
+    {offsetof(DIJOYSTATE, lX), offsetof(DIJOYSTATE, lY), offsetof(DIJOYSTATE, lZ), offsetof(DIJOYSTATE, lRz),
+     offsetof(DIJOYSTATE, lRx), offsetof(DIJOYSTATE, lRy), offsetof(DIJOYSTATE, rglSlider[0]),
+     offsetof(DIJOYSTATE, rglSlider[1])}};
+  for (u32 i = 0; i < NUM_AXISES; i++)
+  {
+    // ask for 16 bits of axis range
+    DIPROPRANGE range = {};
+    range.diph.dwSize = sizeof(range);
+    range.diph.dwHeaderSize = sizeof(range.diph);
+    range.diph.dwHow = DIPH_BYOFFSET;
+    range.diph.dwObj = axis_offsets[i];
+    range.lMin = std::numeric_limits<s16>::min();
+    range.lMax = std::numeric_limits<s16>::max();
+    hr = cd.device->SetProperty(DIPROP_RANGE, &range.diph);
+
+    // did it apply?
+    if (SUCCEEDED(cd.device->GetProperty(DIPROP_RANGE, &range.diph)))
+    {
+      cd.axis_offsets[cd.num_axes] = axis_offsets[i];
+      cd.num_axes++;
+    }
+  }
+
+  cd.has_hat = (caps.dwPOVs > 0);
+
+  hr = cd.device->Poll();
+  if (hr == DI_NOEFFECT)
+    cd.needs_poll = false;
+  else if (hr != DI_OK)
+    Log_WarningPrintf("Polling device '%s' failed: %08X", name, hr);
+
+  hr = cd.device->GetDeviceState(sizeof(cd.last_state), &cd.last_state);
+  if (hr != DI_OK)
+    Log_WarningPrintf("GetDeviceState() for '%s' failed: %08X", name, hr);
+
+  Log_InfoPrintf("%s has %u buttons, %u axes%s", name, cd.num_buttons, cd.num_axes, cd.has_hat ? ", and a hat" : "");
+
+  return (cd.num_buttons > 0 || cd.num_axes > 0 || cd.has_hat);
+}
+
+void DInputControllerInterface::PollEvents()
+{
+  for (u32 i = 0; i < static_cast<u32>(m_controllers.size()); i++)
+  {
+    ControllerData& cd = m_controllers[i];
+    if (!cd.device)
+      continue;
+
+    if (cd.needs_poll)
+      cd.device->Poll();
+
+    DIJOYSTATE js;
+    HRESULT hr = cd.device->GetDeviceState(sizeof(js), &js);
+    if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
+    {
+      hr = cd.device->Acquire();
+      if (hr == DI_OK)
+        hr = cd.device->GetDeviceState(sizeof(js), &js);
+
+      if (hr != DI_OK)
+      {
+        cd = {};
+        OnControllerDisconnected(static_cast<int>(i));
+        continue;
+      }
+    }
+    else if (hr != DI_OK)
+    {
+      Log_WarningPrintf("GetDeviceState() failed: %08X", hr);
+      continue;
+    }
+
+    CheckForStateChanges(i, js);
+  }
+}
+
+u32 DInputControllerInterface::GetHatDirection(DWORD hat)
+{
+  const WORD hv = LOWORD(hat);
+  if (hv == 0xFFFF)
+    return NUM_HAT_DIRECTIONS;
+  else if (hv < 9000)
+    return HAT_DIRECTION_UP;
+  else if (hv < 18000)
+    return HAT_DIRECTION_RIGHT;
+  else if (hv < 27000)
+    return HAT_DIRECTION_DOWN;
+  else
+    return HAT_DIRECTION_LEFT;
+}
+
+void DInputControllerInterface::CheckForStateChanges(u32 index, const DIJOYSTATE& new_state)
+{
+  ControllerData& cd = m_controllers[index];
+  DIJOYSTATE& last_state = cd.last_state;
+
+  for (u32 i = 0; i < cd.num_axes; i++)
+  {
+    LONG new_value;
+    LONG old_value;
+    std::memcpy(&old_value, reinterpret_cast<const u8*>(&cd.last_state) + cd.axis_offsets[i], sizeof(old_value));
+    std::memcpy(&new_value, reinterpret_cast<const u8*>(&new_state) + cd.axis_offsets[i], sizeof(new_value));
+    if (old_value != new_value)
+    {
+      HandleAxisEvent(index, i, new_value);
+      std::memcpy(reinterpret_cast<u8*>(&cd.last_state) + cd.axis_offsets[i], &new_value, sizeof(new_value));
+    }
+  }
+
+  for (u32 i = 0; i < cd.num_buttons; i++)
+  {
+    if (last_state.rgbButtons[i] != new_state.rgbButtons[i])
+    {
+      HandleButtonEvent(index, i, new_state.rgbButtons[i] != 0);
+      last_state.rgbButtons[i] = new_state.rgbButtons[i];
+    }
+  }
+
+  if (cd.has_hat)
+  {
+    if (last_state.rgdwPOV[0] != new_state.rgdwPOV[0])
+    {
+      // map hats to the last buttons
+      const u32 old_direction = GetHatDirection(last_state.rgdwPOV[0]);
+      if (old_direction != NUM_HAT_DIRECTIONS)
+        HandleButtonEvent(index, cd.num_buttons + old_direction, false);
+
+      const u32 new_direction = GetHatDirection(new_state.rgdwPOV[0]);
+      if (new_direction != NUM_HAT_DIRECTIONS)
+        HandleButtonEvent(index, cd.num_buttons + new_direction, true);
+      last_state.rgdwPOV[0] = new_state.rgdwPOV[0];
+    }
+  }
+}
+
+void DInputControllerInterface::ClearBindings()
+{
+  for (ControllerData& cd : m_controllers)
+  {
+    cd.axis_mapping.fill({});
+    cd.button_mapping.fill({});
+    cd.axis_button_mapping.fill({});
+    cd.button_axis_mapping.fill({});
+  }
+}
+
+bool DInputControllerInterface::BindControllerAxis(int controller_index, int axis_number, AxisSide axis_side,
+                                                   AxisCallback callback)
+{
+  if (static_cast<u32>(controller_index) >= m_controllers.size())
+    return false;
+
+  if (axis_number < 0 || axis_number >= NUM_AXISES)
+    return false;
+
+  m_controllers[controller_index].axis_mapping[axis_number][axis_side] = std::move(callback);
+  return true;
+}
+
+bool DInputControllerInterface::BindControllerButton(int controller_index, int button_number, ButtonCallback callback)
+{
+  if (static_cast<u32>(controller_index) >= m_controllers.size())
+    return false;
+
+  if (button_number < 0 || button_number >= TOTAL_NUM_BUTTONS)
+    return false;
+
+  m_controllers[controller_index].button_mapping[button_number] = std::move(callback);
+  return true;
+}
+
+bool DInputControllerInterface::BindControllerAxisToButton(int controller_index, int axis_number, bool direction,
+                                                           ButtonCallback callback)
+{
+  if (static_cast<u32>(controller_index) >= m_controllers.size())
+    return false;
+
+  if (axis_number < 0 || axis_number >= NUM_AXISES)
+    return false;
+
+  m_controllers[controller_index].axis_button_mapping[axis_number][BoolToUInt8(direction)] = std::move(callback);
+  return true;
+}
+
+bool DInputControllerInterface::BindControllerHatToButton(int controller_index, int hat_number,
+                                                          std::string_view hat_position, ButtonCallback callback)
+{
+  // Hats don't exist in XInput
+  return false;
+}
+
+bool DInputControllerInterface::BindControllerButtonToAxis(int controller_index, int button_number,
+                                                           AxisCallback callback)
+{
+  if (static_cast<u32>(controller_index) >= m_controllers.size())
+    return false;
+
+  if (button_number < 0 || button_number >= TOTAL_NUM_BUTTONS)
+    return false;
+
+  m_controllers[controller_index].button_axis_mapping[button_number] = std::move(callback);
+  return true;
+}
+
+bool DInputControllerInterface::HandleAxisEvent(u32 index, u32 axis, s32 value)
+{
+  const float f_value = static_cast<float>(value) / (value < 0 ? 32768.0f : 32767.0f);
+  Log_DevPrintf("controller %u axis %u %d %f", index, static_cast<u32>(axis), value, f_value);
+  DebugAssert(index < m_controllers.size());
+
+  if (DoEventHook(Hook::Type::Axis, index, static_cast<u32>(axis), f_value))
+    return true;
+
+  const AxisCallback& cb = m_controllers[index].axis_mapping[static_cast<u32>(axis)][AxisSide::Full];
+  if (cb)
+  {
+    // Extend triggers from a 0 - 1 range to a -1 - 1 range for consistency with other inputs
+    if (axis == 4 || axis == 5)
+    {
+      cb((f_value * 2.0f) - 1.0f);
+    }
+    else
+    {
+      cb(f_value);
+    }
+    return true;
+  }
+
+  // set the other direction to false so large movements don't leave the opposite on
+  const bool outside_deadzone = (std::abs(f_value) >= m_controllers[index].deadzone);
+  const bool positive = (f_value >= 0.0f);
+  const ButtonCallback& other_button_cb =
+    m_controllers[index].axis_button_mapping[static_cast<u32>(axis)][BoolToUInt8(!positive)];
+  const ButtonCallback& button_cb =
+    m_controllers[index].axis_button_mapping[static_cast<u32>(axis)][BoolToUInt8(positive)];
+  if (button_cb)
+  {
+    button_cb(outside_deadzone);
+    if (other_button_cb)
+      other_button_cb(false);
+    return true;
+  }
+  else if (other_button_cb)
+  {
+    other_button_cb(false);
+    return true;
+  }
+  else
+  {
+    return false;
+  }
+}
+
+bool DInputControllerInterface::HandleButtonEvent(u32 index, u32 button, bool pressed)
+{
+  Log_DevPrintf("controller %u button %u %s", index, button, pressed ? "pressed" : "released");
+  DebugAssert(index < m_controllers.size());
+
+  if (DoEventHook(Hook::Type::Button, index, button, pressed ? 1.0f : 0.0f))
+    return true;
+
+  const ButtonCallback& cb = m_controllers[index].button_mapping[button];
+  if (cb)
+  {
+    cb(pressed);
+    return true;
+  }
+
+  const AxisCallback& axis_cb = m_controllers[index].button_axis_mapping[button];
+  if (axis_cb)
+  {
+    axis_cb(pressed ? 1.0f : -1.0f);
+  }
+  return true;
+}
+
+u32 DInputControllerInterface::GetControllerRumbleMotorCount(int controller_index)
+{
+  if (static_cast<u32>(controller_index) >= m_controllers.size())
+    return 0;
+
+  return 0;
+}
+
+void DInputControllerInterface::SetControllerRumbleStrength(int controller_index, const float* strengths,
+                                                            u32 num_motors)
+{
+  DebugAssert(static_cast<u32>(controller_index) < m_controllers.size());
+}
+
+bool DInputControllerInterface::SetControllerDeadzone(int controller_index, float size /* = 0.25f */)
+{
+  if (static_cast<u32>(controller_index) >= m_controllers.size())
+    return false;
+
+  m_controllers[static_cast<u32>(controller_index)].deadzone = std::clamp(std::abs(size), 0.01f, 0.99f);
+  Log_InfoPrintf("Controller %d deadzone size set to %f", controller_index,
+                 m_controllers[static_cast<u32>(controller_index)].deadzone);
+  return true;
+}
diff --git a/src/frontend-common/dinput_controller_interface.h b/src/frontend-common/dinput_controller_interface.h
new file mode 100644
index 000000000..fa8183b39
--- /dev/null
+++ b/src/frontend-common/dinput_controller_interface.h
@@ -0,0 +1,96 @@
+#pragma once
+#define DIRECTINPUT_VERSION 0x0800
+#include "common/windows_headers.h"
+#include "controller_interface.h"
+#include "core/types.h"
+#include <array>
+#include <dinput.h>
+#include <functional>
+#include <mutex>
+#include <vector>
+#include <wrl/client.h>
+
+class DInputControllerInterface final : public ControllerInterface
+{
+public:
+  DInputControllerInterface();
+  ~DInputControllerInterface() override;
+
+  Backend GetBackend() const override;
+  bool Initialize(CommonHostInterface* host_interface) override;
+  void Shutdown() override;
+
+  // Removes all bindings. Call before setting new bindings.
+  void ClearBindings() override;
+
+  // Binding to events. If a binding for this axis/button already exists, returns false.
+  bool BindControllerAxis(int controller_index, int axis_number, AxisSide axis_side, AxisCallback callback) override;
+  bool BindControllerButton(int controller_index, int button_number, ButtonCallback callback) override;
+  bool BindControllerAxisToButton(int controller_index, int axis_number, bool direction,
+                                  ButtonCallback callback) override;
+  bool BindControllerHatToButton(int controller_index, int hat_number, std::string_view hat_position,
+                                 ButtonCallback callback) override;
+  bool BindControllerButtonToAxis(int controller_index, int button_number, AxisCallback callback) override;
+
+  // Changing rumble strength.
+  u32 GetControllerRumbleMotorCount(int controller_index) override;
+  void SetControllerRumbleStrength(int controller_index, const float* strengths, u32 num_motors) override;
+
+  // Set deadzone that will be applied on axis-to-button mappings
+  bool SetControllerDeadzone(int controller_index, float size = 0.25f) override;
+
+  void PollEvents() override;
+
+private:
+  template<typename T>
+  using ComPtr = Microsoft::WRL::ComPtr<T>;
+
+  enum : u32
+  {
+    NUM_AXISES = 8,
+    NUM_BUTTONS = 16,
+    NUM_HATS = 1,
+
+    TOTAL_NUM_BUTTONS = NUM_BUTTONS + (NUM_HATS * NUM_HAT_DIRECTIONS),
+  };
+
+  struct ControllerData
+  {
+    ComPtr<IDirectInputDevice8> device;
+    DIJOYSTATE last_state = {};
+    u32 num_buttons = 0;
+    u32 num_axes = 0;
+
+    float deadzone = 0.25f;
+
+    std::array<u32, NUM_AXISES> axis_offsets;
+
+    std::array<std::array<AxisCallback, 3>, NUM_AXISES> axis_mapping;
+    std::array<ButtonCallback, TOTAL_NUM_BUTTONS + NUM_HAT_DIRECTIONS> button_mapping;
+    std::array<std::array<ButtonCallback, 2>, NUM_AXISES> axis_button_mapping;
+    std::array<AxisCallback, TOTAL_NUM_BUTTONS + NUM_HAT_DIRECTIONS> button_axis_mapping;
+
+    bool has_hat = false;
+    bool needs_poll = true;
+  };
+
+  using ControllerDataArray = std::vector<ControllerData>;
+
+  void AddDevices();
+  bool AddDevice(ControllerData& cd, const char* name);
+
+  static u32 GetHatDirection(DWORD hat);
+
+  void CheckForStateChanges(u32 index, const DIJOYSTATE& new_state);
+
+  bool HandleAxisEvent(u32 index, u32 axis, s32 value);
+  bool HandleButtonEvent(u32 index, u32 button, bool pressed);
+
+  ControllerDataArray m_controllers;
+
+  HMODULE m_dinput_module{};
+  LPCDIDATAFORMAT m_joystick_data_format{};
+  ComPtr<IDirectInput8> m_dinput;
+  std::mutex m_event_intercept_mutex;
+  Hook::Callback m_event_intercept_callback;
+};
diff --git a/src/frontend-common/frontend-common.vcxproj b/src/frontend-common/frontend-common.vcxproj
index c1ca84874..9b5b26760 100644
--- a/src/frontend-common/frontend-common.vcxproj
+++ b/src/frontend-common/frontend-common.vcxproj
@@ -87,6 +87,7 @@
     <ClCompile Include="controller_interface.cpp" />
     <ClCompile Include="cubeb_audio_stream.cpp" />
     <ClCompile Include="d3d11_host_display.cpp" />
+    <ClCompile Include="dinput_controller_interface.cpp" />
     <ClCompile Include="game_list.cpp" />
     <ClCompile Include="game_settings.cpp" />
     <ClCompile Include="icon.cpp" />
@@ -111,6 +112,7 @@
     <ClInclude Include="controller_interface.h" />
     <ClInclude Include="cubeb_audio_stream.h" />
     <ClInclude Include="d3d11_host_display.h" />
+    <ClInclude Include="dinput_controller_interface.h" />
     <ClInclude Include="game_list.h" />
     <ClInclude Include="game_settings.h" />
     <ClInclude Include="icon.h" />
diff --git a/src/frontend-common/frontend-common.vcxproj.filters b/src/frontend-common/frontend-common.vcxproj.filters
index 7a5eeadfa..42615ac11 100644
--- a/src/frontend-common/frontend-common.vcxproj.filters
+++ b/src/frontend-common/frontend-common.vcxproj.filters
@@ -23,6 +23,7 @@
     <ClCompile Include="postprocessing_shadergen.cpp" />
     <ClCompile Include="postprocessing_chain.cpp" />
     <ClCompile Include="cubeb_audio_stream.cpp" />
+    <ClCompile Include="dinput_controller_interface.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="icon.h" />
@@ -47,6 +48,7 @@
     <ClInclude Include="postprocessing_shadergen.h" />
     <ClInclude Include="postprocessing_chain.h" />
     <ClInclude Include="cubeb_audio_stream.h" />
+    <ClInclude Include="dinput_controller_interface.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="font_roboto_regular.inl" />