diff --git a/Source/Core/DolphinNoGUI/MainNoGUI.cpp b/Source/Core/DolphinNoGUI/MainNoGUI.cpp
diff --git a/Source/Core/DolphinNoGUI/Platform.cpp b/Source/Core/DolphinNoGUI/Platform.cpp
@@ -0,0 +1,53 @@
+// Copyright 2018 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "DolphinNoGUI/Platform.h"
+#include "Core/IOS/IOS.h"
+#include "Core/IOS/STM/STM.h"
+#include "Core/State.h"
+
+namespace ProcessorInterface
+{
+void PowerButton_Tap();
+}
+
+Platform::~Platform() = default;
+
+bool Platform::Init()
+{
+  return true;
+}
+
+void Platform::SetTitle(const std::string& title)
+{
+}
+
+void Platform::UpdateRunningFlag()
+{
+  if (m_shutdown_requested.TestAndClear())
+  {
+    const auto ios = IOS::HLE::GetIOS();
+    const auto stm = ios ? ios->GetDeviceByName("/dev/stm/eventhook") : nullptr;
+    if (!m_tried_graceful_shutdown.IsSet() && stm &&
+        std::static_pointer_cast<IOS::HLE::Device::STMEventHook>(stm)->HasHookInstalled())
+    {
+      ProcessorInterface::PowerButton_Tap();
+      m_tried_graceful_shutdown.Set();
+    }
+    else
+    {
+      m_running.Clear();
+    }
+  }
+}
+
+void Platform::Stop()
+{
+  m_running.Clear();
+}
+
+void Platform::RequestShutdown()
+{
+  m_shutdown_requested.Set();
+}
diff --git a/Source/Core/DolphinNoGUI/Platform.h b/Source/Core/DolphinNoGUI/Platform.h
@@ -0,0 +1,48 @@
+// Copyright 2018 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "Common/Flag.h"
+#include "Common/WindowSystemInfo.h"
+
+class Platform
+{
+public:
+  virtual ~Platform();
+
+  bool IsRunning() const { return m_running.IsSet(); }
+  bool IsWindowFocused() const { return m_window_focus; }
+  bool IsWindowFullscreen() const { return m_window_fullscreen; }
+
+  virtual bool Init();
+  virtual void SetTitle(const std::string& title);
+  virtual void MainLoop() = 0;
+
+  virtual WindowSystemInfo GetWindowSystemInfo() const = 0;
+
+  // Requests a graceful shutdown, from SIGINT/SIGTERM.
+  void RequestShutdown();
+
+  // Request an immediate shutdown.
+  void Stop();
+
+  static std::unique_ptr<Platform> CreateHeadlessPlatform();
+#ifdef HAVE_X11
+  static std::unique_ptr<Platform> CreateX11Platform();
+#endif
+
+protected:
+  void UpdateRunningFlag();
+
+  Common::Flag m_running{true};
+  Common::Flag m_shutdown_requested{false};
+  Common::Flag m_tried_graceful_shutdown{false};
+
+  bool m_window_focus = true;
+  bool m_window_fullscreen = false;
+};
diff --git a/Source/Core/DolphinNoGUI/PlatformHeadless.cpp b/Source/Core/DolphinNoGUI/PlatformHeadless.cpp
@@ -0,0 +1,50 @@
+// Copyright 2018 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <cstdio>
+#include <thread>
+#include "Core/Core.h"
+#include "DolphinNoGUI/Platform.h"
+
+namespace
+{
+class PlatformHeadless : public Platform
+{
+public:
+  void SetTitle(const std::string& title) override;
+  void MainLoop() override;
+
+  WindowSystemInfo GetWindowSystemInfo() const override;
+};
+
+void PlatformHeadless::SetTitle(const std::string& title)
+{
+  std::fprintf(stdout, "%s\n", title.c_str());
+}
+
+void PlatformHeadless::MainLoop()
+{
+  while (m_running.IsSet())
+  {
+    UpdateRunningFlag();
+    Core::HostDispatchJobs();
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+}
+
+WindowSystemInfo PlatformHeadless::GetWindowSystemInfo() const
+{
+  WindowSystemInfo wsi;
+  wsi.type = WindowSystemType::Headless;
+  wsi.display_connection = nullptr;
+  wsi.render_surface = nullptr;
+  return wsi;
+}
+
+}  // namespace
+
+std::unique_ptr<Platform> Platform::CreateHeadlessPlatform()
+{
+  return std::make_unique<PlatformHeadless>();
+}
diff --git a/Source/Core/DolphinNoGUI/PlatformX11.cpp b/Source/Core/DolphinNoGUI/PlatformX11.cpp
@@ -0,0 +1,270 @@
+// Copyright 2018 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <unistd.h>
+
+#include "DolphinNoGUI/Platform.h"
+
+#include "Common/MsgHandler.h"
+#include "Core/ConfigManager.h"
+#include "Core/Core.h"
+#include "Core/State.h"
+
+#include <climits>
+#include <cstdio>
+
+#include <X11/Xatom.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#include "UICommon/X11Utils.h"
+#include "VideoCommon/RenderBase.h"
+
+#ifndef HOST_NAME_MAX
+#define HOST_NAME_MAX _POSIX_HOST_NAME_MAX
+#endif
+
+namespace
+{
+class PlatformX11 : public Platform
+{
+public:
+  ~PlatformX11() override;
+
+  bool Init() override;
+  void SetTitle(const std::string& string) override;
+  void MainLoop() override;
+
+  WindowSystemInfo GetWindowSystemInfo() const;
+
+private:
+  void CloseDisplay();
+  void UpdateWindowPosition();
+  void ProcessEvents();
+
+  Display* m_display = nullptr;
+  Window m_window = {};
+  Cursor m_blank_cursor = None;
+#if defined(HAVE_XRANDR) && HAVE_XRANDR
+  X11Utils::XRRConfiguration* m_xrr_config = nullptr;
+#endif
+};
+
+PlatformX11::~PlatformX11()
+{
+#if defined(HAVE_XRANDR) && HAVE_XRANDR
+  delete m_xrr_config;
+#endif
+
+  if (m_display)
+  {
+    if (SConfig::GetInstance().bHideCursor)
+      XFreeCursor(m_display, m_blank_cursor);
+
+    XCloseDisplay(m_display);
+  }
+}
+
+bool PlatformX11::Init()
+{
+  XInitThreads();
+  m_display = XOpenDisplay(nullptr);
+  if (!m_display)
+  {
+    PanicAlert("No X11 display found");
+    return false;
+  }
+
+  m_window = XCreateSimpleWindow(
+      m_display, DefaultRootWindow(m_display), SConfig::GetInstance().iRenderWindowXPos,
+      SConfig::GetInstance().iRenderWindowYPos, SConfig::GetInstance().iRenderWindowWidth,
+      SConfig::GetInstance().iRenderWindowHeight, 0, 0, BlackPixel(m_display, 0));
+  XSelectInput(m_display, m_window, StructureNotifyMask | KeyPressMask | FocusChangeMask);
+  Atom wmProtocols[1];
+  wmProtocols[0] = XInternAtom(m_display, "WM_DELETE_WINDOW", True);
+  XSetWMProtocols(m_display, m_window, wmProtocols, 1);
+  pid_t pid = getpid();
+  XChangeProperty(m_display, m_window, XInternAtom(m_display, "_NET_WM_PID", False), XA_CARDINAL,
+                  32, PropModeReplace, reinterpret_cast<unsigned char*>(&pid), 1);
+  char host_name[HOST_NAME_MAX] = "";
+  if (!gethostname(host_name, sizeof(host_name)))
+  {
+    XTextProperty wmClientMachine = {reinterpret_cast<unsigned char*>(host_name), XA_STRING, 8,
+                                     strlen(host_name)};
+    XSetWMClientMachine(m_display, m_window, &wmClientMachine);
+  }
+  XMapRaised(m_display, m_window);
+  XFlush(m_display);
+  XSync(m_display, True);
+  ProcessEvents();
+
+  if (SConfig::GetInstance().bDisableScreenSaver)
+    X11Utils::InhibitScreensaver(m_window, true);
+
+#if defined(HAVE_XRANDR) && HAVE_XRANDR
+  m_xrr_config = new X11Utils::XRRConfiguration(m_display, m_window);
+#endif
+
+  if (SConfig::GetInstance().bHideCursor)
+  {
+    // make a blank cursor
+    Pixmap Blank;
+    XColor DummyColor;
+    char ZeroData[1] = {0};
+    Blank = XCreateBitmapFromData(m_display, m_window, ZeroData, 1, 1);
+    m_blank_cursor = XCreatePixmapCursor(m_display, Blank, Blank, &DummyColor, &DummyColor, 0, 0);
+    XFreePixmap(m_display, Blank);
+    XDefineCursor(m_display, m_window, m_blank_cursor);
+  }
+
+  // Enter fullscreen if enabled.
+  if (SConfig::GetInstance().bFullscreen)
+  {
+    m_window_fullscreen = X11Utils::ToggleFullscreen(m_display, m_window);
+#if defined(HAVE_XRANDR) && HAVE_XRANDR
+    m_xrr_config->ToggleDisplayMode(True);
+#endif
+    ProcessEvents();
+  }
+
+  UpdateWindowPosition();
+  return true;
+}
+
+void PlatformX11::SetTitle(const std::string& string)
+{
+  XStoreName(m_display, m_window, string.c_str());
+}
+
+void PlatformX11::MainLoop()
+{
+  while (IsRunning())
+  {
+    UpdateRunningFlag();
+    Core::HostDispatchJobs();
+    ProcessEvents();
+    UpdateWindowPosition();
+
+    // TODO: Is this sleep appropriate?
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  }
+}
+
+WindowSystemInfo PlatformX11::GetWindowSystemInfo() const
+{
+  WindowSystemInfo wsi;
+  wsi.type = WindowSystemType::X11;
+  wsi.display_connection = static_cast<void*>(m_display);
+  wsi.render_surface = reinterpret_cast<void*>(m_window);
+  return wsi;
+}
+
+void PlatformX11::UpdateWindowPosition()
+{
+  if (m_window_fullscreen)
+    return;
+
+  Window winDummy;
+  unsigned int borderDummy, depthDummy;
+  XGetGeometry(m_display, m_window, &winDummy, &SConfig::GetInstance().iRenderWindowXPos,
+               &SConfig::GetInstance().iRenderWindowYPos,
+               reinterpret_cast<unsigned int*>(&SConfig::GetInstance().iRenderWindowWidth),
+               reinterpret_cast<unsigned int*>(&SConfig::GetInstance().iRenderWindowHeight),
+               &borderDummy, &depthDummy);
+}
+
+void PlatformX11::ProcessEvents()
+{
+  XEvent event;
+  KeySym key;
+  for (int num_events = XPending(m_display); num_events > 0; num_events--)
+  {
+    XNextEvent(m_display, &event);
+    switch (event.type)
+    {
+    case KeyPress:
+      key = XLookupKeysym((XKeyEvent*)&event, 0);
+      if (key == XK_Escape)
+      {
+        RequestShutdown();
+      }
+      else if (key == XK_F10)
+      {
+        if (Core::GetState() == Core::State::Running)
+        {
+          if (SConfig::GetInstance().bHideCursor)
+            XUndefineCursor(m_display, m_window);
+          Core::SetState(Core::State::Paused);
+        }
+        else
+        {
+          if (SConfig::GetInstance().bHideCursor)
+            XDefineCursor(m_display, m_window, m_blank_cursor);
+          Core::SetState(Core::State::Running);
+        }
+      }
+      else if ((key == XK_Return) && (event.xkey.state & Mod1Mask))
+      {
+        m_window_fullscreen = !m_window_fullscreen;
+        X11Utils::ToggleFullscreen(m_display, m_window);
+#if defined(HAVE_XRANDR) && HAVE_XRANDR
+        m_xrr_config->ToggleDisplayMode(m_window_fullscreen);
+#endif
+        UpdateWindowPosition();
+      }
+      else if (key >= XK_F1 && key <= XK_F8)
+      {
+        int slot_number = key - XK_F1 + 1;
+        if (event.xkey.state & ShiftMask)
+          State::Save(slot_number);
+        else
+          State::Load(slot_number);
+      }
+      else if (key == XK_F9)
+        Core::SaveScreenShot();
+      else if (key == XK_F11)
+        State::LoadLastSaved();
+      else if (key == XK_F12)
+      {
+        if (event.xkey.state & ShiftMask)
+          State::UndoLoadState();
+        else
+          State::UndoSaveState();
+      }
+      break;
+    case FocusIn:
+    {
+      m_window_focus = true;
+      if (SConfig::GetInstance().bHideCursor && Core::GetState() != Core::State::Paused)
+        XDefineCursor(m_display, m_window, m_blank_cursor);
+    }
+    break;
+    case FocusOut:
+    {
+      m_window_focus = false;
+      if (SConfig::GetInstance().bHideCursor)
+        XUndefineCursor(m_display, m_window);
+    }
+    break;
+    case ClientMessage:
+    {
+      if ((unsigned long)event.xclient.data.l[0] ==
+          XInternAtom(m_display, "WM_DELETE_WINDOW", False))
+        Stop();
+    }
+    break;
+    case ConfigureNotify:
+    {
+      if (g_renderer)
+        g_renderer->ResizeSurface();
+    }
+    break;
+    }
+  }
+}
+}  // namespace
+
+std::unique_ptr<Platform> Platform::CreateX11Platform()
+{
+  return std::make_unique<PlatformX11>();
+}
diff --git a/Source/Core/VideoBackends/Vulkan/SwapChain.cpp b/Source/Core/VideoBackends/Vulkan/SwapChain.cpp
@@ -18,16 +18,12 @@
 
 #if defined(VK_USE_PLATFORM_XLIB_KHR)
 #include <X11/Xlib.h>
-#elif defined(VK_USE_PLATFORM_XCB_KHR)
-#include <X11/Xlib-xcb.h>
-#include <X11/Xlib.h>
 #endif
 
 namespace Vulkan
 {
-SwapChain::SwapChain(void* display_handle, void* native_handle, VkSurfaceKHR surface, bool vsync)
-    : m_display_handle(display_handle), m_native_handle(native_handle), m_surface(surface),
-      m_vsync_enabled(vsync)
+SwapChain::SwapChain(const WindowSystemInfo& wsi, VkSurfaceKHR surface, bool vsync)
+    : m_wsi(wsi), m_surface(surface), m_vsync_enabled(vsync)
 {
 }
 
@@ -39,110 +35,101 @@ SwapChain::~SwapChain()
   DestroySemaphores();
 }
 
-VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, void* display_handle, void* hwnd)
+VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, const WindowSystemInfo& wsi)
 {
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-  VkWin32SurfaceCreateInfoKHR surface_create_info = {
-      VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,  // VkStructureType               sType
-      nullptr,                                          // const void*                   pNext
-      0,                                                // VkWin32SurfaceCreateFlagsKHR  flags
-      nullptr,                                          // HINSTANCE                     hinstance
-      reinterpret_cast<HWND>(hwnd)                      // HWND                          hwnd
-  };
-
-  VkSurfaceKHR surface;
-  VkResult res = vkCreateWin32SurfaceKHR(instance, &surface_create_info, nullptr, &surface);
-  if (res != VK_SUCCESS)
+  if (wsi.type == WindowSystemType::Windows)
   {
-    LOG_VULKAN_ERROR(res, "vkCreateWin32SurfaceKHR failed: ");
-    return VK_NULL_HANDLE;
-  }
-
-  return surface;
-
-#elif defined(VK_USE_PLATFORM_XLIB_KHR)
-  VkXlibSurfaceCreateInfoKHR surface_create_info = {
-      VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,  // VkStructureType               sType
-      nullptr,                                         // const void*                   pNext
-      0,                                               // VkXlibSurfaceCreateFlagsKHR   flags
-      static_cast<Display*>(display_handle),           // Display*                      dpy
-      reinterpret_cast<Window>(hwnd)                   // Window                        window
-  };
+    VkWin32SurfaceCreateInfoKHR surface_create_info = {
+        VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,  // VkStructureType               sType
+        nullptr,                                          // const void*                   pNext
+        0,                                                // VkWin32SurfaceCreateFlagsKHR  flags
+        nullptr,                                          // HINSTANCE                     hinstance
+        reinterpret_cast<HWND>(wsi.render_surface)        // HWND                          hwnd
+    };
+
+    VkSurfaceKHR surface;
+    VkResult res = vkCreateWin32SurfaceKHR(instance, &surface_create_info, nullptr, &surface);
+    if (res != VK_SUCCESS)
+    {
+      LOG_VULKAN_ERROR(res, "vkCreateWin32SurfaceKHR failed: ");
+      return VK_NULL_HANDLE;
+    }
 
-  VkSurfaceKHR surface;
-  VkResult res = vkCreateXlibSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
-  if (res != VK_SUCCESS)
-  {
-    LOG_VULKAN_ERROR(res, "vkCreateXlibSurfaceKHR failed: ");
-    return VK_NULL_HANDLE;
+    return surface;
   }
+#endif
 
-  return surface;
-
-#elif defined(VK_USE_PLATFORM_XCB_KHR)
-  // If we ever switch to using xcb, we should pass the display handle as well.
-  xcb_connection_t* connection = XGetXCBConnection(display_handle);
-
-  VkXcbSurfaceCreateInfoKHR surface_create_info = {
-      VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,  // VkStructureType               sType
-      nullptr,                                        // const void*                   pNext
-      0,                                              // VkXcbSurfaceCreateFlagsKHR    flags
-      connection,                                     // xcb_connection_t*             connection
-      static_cast<xcb_window_t>(reinterpret_cast<uintptr_t>(hwnd))  // xcb_window_t window
-  };
-
-  VkSurfaceKHR surface;
-  VkResult res = vkCreateXcbSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
-  if (res != VK_SUCCESS)
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+  if (wsi.type == WindowSystemType::X11)
   {
-    LOG_VULKAN_ERROR(res, "vkCreateXcbSurfaceKHR failed: ");
-    return VK_NULL_HANDLE;
-  }
-
-  return surface;
+    VkXlibSurfaceCreateInfoKHR surface_create_info = {
+        VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,  // VkStructureType               sType
+        nullptr,                                         // const void*                   pNext
+        0,                                               // VkXlibSurfaceCreateFlagsKHR   flags
+        static_cast<Display*>(wsi.display_connection),   // Display*                      dpy
+        reinterpret_cast<Window>(wsi.render_surface)     // Window                        window
+    };
+
+    VkSurfaceKHR surface;
+    VkResult res = vkCreateXlibSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
+    if (res != VK_SUCCESS)
+    {
+      LOG_VULKAN_ERROR(res, "vkCreateXlibSurfaceKHR failed: ");
+      return VK_NULL_HANDLE;
+    }
 
-#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
-  VkAndroidSurfaceCreateInfoKHR surface_create_info = {
-      VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,  // VkStructureType                sType
-      nullptr,                                            // const void*                    pNext
-      0,                                                  // VkAndroidSurfaceCreateFlagsKHR flags
-      reinterpret_cast<ANativeWindow*>(hwnd)              // ANativeWindow*                 window
-  };
+    return surface;
+  }
+#endif
 
-  VkSurfaceKHR surface;
-  VkResult res = vkCreateAndroidSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
-  if (res != VK_SUCCESS)
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+  if (wsi.type == WindowSystemType::Android)
   {
-    LOG_VULKAN_ERROR(res, "vkCreateAndroidSurfaceKHR failed: ");
-    return VK_NULL_HANDLE;
+    VkAndroidSurfaceCreateInfoKHR surface_create_info = {
+        VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,  // VkStructureType                sType
+        nullptr,                                            // const void*                    pNext
+        0,                                                  // VkAndroidSurfaceCreateFlagsKHR flags
+        reinterpret_cast<ANativeWindow*>(wsi.render_surface)  // ANativeWindow* window
+    };
+
+    VkSurfaceKHR surface;
+    VkResult res = vkCreateAndroidSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
+    if (res != VK_SUCCESS)
+    {
+      LOG_VULKAN_ERROR(res, "vkCreateAndroidSurfaceKHR failed: ");
+      return VK_NULL_HANDLE;
+    }
+
+    return surface;
   }
+#endif
 
-  return surface;
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+  if (wsi.type == WindowSystemType::MacOS)
+  {
+    VkMacOSSurfaceCreateInfoMVK surface_create_info = {
+        VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, nullptr, 0, wsi.render_surface};
 
-#elif defined(VK_USE_PLATFORM_MACOS_MVK)
-  VkMacOSSurfaceCreateInfoMVK surface_create_info = {
-      VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, nullptr, 0, hwnd};
+    VkSurfaceKHR surface;
+    VkResult res = vkCreateMacOSSurfaceMVK(instance, &surface_create_info, nullptr, &surface);
+    if (res != VK_SUCCESS)
+    {
+      LOG_VULKAN_ERROR(res, "vkCreateMacOSSurfaceMVK failed: ");
+      return VK_NULL_HANDLE;
+    }
 
-  VkSurfaceKHR surface;
-  VkResult res = vkCreateMacOSSurfaceMVK(instance, &surface_create_info, nullptr, &surface);
-  if (res != VK_SUCCESS)
-  {
-    LOG_VULKAN_ERROR(res, "vkCreateMacOSSurfaceMVK failed: ");
-    return VK_NULL_HANDLE;
+    return surface;
   }
+#endif
 
-  return surface;
-#else
   return VK_NULL_HANDLE;
-#endif
 }
 
-std::unique_ptr<SwapChain> SwapChain::Create(void* display_handle, void* native_handle,
-                                             VkSurfaceKHR surface, bool vsync)
+std::unique_ptr<SwapChain> SwapChain::Create(const WindowSystemInfo& wsi, VkSurfaceKHR surface,
+                                             bool vsync)
 {
-  std::unique_ptr<SwapChain> swap_chain =
-      std::make_unique<SwapChain>(display_handle, native_handle, surface, vsync);
-
+  std::unique_ptr<SwapChain> swap_chain = std::make_unique<SwapChain>(wsi, surface, vsync);
   if (!swap_chain->CreateSemaphores() || !swap_chain->CreateSwapChain() ||
       !swap_chain->SetupSwapChainImages())
   {
@@ -531,9 +518,8 @@ bool SwapChain::RecreateSurface(void* native_handle)
   DestroySurface();
 
   // Re-create the surface with the new native handle
-  m_native_handle = native_handle;
-  m_surface =
-      CreateVulkanSurface(g_vulkan_context->GetVulkanInstance(), m_display_handle, native_handle);
+  m_wsi.render_surface = native_handle;
+  m_surface = CreateVulkanSurface(g_vulkan_context->GetVulkanInstance(), m_wsi);
   if (m_surface == VK_NULL_HANDLE)
     return false;
 

diff --git a/Source/Core/VideoBackends/Vulkan/SwapChain.h b/Source/Core/VideoBackends/Vulkan/SwapChain.h
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "Common/CommonTypes.h"
+#include "Common/WindowSystemInfo.h"
 #include "VideoBackends/Vulkan/Constants.h"
 #include "VideoBackends/Vulkan/Texture2D.h"
 #include "VideoCommon/TextureConfig.h"
@@ -20,18 +21,16 @@ class ObjectCache;
 class SwapChain
 {
 public:
-  SwapChain(void* display_handle, void* native_handle, VkSurfaceKHR surface, bool vsync);
+  SwapChain(const WindowSystemInfo& wsi, VkSurfaceKHR surface, bool vsync);
   ~SwapChain();
 
   // Creates a vulkan-renderable surface for the specified window handle.
-  static VkSurfaceKHR CreateVulkanSurface(VkInstance instance, void* display_handle, void* hwnd);
+  static VkSurfaceKHR CreateVulkanSurface(VkInstance instance, const WindowSystemInfo& wsi);
 
   // Create a new swap chain from a pre-existing surface.
-  static std::unique_ptr<SwapChain> Create(void* display_handle, void* native_handle,
-                                           VkSurfaceKHR surface, bool vsync);
+  static std::unique_ptr<SwapChain> Create(const WindowSystemInfo& wsi, VkSurfaceKHR surface,
+                                           bool vsync);
 
-  void* GetDisplayHandle() const { return m_display_handle; }
-  void* GetNativeHandle() const { return m_native_handle; }
   VkSurfaceKHR GetSurface() const { return m_surface; }
   VkSurfaceFormatKHR GetSurfaceFormat() const { return m_surface_format; }
   AbstractTextureFormat GetTextureFormat() const { return m_texture_format; }
@@ -89,8 +88,7 @@ class SwapChain
     VkFramebuffer framebuffer;
   };
 
-  void* m_display_handle;
-  void* m_native_handle;
+  WindowSystemInfo m_wsi;
   VkSurfaceKHR m_surface = VK_NULL_HANDLE;
   VkSurfaceFormatKHR m_surface_format = {};
   VkPresentModeKHR m_present_mode = VK_PRESENT_MODE_RANGE_SIZE_KHR;

diff --git a/Source/Core/VideoBackends/Vulkan/VulkanContext.cpp b/Source/Core/VideoBackends/Vulkan/VulkanContext.cpp
@@ -84,11 +84,11 @@ bool VulkanContext::CheckValidationLayerAvailablility()
           }) != layer_list.end());
 }
 
-VkInstance VulkanContext::CreateVulkanInstance(bool enable_surface, bool enable_debug_report,
+VkInstance VulkanContext::CreateVulkanInstance(WindowSystemType wstype, bool enable_debug_report,
                                                bool enable_validation_layer)
 {
   ExtensionList enabled_extensions;
-  if (!SelectInstanceExtensions(&enabled_extensions, enable_surface, enable_debug_report))
+  if (!SelectInstanceExtensions(&enabled_extensions, wstype, enable_debug_report))
     return VK_NULL_HANDLE;
 
   VkApplicationInfo app_info = {};
@@ -129,7 +129,7 @@ VkInstance VulkanContext::CreateVulkanInstance(bool enable_surface, bool enable_
   return instance;
 }
 
-bool VulkanContext::SelectInstanceExtensions(ExtensionList* extension_list, bool enable_surface,
+bool VulkanContext::SelectInstanceExtensions(ExtensionList* extension_list, WindowSystemType wstype,
                                              bool enable_debug_report)
 {
   u32 extension_count = 0;
@@ -172,24 +172,39 @@ bool VulkanContext::SelectInstanceExtensions(ExtensionList* extension_list, bool
   };
 
   // Common extensions
-  if (enable_surface && !SupportsExtension(VK_KHR_SURFACE_EXTENSION_NAME, true))
+  if (wstype != WindowSystemType::Headless &&
+      !SupportsExtension(VK_KHR_SURFACE_EXTENSION_NAME, true))
+  {
     return false;
+  }
 
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-  if (enable_surface && !SupportsExtension(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, true))
-    return false;
-#elif defined(VK_USE_PLATFORM_XLIB_KHR)
-  if (enable_surface && !SupportsExtension(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, true))
+  if (wstype == WindowSystemType::Windows &&
+      !SupportsExtension(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, true))
+  {
     return false;
-#elif defined(VK_USE_PLATFORM_XCB_KHR)
-  if (enable_surface && !SupportsExtension(VK_KHR_XCB_SURFACE_EXTENSION_NAME, true))
+  }
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+  if (wstype == WindowSystemType::X11 &&
+      !SupportsExtension(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, true))
+  {
     return false;
-#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
-  if (enable_surface && !SupportsExtension(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, true))
+  }
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+  if (wstype == WindowSystemType::Android &&
+      !SupportsExtension(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, true))
+  {
     return false;
-#elif defined(VK_USE_PLATFORM_MACOS_MVK)
-  if (enable_surface && !SupportsExtension(VK_MVK_MACOS_SURFACE_EXTENSION_NAME, true))
+  }
+#endif
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+  if (wstype == WindowSystemType::MacOS &&
+      !SupportsExtension(VK_MVK_MACOS_SURFACE_EXTENSION_NAME, true))
+  {
     return false;
+  }
 #endif
 
   // VK_EXT_debug_report

diff --git a/Source/Core/VideoBackends/Vulkan/VulkanContext.h b/Source/Core/VideoBackends/Vulkan/VulkanContext.h
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "Common/CommonTypes.h"
+#include "Common/WindowSystemInfo.h"
 #include "VideoBackends/Vulkan/Constants.h"
 #include "VideoCommon/VideoConfig.h"
 
@@ -23,7 +24,7 @@ class VulkanContext
   static bool CheckValidationLayerAvailablility();
 
   // Helper method to create a Vulkan instance.
-  static VkInstance CreateVulkanInstance(bool enable_surface, bool enable_debug_report,
+  static VkInstance CreateVulkanInstance(WindowSystemType wstype, bool enable_debug_report,
                                          bool enable_validation_layer);
 
   // Returns a list of Vulkan-compatible GPUs.
@@ -109,7 +110,7 @@ class VulkanContext
 
 private:
   using ExtensionList = std::vector<const char*>;
-  static bool SelectInstanceExtensions(ExtensionList* extension_list, bool enable_surface,
+  static bool SelectInstanceExtensions(ExtensionList* extension_list, WindowSystemType wstype,
                                        bool enable_debug_report);
   bool SelectDeviceExtensions(ExtensionList* extension_list, bool enable_surface);
   bool SelectDeviceFeatures();

diff --git a/Source/Core/VideoBackends/Vulkan/VulkanEntryPoints.inl b/Source/Core/VideoBackends/Vulkan/VulkanEntryPoints.inl
@@ -39,28 +39,21 @@ VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceSurfaceFormatsKHR, false)
 VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceSurfacePresentModesKHR, false)
 
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-
 VULKAN_INSTANCE_ENTRY_POINT(vkCreateWin32SurfaceKHR, false)
 VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceWin32PresentationSupportKHR, false)
+#endif
 
-#elif defined(VK_USE_PLATFORM_XLIB_KHR)
-
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
 VULKAN_INSTANCE_ENTRY_POINT(vkCreateXlibSurfaceKHR, false)
 VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceXlibPresentationSupportKHR, false)
+#endif
 
-#elif defined(VK_USE_PLATFORM_XCB_KHR)
-
-VULKAN_INSTANCE_ENTRY_POINT(vkCreateXcbSurfaceKHR, false)
-VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceXcbPresentationSupportKHR, false)
-
-#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
-
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
 VULKAN_INSTANCE_ENTRY_POINT(vkCreateAndroidSurfaceKHR, false)
+#endif
 
-#elif defined(VK_USE_PLATFORM_MACOS_MVK)
-
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
 VULKAN_INSTANCE_ENTRY_POINT(vkCreateMacOSSurfaceMVK, false)
-
 #endif
 
 VULKAN_INSTANCE_ENTRY_POINT(vkCreateDebugReportCallbackEXT, false)

diff --git a/Source/Core/VideoBackends/Vulkan/VulkanLoader.cpp b/Source/Core/VideoBackends/Vulkan/VulkanLoader.cpp
@@ -13,11 +13,9 @@
 
 #include "VideoBackends/Vulkan/VulkanLoader.h"
 
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
+#if defined(_WIN32)
 #include <Windows.h>
-#elif defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_XCB_KHR) ||                     \
-    defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(VK_USE_PLATFORM_MACOS_MVK) ||                  \
-    defined(USE_HEADLESS)
+#else
 #include <dlfcn.h>
 #endif
 
@@ -42,7 +40,7 @@ static void ResetVulkanLibraryFunctionPointers()
 #undef VULKAN_MODULE_ENTRY_POINT
 }
 
-#if defined(VK_USE_PLATFORM_WIN32_KHR)
+#if defined(_WIN32)
 
 static HMODULE vulkan_module;
 static std::atomic_int vulkan_module_ref_count = {0};
@@ -100,9 +98,7 @@ void UnloadVulkanLibrary()
   vulkan_module = nullptr;
 }
 
-#elif defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_XCB_KHR) ||                     \
-    defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(VK_USE_PLATFORM_MACOS_MVK) ||                  \
-    defined(USE_HEADLESS)
+#else
 
 static void* vulkan_module;
 static std::atomic_int vulkan_module_ref_count = {0};
@@ -181,20 +177,6 @@ void UnloadVulkanLibrary()
   vulkan_module = nullptr;
 }
 
-#else
-
-//#warning Unknown platform, not compiling loader.
-
-bool LoadVulkanLibrary()
-{
-  return false;
-}
-
-void UnloadVulkanLibrary()
-{
-  ResetVulkanLibraryFunctionPointers();
-}
-
 #endif
 
 bool LoadVulkanInstanceFunctions(VkInstance instance)

diff --git a/Source/Core/VideoBackends/Vulkan/VulkanLoader.h b/Source/Core/VideoBackends/Vulkan/VulkanLoader.h
@@ -8,17 +8,18 @@
 
 #if defined(WIN32)
 #define VK_USE_PLATFORM_WIN32_KHR
-#elif defined(HAVE_X11)
-// Currently we're getting xlib handles passed to the backend.
-// If this ever changes to xcb, it's a simple change here.
+#endif
+
+#if defined(HAVE_X11)
 #define VK_USE_PLATFORM_XLIB_KHR
-//#define VK_USE_PLATFORM_XCB_KHR
-#elif defined(ANDROID)
+#endif
+
+#if defined(ANDROID)
 #define VK_USE_PLATFORM_ANDROID_KHR
-#elif defined(__APPLE__)
+#endif
+
+#if defined(__APPLE__)
 #define VK_USE_PLATFORM_MACOS_MVK
-#else
-//#warning Unknown platform
 #endif
 
 #include "vulkan/vulkan.h"

diff --git a/Source/Core/VideoBackends/Vulkan/main.cpp b/Source/Core/VideoBackends/Vulkan/main.cpp
@@ -36,7 +36,8 @@ void VideoBackend::InitBackendInfo()
 
   if (LoadVulkanLibrary())
   {
-    VkInstance temp_instance = VulkanContext::CreateVulkanInstance(false, false, false);
+    VkInstance temp_instance =
+        VulkanContext::CreateVulkanInstance(WindowSystemType::Headless, false, false);
     if (temp_instance)
     {
       if (LoadVulkanInstanceFunctions(temp_instance))
@@ -111,10 +112,10 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
 
   // Create Vulkan instance, needed before we can create a surface, or enumerate devices.
   // We use this instance to fill in backend info, then re-use it for the actual device.
-  bool enable_surface = wsi.render_surface != nullptr;
+  bool enable_surface = wsi.type != WindowSystemType::Headless;
   bool enable_debug_reports = ShouldEnableDebugReports(enable_validation_layer);
-  VkInstance instance = VulkanContext::CreateVulkanInstance(enable_surface, enable_debug_reports,
-                                                            enable_validation_layer);
+  VkInstance instance =
+      VulkanContext::CreateVulkanInstance(wsi.type, enable_debug_reports, enable_validation_layer);
   if (instance == VK_NULL_HANDLE)
   {
     PanicAlert("Failed to create Vulkan instance.");
@@ -150,7 +151,7 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
   VkSurfaceKHR surface = VK_NULL_HANDLE;
   if (enable_surface)
   {
-    surface = SwapChain::CreateVulkanSurface(instance, wsi.display_connection, wsi.render_surface);
+    surface = SwapChain::CreateVulkanSurface(instance, wsi);
     if (surface == VK_NULL_HANDLE)
     {
       PanicAlert("Failed to create Vulkan surface.");
@@ -213,8 +214,7 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
   std::unique_ptr<SwapChain> swap_chain;
   if (surface != VK_NULL_HANDLE)
   {
-    swap_chain = SwapChain::Create(wsi.display_connection, wsi.render_surface, surface,
-                                   g_ActiveConfig.bVSyncActive);
+    swap_chain = SwapChain::Create(wsi, surface, g_ActiveConfig.bVSyncActive);
     if (!swap_chain)
     {
       PanicAlert("Failed to create Vulkan swap chain.");