diff --git a/pcsx2/GS/GSUtil.cpp b/pcsx2/GS/GSUtil.cpp
index 9ed0a2da13..560f2b5b4e 100644
--- a/pcsx2/GS/GSUtil.cpp
+++ b/pcsx2/GS/GSUtil.cpp
@@ -22,6 +22,7 @@
 #include "Renderers/DX11/GSDevice11.h"
 #include <VersionHelpers.h>
 #include "svnrev.h"
+#include <wil/com.h>
 #else
 #define SVN_REV 0
 #define SVN_MODS 0
@@ -240,11 +241,11 @@ D3D_FEATURE_LEVEL GSUtil::CheckDirect3D11Level(IDXGIAdapter* adapter, D3D_DRIVER
 
 GSRendererType GSUtil::GetBestRenderer()
 {
-	CComPtr<IDXGIFactory1> dxgi_factory;
-	if (SUCCEEDED(CreateDXGIFactory1(IID_PPV_ARGS(&dxgi_factory))))
+	wil::com_ptr_nothrow<IDXGIFactory1> dxgi_factory;
+	if (SUCCEEDED(CreateDXGIFactory1(IID_PPV_ARGS(dxgi_factory.put()))))
 	{
-		CComPtr<IDXGIAdapter1> adapter;
-		if (SUCCEEDED(dxgi_factory->EnumAdapters1(0, &adapter)))
+		wil::com_ptr_nothrow<IDXGIAdapter1> adapter;
+		if (SUCCEEDED(dxgi_factory->EnumAdapters1(0, adapter.put())))
 		{
 			DXGI_ADAPTER_DESC1 desc;
 			if (SUCCEEDED(adapter->GetDesc1(&desc)))
@@ -286,11 +287,7 @@ std::string GStempdir()
 #ifdef _WIN32
 	wchar_t path[MAX_PATH + 1];
 	GetTempPath(MAX_PATH, path);
-	std::wstring tmp(path);
-	using convert_type = std::codecvt_utf8<wchar_t>;
-	std::wstring_convert<convert_type, wchar_t> converter;
-
-	return converter.to_bytes(tmp);
+	return convert_utf16_to_utf8(path);
 #else
 	return "/tmp";
 #endif
diff --git a/pcsx2/GS/Renderers/DX11/GSDevice11.cpp b/pcsx2/GS/Renderers/DX11/GSDevice11.cpp
index 4ff0af4118..e63cd03dc2 100644
--- a/pcsx2/GS/Renderers/DX11/GSDevice11.cpp
+++ b/pcsx2/GS/Renderers/DX11/GSDevice11.cpp
@@ -83,8 +83,6 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 		return false;
 	}
 
-	HRESULT hr = E_FAIL;
-
 	D3D11_BUFFER_DESC bd;
 	D3D11_SAMPLER_DESC sd;
 	D3D11_DEPTH_STENCIL_DESC dsd;
@@ -92,8 +90,9 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	D3D11_BLEND_DESC bsd;
 
 	// create factory
+	wil::com_ptr_nothrow<IDXGIFactory2> factory;
 	{
-		const HRESULT result = CreateDXGIFactory2(0, IID_PPV_ARGS(&m_factory));
+		const HRESULT result = CreateDXGIFactory2(0, IID_PPV_ARGS(factory.put()));
 		if (FAILED(result))
 		{
 			fprintf(stderr, "D3D11: Unable to create DXGIFactory2 (reason: %x)\n", result);
@@ -102,7 +101,7 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	}
 
 	// enumerate adapters
-	CComPtr<IDXGIAdapter1> adapter;
+	wil::com_ptr_nothrow<IDXGIAdapter1> adapter;
 	D3D_DRIVER_TYPE driver_type = D3D_DRIVER_TYPE_HARDWARE;
 
 	{
@@ -114,17 +113,17 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 		{
 			for (int i = 0;; i++)
 			{
-				CComPtr<IDXGIAdapter1> enum_adapter;
-				if (S_OK != m_factory->EnumAdapters1(i, &enum_adapter))
+				wil::com_ptr_nothrow<IDXGIAdapter1> enum_adapter;
+				if (FAILED(factory->EnumAdapters1(i, enum_adapter.put())))
 					break;
 				DXGI_ADAPTER_DESC1 desc;
-				hr = enum_adapter->GetDesc1(&desc);
-				if (S_OK == hr && (GSAdapter(desc) == adapter_id || adapter_id == "default"))
+				const HRESULT hr = enum_adapter->GetDesc1(&desc);
+				if (SUCCEEDED(hr) && (GSAdapter(desc) == adapter_id || adapter_id == "default"))
 				{
 					if (desc.VendorId == 0x10DE)
 						nvidia_vendor = true;
 
-					adapter = enum_adapter;
+					adapter = std::move(enum_adapter);
 					driver_type = D3D_DRIVER_TYPE_UNKNOWN;
 					break;
 				}
@@ -138,7 +137,7 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	{
 		uint32 flags = D3D11_CREATE_DEVICE_SINGLETHREADED;
 
-#ifdef DEBUG
+#ifdef _DEBUG
 		flags |= D3D11_CREATE_DEVICE_DEBUG;
 #endif
 
@@ -149,9 +148,9 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 		};
 
 		const HRESULT result = D3D11CreateDevice(
-			adapter, driver_type, nullptr, flags,
+			adapter.get(), driver_type, nullptr, flags,
 			supported_levels.data(), supported_levels.size(),
-			D3D11_SDK_VERSION, &m_dev, &level, &m_ctx);
+			D3D11_SDK_VERSION, m_dev.put(), &level, m_ctx.put());
 
 		if (FAILED(result))
 		{
@@ -177,9 +176,9 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 		// TODO: update swap effect
 		swapchain_description.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
 
-		const HRESULT result = m_factory->CreateSwapChainForHwnd(
-			m_dev, reinterpret_cast<HWND>(m_wnd->GetHandle()),
-			&swapchain_description, nullptr, nullptr, &m_swapchain);
+		const HRESULT result = factory->CreateSwapChainForHwnd(
+			m_dev.get(), reinterpret_cast<HWND>(m_wnd->GetHandle()),
+			&swapchain_description, nullptr, nullptr, m_swapchain.put());
 
 		if (FAILED(result))
 		{
@@ -206,23 +205,14 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 
 	// debug
 #ifdef _DEBUG
-	CComPtr<ID3D11Debug> debug;
-	hr = m_dev->QueryInterface<ID3D11Debug>(&debug);
-
-	if (SUCCEEDED(hr))
+	if (auto info_queue = m_dev.try_query<ID3D11InfoQueue>())
 	{
-		CComPtr<ID3D11InfoQueue> info_queue;
-		hr = debug->QueryInterface<ID3D11InfoQueue>(&info_queue);
+		int break_on = theApp.GetConfigI("dx_break_on_severity");
 
-		if (SUCCEEDED(hr))
-		{
-			int break_on = theApp.GetConfigI("dx_break_on_severity");
-
-			info_queue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, break_on & (1 << 0));
-			info_queue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, break_on & (1 << 1));
-			info_queue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, break_on & (1 << 2));
-			info_queue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_INFO, break_on & (1 << 3));
-		}
+		info_queue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, break_on & (1 << 0));
+		info_queue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, break_on & (1 << 1));
+		info_queue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, break_on & (1 << 2));
+		info_queue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_INFO, break_on & (1 << 3));
 	}
 #endif
 
@@ -239,7 +229,7 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 
 	std::vector<char> shader;
 	theApp.LoadResource(IDR_CONVERT_FX, shader);
-	CreateShader(shader, "convert.fx", nullptr, "vs_main", sm_model.GetPtr(), &m_convert.vs, il_convert, countof(il_convert), &m_convert.il);
+	CreateShader(shader, "convert.fx", nullptr, "vs_main", sm_model.GetPtr(), &m_convert.vs, il_convert, countof(il_convert), m_convert.il.put());
 
 	ShaderMacro sm_convert(m_shader.model);
 	sm_convert.AddMacro("PS_SCALE_FACTOR", std::max(1, m_upscale_multiplier));
@@ -248,24 +238,24 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 
 	for (size_t i = 0; i < countof(m_convert.ps); i++)
 	{
-		CreateShader(shader, "convert.fx", nullptr, format("ps_main%d", i).c_str(), sm_convert_ptr, &m_convert.ps[i]);
+		CreateShader(shader, "convert.fx", nullptr, format("ps_main%d", i).c_str(), sm_convert_ptr, m_convert.ps[i].put());
 	}
 
 	memset(&dsd, 0, sizeof(dsd));
 
-	hr = m_dev->CreateDepthStencilState(&dsd, &m_convert.dss);
+	m_dev->CreateDepthStencilState(&dsd, m_convert.dss.put());
 
 	dsd.DepthEnable = true;
 	dsd.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
 	dsd.DepthFunc = D3D11_COMPARISON_ALWAYS;
 
-	hr = m_dev->CreateDepthStencilState(&dsd, &m_convert.dss_write);
+	m_dev->CreateDepthStencilState(&dsd, m_convert.dss_write.put());
 
 	memset(&bsd, 0, sizeof(bsd));
 
 	bsd.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
 
-	hr = m_dev->CreateBlendState(&bsd, &m_convert.bs);
+	m_dev->CreateBlendState(&bsd, m_convert.bs.put());
 
 	// merge
 
@@ -275,12 +265,12 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	bd.Usage = D3D11_USAGE_DEFAULT;
 	bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 
-	hr = m_dev->CreateBuffer(&bd, NULL, &m_merge.cb);
+	m_dev->CreateBuffer(&bd, nullptr, m_merge.cb.put());
 
 	theApp.LoadResource(IDR_MERGE_FX, shader);
 	for (size_t i = 0; i < countof(m_merge.ps); i++)
 	{
-		CreateShader(shader, "merge.fx", nullptr, format("ps_main%d", i).c_str(), sm_model.GetPtr(), &m_merge.ps[i]);
+		CreateShader(shader, "merge.fx", nullptr, format("ps_main%d", i).c_str(), sm_model.GetPtr(), m_merge.ps[i].put());
 	}
 
 	memset(&bsd, 0, sizeof(bsd));
@@ -294,7 +284,7 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	bsd.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
 	bsd.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
 
-	hr = m_dev->CreateBlendState(&bsd, &m_merge.bs);
+	m_dev->CreateBlendState(&bsd, m_merge.bs.put());
 
 	// interlace
 
@@ -304,12 +294,12 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	bd.Usage = D3D11_USAGE_DEFAULT;
 	bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 
-	hr = m_dev->CreateBuffer(&bd, NULL, &m_interlace.cb);
+	m_dev->CreateBuffer(&bd, nullptr, m_interlace.cb.put());
 
 	theApp.LoadResource(IDR_INTERLACE_FX, shader);
 	for (size_t i = 0; i < countof(m_interlace.ps); i++)
 	{
-		CreateShader(shader, "interlace.fx", nullptr, format("ps_main%d", i).c_str(), sm_model.GetPtr(), &m_interlace.ps[i]);
+		CreateShader(shader, "interlace.fx", nullptr, format("ps_main%d", i).c_str(), sm_model.GetPtr(), m_interlace.ps[i].put());
 	}
 
 	// Shade Boost
@@ -326,10 +316,10 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	bd.Usage = D3D11_USAGE_DEFAULT;
 	bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 
-	hr = m_dev->CreateBuffer(&bd, NULL, &m_shadeboost.cb);
+	m_dev->CreateBuffer(&bd, nullptr, m_shadeboost.cb.put());
 
 	theApp.LoadResource(IDR_SHADEBOOST_FX, shader);
-	CreateShader(shader, "shadeboost.fx", nullptr, "ps_main", sm_sboost.GetPtr(), &m_shadeboost.ps);
+	CreateShader(shader, "shadeboost.fx", nullptr, "ps_main", sm_sboost.GetPtr(), m_shadeboost.ps.put());
 
 	// External fx shader
 
@@ -339,7 +329,7 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	bd.Usage = D3D11_USAGE_DEFAULT;
 	bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 
-	hr = m_dev->CreateBuffer(&bd, NULL, &m_shaderfx.cb);
+	m_dev->CreateBuffer(&bd, nullptr, m_shaderfx.cb.put());
 
 	// Fxaa
 
@@ -349,7 +339,7 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	bd.Usage = D3D11_USAGE_DEFAULT;
 	bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 
-	hr = m_dev->CreateBuffer(&bd, NULL, &m_fxaa.cb);
+	m_dev->CreateBuffer(&bd, nullptr, m_fxaa.cb.put());
 
 	//
 
@@ -366,9 +356,10 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	rd.MultisampleEnable = true;
 	rd.AntialiasedLineEnable = false;
 
-	hr = m_dev->CreateRasterizerState(&rd, &m_rs);
+	wil::com_ptr_nothrow<ID3D11RasterizerState> rs;
+	m_dev->CreateRasterizerState(&rd, rs.put());
 
-	m_ctx->RSSetState(m_rs);
+	m_ctx->RSSetState(rs.get());
 
 	//
 
@@ -383,11 +374,11 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	sd.MaxAnisotropy = m_aniso_filter;
 	sd.ComparisonFunc = D3D11_COMPARISON_NEVER;
 
-	hr = m_dev->CreateSamplerState(&sd, &m_convert.ln);
+	m_dev->CreateSamplerState(&sd, m_convert.ln.put());
 
 	sd.Filter = m_aniso_filter ? D3D11_FILTER_ANISOTROPIC : D3D11_FILTER_MIN_MAG_MIP_POINT;
 
-	hr = m_dev->CreateSamplerState(&sd, &m_convert.pt);
+	m_dev->CreateSamplerState(&sd, m_convert.pt.put());
 
 	//
 
@@ -414,13 +405,13 @@ bool GSDevice11::Create(const std::shared_ptr<GSWnd>& wnd)
 	dsd.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
 	dsd.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
 
-	m_dev->CreateDepthStencilState(&dsd, &m_date.dss);
+	m_dev->CreateDepthStencilState(&dsd, m_date.dss.put());
 
 	D3D11_BLEND_DESC blend;
 
 	memset(&blend, 0, sizeof(blend));
 
-	m_dev->CreateBlendState(&blend, &m_date.bs);
+	m_dev->CreateBlendState(&blend, m_date.bs.put());
 
 	GSVector2i tex_font = m_osd.get_texture_font_size();
 
@@ -444,14 +435,13 @@ bool GSDevice11::Reset(int w, int h)
 		m_swapchain->GetDesc(&scd);
 		m_swapchain->ResizeBuffers(scd.BufferCount, w, h, scd.BufferDesc.Format, 0);
 
-		CComPtr<ID3D11Texture2D> backbuffer;
-
-		if (FAILED(m_swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backbuffer)))
+		wil::com_ptr_nothrow<ID3D11Texture2D> backbuffer;
+		if (FAILED(m_swapchain->GetBuffer(0, IID_PPV_ARGS(backbuffer.put()))))
 		{
 			return false;
 		}
 
-		m_backbuffer = new GSTexture11(backbuffer);
+		m_backbuffer = new GSTexture11(std::move(backbuffer));
 	}
 
 	return true;
@@ -507,7 +497,7 @@ void GSDevice11::AfterDraw()
 		OutputDebugStringA(format("WARNING: FB read detected on slot %i, copying...", i).c_str());
 #endif
 		Recycle(m_state.ps_sr_texture[i]);
-		PSSetShaderResource(i, NULL);
+		PSSetShaderResource(i, nullptr);
 	}
 }
 
@@ -612,13 +602,12 @@ GSTexture* GSDevice11::CreateSurface(int type, int w, int h, int format)
 
 	GSTexture11* t = NULL;
 
-	CComPtr<ID3D11Texture2D> texture;
-
-	hr = m_dev->CreateTexture2D(&desc, NULL, &texture);
+	wil::com_ptr_nothrow<ID3D11Texture2D> texture;
+	hr = m_dev->CreateTexture2D(&desc, nullptr, texture.put());
 
 	if (SUCCEEDED(hr))
 	{
-		t = new GSTexture11(texture);
+		t = new GSTexture11(std::move(texture));
 
 		switch (type)
 		{
@@ -661,7 +650,7 @@ GSTexture* GSDevice11::CopyOffscreen(GSTexture* src, const GSVector4& sRect, int
 	{
 		GSVector4 dRect(0, 0, w, h);
 
-		StretchRect(src, sRect, rt, dRect, m_convert.ps[ps_shader], NULL);
+		StretchRect(src, sRect, rt, dRect, m_convert.ps[ps_shader].get(), NULL);
 
 		dst = CreateOffscreen(w, h, format);
 
@@ -716,18 +705,17 @@ void GSDevice11::CloneTexture(GSTexture* src, GSTexture** dest)
 
 void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, int shader, bool linear)
 {
-	StretchRect(sTex, sRect, dTex, dRect, m_convert.ps[shader], NULL, linear);
+	StretchRect(sTex, sRect, dTex, dRect, m_convert.ps[shader].get(), nullptr, linear);
 }
 
 void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, bool linear)
 {
-	StretchRect(sTex, sRect, dTex, dRect, ps, ps_cb, m_convert.bs, linear);
+	StretchRect(sTex, sRect, dTex, dRect, ps, ps_cb, m_convert.bs.get(), linear);
 }
 
 void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha)
 {
 	D3D11_BLEND_DESC bd = {};
-	CComPtr<ID3D11BlendState> bs;
 
 	uint8 write_mask = 0;
 
@@ -738,9 +726,10 @@ void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture*
 
 	bd.RenderTarget[0].RenderTargetWriteMask = write_mask;
 
-	m_dev->CreateBlendState(&bd, &bs);
+	wil::com_ptr_nothrow<ID3D11BlendState> bs;
+	m_dev->CreateBlendState(&bd, bs.put());
 
-	StretchRect(sTex, sRect, dTex, dRect, m_convert.ps[ShaderConvert_COPY], nullptr, bs, false);
+	StretchRect(sTex, sRect, dTex, dRect, m_convert.ps[ShaderConvert_COPY].get(), nullptr, bs.get(), false);
 }
 
 void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, ID3D11BlendState* bs, bool linear)
@@ -762,16 +751,16 @@ void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture*
 
 
 	if (draw_in_depth)
-		OMSetDepthStencilState(m_convert.dss_write, 0);
+		OMSetDepthStencilState(m_convert.dss_write.get(), 0);
 	else
-		OMSetDepthStencilState(m_convert.dss, 0);
+		OMSetDepthStencilState(m_convert.dss.get(), 0);
 
 	OMSetBlendState(bs, 0);
 
 	if (draw_in_depth)
-		OMSetRenderTargets(NULL, dTex);
+		OMSetRenderTargets(nullptr, dTex);
 	else
-		OMSetRenderTargets(dTex, NULL);
+		OMSetRenderTargets(dTex, nullptr);
 
 	// ia
 
@@ -791,23 +780,23 @@ void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture*
 
 
 	IASetVertexBuffer(vertices, sizeof(vertices[0]), countof(vertices));
-	IASetInputLayout(m_convert.il);
+	IASetInputLayout(m_convert.il.get());
 	IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
 	// vs
 
-	VSSetShader(m_convert.vs, NULL);
+	VSSetShader(m_convert.vs.get(), nullptr);
 
 
 	// gs
 
-	GSSetShader(NULL, NULL);
+	GSSetShader(nullptr, nullptr);
 
 
 	// ps
 
-	PSSetShaderResources(sTex, NULL);
-	PSSetSamplerState(linear ? m_convert.ln : m_convert.pt, NULL);
+	PSSetShaderResources(sTex, nullptr);
+	PSSetSamplerState(linear ? m_convert.ln.get() : m_convert.pt.get(), nullptr);
 	PSSetShader(ps, ps_cb);
 
 	//
@@ -818,7 +807,7 @@ void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture*
 
 	EndScene();
 
-	PSSetShaderResources(NULL, NULL);
+	PSSetShaderResources(nullptr, nullptr);
 }
 
 void GSDevice11::RenderOsd(GSTexture* dt)
@@ -826,9 +815,9 @@ void GSDevice11::RenderOsd(GSTexture* dt)
 	BeginScene();
 
 	// om
-	OMSetDepthStencilState(m_convert.dss, 0);
-	OMSetBlendState(m_merge.bs, 0);
-	OMSetRenderTargets(dt, NULL);
+	OMSetDepthStencilState(m_convert.dss.get(), 0);
+	OMSetBlendState(m_merge.bs.get(), 0);
+	OMSetRenderTargets(dt, nullptr);
 
 	if (m_osd.m_texture_dirty)
 	{
@@ -837,26 +826,26 @@ void GSDevice11::RenderOsd(GSTexture* dt)
 
 	// ps
 	PSSetShaderResource(0, m_font.get());
-	PSSetSamplerState(m_convert.pt, NULL);
-	PSSetShader(m_convert.ps[ShaderConvert_OSD], NULL);
+	PSSetSamplerState(m_convert.pt.get(), nullptr);
+	PSSetShader(m_convert.ps[ShaderConvert_OSD].get(), nullptr);
 
 	// ia
-	IASetInputLayout(m_convert.il);
+	IASetInputLayout(m_convert.il.get());
 	IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 
 	// Note scaling could also be done in shader (require gl3/dx10)
 	size_t count = m_osd.Size();
-	void* dst = NULL;
+	void* dst = nullptr;
 
 	IAMapVertexBuffer(&dst, sizeof(GSVertexPT1), count);
 	count = m_osd.GeneratePrimitives((GSVertexPT1*)dst, count);
 	IAUnmapVertexBuffer();
 
 	// vs
-	VSSetShader(m_convert.vs, NULL);
+	VSSetShader(m_convert.vs.get(), nullptr);
 
 	// gs
-	GSSetShader(NULL, NULL);
+	GSSetShader(nullptr, nullptr);
 
 	DrawPrimitive();
 
@@ -872,14 +861,14 @@ void GSDevice11::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex,
 
 	if (sTex[1] && !slbg)
 	{
-		StretchRect(sTex[1], sRect[1], dTex, dRect[1], m_merge.ps[0], NULL, true);
+		StretchRect(sTex[1], sRect[1], dTex, dRect[1], m_merge.ps[0].get(), nullptr, true);
 	}
 
 	if (sTex[0])
 	{
-		m_ctx->UpdateSubresource(m_merge.cb, 0, NULL, &c, 0, 0);
+		m_ctx->UpdateSubresource(m_merge.cb.get(), 0, nullptr, &c, 0, 0);
 
-		StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge.ps[mmod ? 1 : 0], m_merge.cb, m_merge.bs, true);
+		StretchRect(sTex[0], sRect[0], dTex, dRect[0], m_merge.ps[mmod ? 1 : 0].get(), m_merge.cb.get(), m_merge.bs.get(), true);
 	}
 }
 
@@ -895,9 +884,9 @@ void GSDevice11::DoInterlace(GSTexture* sTex, GSTexture* dTex, int shader, bool
 	cb.ZrH = GSVector2(0, 1.0f / s.y);
 	cb.hH = s.y / 2;
 
-	m_ctx->UpdateSubresource(m_interlace.cb, 0, NULL, &cb, 0, 0);
+	m_ctx->UpdateSubresource(m_interlace.cb.get(), 0, nullptr, &cb, 0, 0);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_interlace.ps[shader], m_interlace.cb, linear);
+	StretchRect(sTex, sRect, dTex, dRect, m_interlace.ps[shader].get(), m_interlace.cb.get(), linear);
 }
 
 void GSDevice11::DoExternalFX(GSTexture* sTex, GSTexture* dTex)
@@ -933,7 +922,7 @@ void GSDevice11::DoExternalFX(GSTexture* sTex, GSTexture* dTex)
 			const std::string& s = shader.str();
 			std::vector<char> buff(s.begin(), s.end());
 			ShaderMacro sm(m_shader.model);
-			CreateShader(buff, shader_name.c_str(), D3D_COMPILE_STANDARD_FILE_INCLUDE, "ps_main", sm.GetPtr(), &m_shaderfx.ps);
+			CreateShader(buff, shader_name.c_str(), D3D_COMPILE_STANDARD_FILE_INCLUDE, "ps_main", sm.GetPtr(), m_shaderfx.ps.put());
 		}
 		catch (GSRecoverableError)
 		{
@@ -945,9 +934,9 @@ void GSDevice11::DoExternalFX(GSTexture* sTex, GSTexture* dTex)
 	cb.rcpFrame = GSVector4(1.0f / (float)s.x, 1.0f / (float)s.y, 0.0f, 0.0f);
 	cb.rcpFrameOpt = GSVector4::zero();
 
-	m_ctx->UpdateSubresource(m_shaderfx.cb, 0, NULL, &cb, 0, 0);
+	m_ctx->UpdateSubresource(m_shaderfx.cb.get(), 0, nullptr, &cb, 0, 0);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_shaderfx.ps, m_shaderfx.cb, true);
+	StretchRect(sTex, sRect, dTex, dRect, m_shaderfx.ps.get(), m_shaderfx.cb.get(), true);
 }
 
 void GSDevice11::DoFXAA(GSTexture* sTex, GSTexture* dTex)
@@ -966,7 +955,7 @@ void GSDevice11::DoFXAA(GSTexture* sTex, GSTexture* dTex)
 			std::vector<char> shader;
 			theApp.LoadResource(IDR_FXAA_FX, shader);
 			ShaderMacro sm(m_shader.model);
-			CreateShader(shader, "fxaa.fx", nullptr, "ps_main", sm.GetPtr(), &m_fxaa.ps);
+			CreateShader(shader, "fxaa.fx", nullptr, "ps_main", sm.GetPtr(), m_fxaa.ps.put());
 		}
 		catch (GSRecoverableError)
 		{
@@ -977,9 +966,9 @@ void GSDevice11::DoFXAA(GSTexture* sTex, GSTexture* dTex)
 	cb.rcpFrame = GSVector4(1.0f / s.x, 1.0f / s.y, 0.0f, 0.0f);
 	cb.rcpFrameOpt = GSVector4::zero();
 
-	m_ctx->UpdateSubresource(m_fxaa.cb, 0, NULL, &cb, 0, 0);
+	m_ctx->UpdateSubresource(m_fxaa.cb.get(), 0, nullptr, &cb, 0, 0);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_fxaa.ps, m_fxaa.cb, true);
+	StretchRect(sTex, sRect, dTex, dRect, m_fxaa.ps.get(), m_fxaa.cb.get(), true);
 
 	//sTex->Save("c:\\temp1\\1.bmp");
 	//dTex->Save("c:\\temp1\\2.bmp");
@@ -997,9 +986,9 @@ void GSDevice11::DoShadeBoost(GSTexture* sTex, GSTexture* dTex)
 	cb.rcpFrame = GSVector4(1.0f / s.x, 1.0f / s.y, 0.0f, 0.0f);
 	cb.rcpFrameOpt = GSVector4::zero();
 
-	m_ctx->UpdateSubresource(m_shadeboost.cb, 0, NULL, &cb, 0, 0);
+	m_ctx->UpdateSubresource(m_shadeboost.cb.get(), 0, nullptr, &cb, 0, 0);
 
-	StretchRect(sTex, sRect, dTex, dRect, m_shadeboost.ps, m_shadeboost.cb, true);
+	StretchRect(sTex, sRect, dTex, dRect, m_shadeboost.ps.get(), m_shadeboost.cb.get(), true);
 }
 
 void GSDevice11::SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vertices, bool datm)
@@ -1012,28 +1001,28 @@ void GSDevice11::SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vert
 
 	// om
 
-	OMSetDepthStencilState(m_date.dss, 1);
-	OMSetBlendState(m_date.bs, 0);
-	OMSetRenderTargets(NULL, ds);
+	OMSetDepthStencilState(m_date.dss.get(), 1);
+	OMSetBlendState(m_date.bs.get(), 0);
+	OMSetRenderTargets(nullptr, ds);
 
 	// ia
 
 	IASetVertexBuffer(vertices, sizeof(vertices[0]), 4);
-	IASetInputLayout(m_convert.il);
+	IASetInputLayout(m_convert.il.get());
 	IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
 	// vs
 
-	VSSetShader(m_convert.vs, NULL);
+	VSSetShader(m_convert.vs.get(), nullptr);
 
 	// gs
 
-	GSSetShader(NULL, NULL);
+	GSSetShader(nullptr, nullptr);
 
 	// ps
-	PSSetShaderResources(rt, NULL);
-	PSSetSamplerState(m_convert.pt, NULL);
-	PSSetShader(m_convert.ps[datm ? ShaderConvert_DATM_1 : ShaderConvert_DATM_0], NULL);
+	PSSetShaderResources(rt, nullptr);
+	PSSetSamplerState(m_convert.pt.get(), nullptr);
+	PSSetShader(m_convert.ps[datm ? ShaderConvert_DATM_1 : ShaderConvert_DATM_0].get(), nullptr);
 
 	//
 
@@ -1046,7 +1035,7 @@ void GSDevice11::SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vert
 
 void GSDevice11::IASetVertexBuffer(const void* vertex, size_t stride, size_t count)
 {
-	void* ptr = NULL;
+	void* ptr = nullptr;
 
 	if (IAMapVertexBuffer(&ptr, stride, count))
 	{
@@ -1062,14 +1051,13 @@ bool GSDevice11::IAMapVertexBuffer(void** vertex, size_t stride, size_t count)
 
 	if (count * stride > m_vertex.limit * m_vertex.stride)
 	{
-		m_vb_old = m_vb;
-		m_vb = NULL;
+		m_vb.reset();
 
 		m_vertex.start = 0;
 		m_vertex.limit = std::max<int>(count * 3 / 2, 11000);
 	}
 
-	if (m_vb == NULL)
+	if (m_vb == nullptr)
 	{
 		D3D11_BUFFER_DESC bd;
 
@@ -1080,9 +1068,7 @@ bool GSDevice11::IAMapVertexBuffer(void** vertex, size_t stride, size_t count)
 		bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
 		bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
 
-		HRESULT hr;
-
-		hr = m_dev->CreateBuffer(&bd, NULL, &m_vb);
+		HRESULT hr = m_dev->CreateBuffer(&bd, nullptr, m_vb.put());
 
 		if (FAILED(hr))
 			return false;
@@ -1099,7 +1085,7 @@ bool GSDevice11::IAMapVertexBuffer(void** vertex, size_t stride, size_t count)
 
 	D3D11_MAPPED_SUBRESOURCE m;
 
-	if (FAILED(m_ctx->Map(m_vb, 0, type, 0, &m)))
+	if (FAILED(m_ctx->Map(m_vb.get(), 0, type, 0, &m)))
 	{
 		return false;
 	}
@@ -1114,9 +1100,9 @@ bool GSDevice11::IAMapVertexBuffer(void** vertex, size_t stride, size_t count)
 
 void GSDevice11::IAUnmapVertexBuffer()
 {
-	m_ctx->Unmap(m_vb, 0);
+	m_ctx->Unmap(m_vb.get(), 0);
 
-	IASetVertexBuffer(m_vb, m_vertex.stride);
+	IASetVertexBuffer(m_vb.get(), m_vertex.stride);
 }
 
 void GSDevice11::IASetVertexBuffer(ID3D11Buffer* vb, size_t stride)
@@ -1139,14 +1125,13 @@ void GSDevice11::IASetIndexBuffer(const void* index, size_t count)
 
 	if (count > m_index.limit)
 	{
-		m_ib_old = m_ib;
-		m_ib = NULL;
+		m_ib.reset();
 
 		m_index.start = 0;
 		m_index.limit = std::max<int>(count * 3 / 2, 11000);
 	}
 
-	if (m_ib == NULL)
+	if (m_ib == nullptr)
 	{
 		D3D11_BUFFER_DESC bd;
 
@@ -1159,7 +1144,7 @@ void GSDevice11::IASetIndexBuffer(const void* index, size_t count)
 
 		HRESULT hr;
 
-		hr = m_dev->CreateBuffer(&bd, NULL, &m_ib);
+		hr = m_dev->CreateBuffer(&bd, nullptr, m_ib.put());
 
 		if (FAILED(hr))
 			return;
@@ -1176,16 +1161,16 @@ void GSDevice11::IASetIndexBuffer(const void* index, size_t count)
 
 	D3D11_MAPPED_SUBRESOURCE m;
 
-	if (SUCCEEDED(m_ctx->Map(m_ib, 0, type, 0, &m)))
+	if (SUCCEEDED(m_ctx->Map(m_ib.get(), 0, type, 0, &m)))
 	{
 		memcpy((uint8*)m.pData + m_index.start * sizeof(uint32), index, count * sizeof(uint32));
 
-		m_ctx->Unmap(m_ib, 0);
+		m_ctx->Unmap(m_ib.get(), 0);
 	}
 
 	m_index.count = count;
 
-	IASetIndexBuffer(m_ib);
+	IASetIndexBuffer(m_ib.get());
 }
 
 void GSDevice11::IASetIndexBuffer(ID3D11Buffer* ib)
@@ -1224,7 +1209,7 @@ void GSDevice11::VSSetShader(ID3D11VertexShader* vs, ID3D11Buffer* vs_cb)
 	{
 		m_state.vs = vs;
 
-		m_ctx->VSSetShader(vs, NULL, 0);
+		m_ctx->VSSetShader(vs, nullptr, 0);
 	}
 
 	if (m_state.vs_cb != vs_cb)
@@ -1241,7 +1226,7 @@ void GSDevice11::GSSetShader(ID3D11GeometryShader* gs, ID3D11Buffer* gs_cb)
 	{
 		m_state.gs = gs;
 
-		m_ctx->GSSetShader(gs, NULL, 0);
+		m_ctx->GSSetShader(gs, nullptr, 0);
 	}
 
 	if (m_state.gs_cb != gs_cb)
@@ -1259,13 +1244,13 @@ void GSDevice11::PSSetShaderResources(GSTexture* sr0, GSTexture* sr1)
 
 	for (size_t i = 2; i < m_state.ps_sr_views.size(); i++)
 	{
-		PSSetShaderResource(i, NULL);
+		PSSetShaderResource(i, nullptr);
 	}
 }
 
 void GSDevice11::PSSetShaderResource(int i, GSTexture* sr)
 {
-	ID3D11ShaderResourceView* srv = NULL;
+	ID3D11ShaderResourceView* srv = nullptr;
 
 	if (sr)
 		srv = *(GSTexture11*)sr;
@@ -1300,7 +1285,7 @@ void GSDevice11::PSSetShader(ID3D11PixelShader* ps, ID3D11Buffer* ps_cb)
 	{
 		m_state.ps = ps;
 
-		m_ctx->PSSetShader(ps, NULL, 0);
+		m_ctx->PSSetShader(ps, nullptr, 0);
 	}
 
 	if (m_state.ps_cb != ps_cb)
@@ -1343,8 +1328,8 @@ void GSDevice11::OMSetBlendState(ID3D11BlendState* bs, float bf)
 
 void GSDevice11::OMSetRenderTargets(GSTexture* rt, GSTexture* ds, const GSVector4i* scissor)
 {
-	ID3D11RenderTargetView* rtv = NULL;
-	ID3D11DepthStencilView* dsv = NULL;
+	ID3D11RenderTargetView* rtv = nullptr;
+	ID3D11DepthStencilView* dsv = nullptr;
 
 	if (!rt && !ds)
 		throw GSRecoverableError();
@@ -1415,11 +1400,11 @@ void GSDevice11::CreateShader(const std::vector<char>& source, const char* fn, I
 {
 	HRESULT hr;
 
-	CComPtr<ID3DBlob> shader;
+	wil::com_ptr_nothrow<ID3DBlob> shader;
 
-	CompileShader(source, fn, include, entry, macro, &shader, m_shader.vs);
+	CompileShader(source, fn, include, entry, macro, shader.put(), m_shader.vs);
 
-	hr = m_dev->CreateVertexShader((void*)shader->GetBufferPointer(), shader->GetBufferSize(), NULL, vs);
+	hr = m_dev->CreateVertexShader(shader->GetBufferPointer(), shader->GetBufferSize(), nullptr, vs);
 
 	if (FAILED(hr))
 	{
@@ -1438,11 +1423,11 @@ void GSDevice11::CreateShader(const std::vector<char>& source, const char* fn, I
 {
 	HRESULT hr;
 
-	CComPtr<ID3DBlob> shader;
+	wil::com_ptr_nothrow<ID3DBlob> shader;
 
-	CompileShader(source, fn, include, entry, macro, &shader, m_shader.gs);
+	CompileShader(source, fn, include, entry, macro, shader.put(), m_shader.gs);
 
-	hr = m_dev->CreateGeometryShader((void*)shader->GetBufferPointer(), shader->GetBufferSize(), NULL, gs);
+	hr = m_dev->CreateGeometryShader(shader->GetBufferPointer(), shader->GetBufferSize(), nullptr, gs);
 
 	if (FAILED(hr))
 	{
@@ -1454,11 +1439,11 @@ void GSDevice11::CreateShader(const std::vector<char>& source, const char* fn, I
 {
 	HRESULT hr;
 
-	CComPtr<ID3DBlob> shader;
+	wil::com_ptr_nothrow<ID3DBlob> shader;
 
-	CompileShader(source, fn, include, entry, macro, &shader, m_shader.ps);
+	CompileShader(source, fn, include, entry, macro, shader.put(), m_shader.ps);
 
-	hr = m_dev->CreatePixelShader((void*)shader->GetBufferPointer(), shader->GetBufferSize(), NULL, ps);
+	hr = m_dev->CreatePixelShader(shader->GetBufferPointer(), shader->GetBufferSize(), nullptr, ps);
 
 	if (FAILED(hr))
 	{
@@ -1466,9 +1451,9 @@ void GSDevice11::CreateShader(const std::vector<char>& source, const char* fn, I
 	}
 }
 
-void GSDevice11::CompileShader(const std::vector<char>& source, const char* fn, ID3DInclude* include, const char* entry, D3D_SHADER_MACRO* macro, ID3DBlob** shader, std::string shader_model)
+void GSDevice11::CompileShader(const std::vector<char>& source, const char* fn, ID3DInclude* include, const char* entry, D3D_SHADER_MACRO* macro, ID3DBlob** shader, const std::string& shader_model)
 {
-	CComPtr<ID3DBlob> error;
+	wil::com_ptr_nothrow<ID3DBlob> error;
 
 	UINT flags = 0;
 
@@ -1479,7 +1464,7 @@ void GSDevice11::CompileShader(const std::vector<char>& source, const char* fn,
 	const HRESULT hr = D3DCompile(
 		source.data(), source.size(), fn, macro,
 		include, entry, shader_model.c_str(),
-		flags, 0, shader, &error);
+		flags, 0, shader, error.put());
 
 	if (error)
 		fprintf(stderr, "%s\n", (const char*)error->GetBufferPointer());
diff --git a/pcsx2/GS/Renderers/DX11/GSDevice11.h b/pcsx2/GS/Renderers/DX11/GSDevice11.h
index f2232f8ab5..539f91a982 100644
--- a/pcsx2/GS/Renderers/DX11/GSDevice11.h
+++ b/pcsx2/GS/Renderers/DX11/GSDevice11.h
@@ -18,11 +18,12 @@
 #include "GSTexture11.h"
 #include "GS/GSVector.h"
 #include "GS/Renderers/Common/GSDevice.h"
+#include <wil/com.h>
 
 struct GSVertexShader11
 {
-	CComPtr<ID3D11VertexShader> vs;
-	CComPtr<ID3D11InputLayout> il;
+	wil::com_ptr_nothrow<ID3D11VertexShader> vs;
+	wil::com_ptr_nothrow<ID3D11InputLayout> il;
 };
 
 class GSDevice11 final : public GSDevice
@@ -406,14 +407,11 @@ private:
 
 	uint16 ConvertBlendEnum(uint16 generic) final;
 
-	CComPtr<IDXGIFactory2> m_factory;
-	CComPtr<ID3D11Device> m_dev;
-	CComPtr<ID3D11DeviceContext> m_ctx;
-	CComPtr<IDXGISwapChain1> m_swapchain;
-	CComPtr<ID3D11Buffer> m_vb;
-	CComPtr<ID3D11Buffer> m_vb_old;
-	CComPtr<ID3D11Buffer> m_ib;
-	CComPtr<ID3D11Buffer> m_ib_old;
+	wil::com_ptr_nothrow<ID3D11Device> m_dev;
+	wil::com_ptr_nothrow<ID3D11DeviceContext> m_ctx;
+	wil::com_ptr_nothrow<IDXGISwapChain1> m_swapchain;
+	wil::com_ptr_nothrow<ID3D11Buffer> m_vb;
+	wil::com_ptr_nothrow<ID3D11Buffer> m_ib;
 
 	struct
 	{
@@ -444,69 +442,68 @@ private:
 		uint16_t ps_sr_bitfield;
 	} m_state;
 
-	CComPtr<ID3D11RasterizerState> m_rs;
 
 	struct
 	{
-		CComPtr<ID3D11InputLayout> il;
-		CComPtr<ID3D11VertexShader> vs;
-		CComPtr<ID3D11PixelShader> ps[ShaderConvert_Count];
-		CComPtr<ID3D11SamplerState> ln;
-		CComPtr<ID3D11SamplerState> pt;
-		CComPtr<ID3D11DepthStencilState> dss;
-		CComPtr<ID3D11DepthStencilState> dss_write;
-		CComPtr<ID3D11BlendState> bs;
+		wil::com_ptr_nothrow<ID3D11InputLayout> il;
+		wil::com_ptr_nothrow<ID3D11VertexShader> vs;
+		wil::com_ptr_nothrow<ID3D11PixelShader> ps[ShaderConvert_Count];
+		wil::com_ptr_nothrow<ID3D11SamplerState> ln;
+		wil::com_ptr_nothrow<ID3D11SamplerState> pt;
+		wil::com_ptr_nothrow<ID3D11DepthStencilState> dss;
+		wil::com_ptr_nothrow<ID3D11DepthStencilState> dss_write;
+		wil::com_ptr_nothrow<ID3D11BlendState> bs;
 	} m_convert;
 
 	struct
 	{
-		CComPtr<ID3D11PixelShader> ps[2];
-		CComPtr<ID3D11Buffer> cb;
-		CComPtr<ID3D11BlendState> bs;
+		wil::com_ptr_nothrow<ID3D11PixelShader> ps[2];
+		wil::com_ptr_nothrow<ID3D11Buffer> cb;
+		wil::com_ptr_nothrow<ID3D11BlendState> bs;
 	} m_merge;
 
 	struct
 	{
-		CComPtr<ID3D11PixelShader> ps[4];
-		CComPtr<ID3D11Buffer> cb;
+		wil::com_ptr_nothrow<ID3D11PixelShader> ps[4];
+		wil::com_ptr_nothrow<ID3D11Buffer> cb;
 	} m_interlace;
 
 	struct
 	{
-		CComPtr<ID3D11PixelShader> ps;
-		CComPtr<ID3D11Buffer> cb;
+		wil::com_ptr_nothrow<ID3D11PixelShader> ps;
+		wil::com_ptr_nothrow<ID3D11Buffer> cb;
 	} m_shaderfx;
 
 	struct
 	{
-		CComPtr<ID3D11PixelShader> ps;
-		CComPtr<ID3D11Buffer> cb;
+		wil::com_ptr_nothrow<ID3D11PixelShader> ps;
+		wil::com_ptr_nothrow<ID3D11Buffer> cb;
 	} m_fxaa;
 
 	struct
 	{
-		CComPtr<ID3D11PixelShader> ps;
-		CComPtr<ID3D11Buffer> cb;
+		wil::com_ptr_nothrow<ID3D11PixelShader> ps;
+		wil::com_ptr_nothrow<ID3D11Buffer> cb;
 	} m_shadeboost;
 
 	struct
 	{
-		CComPtr<ID3D11DepthStencilState> dss;
-		CComPtr<ID3D11BlendState> bs;
+		wil::com_ptr_nothrow<ID3D11DepthStencilState> dss;
+		wil::com_ptr_nothrow<ID3D11BlendState> bs;
 	} m_date;
 
 	// Shaders...
 
 	std::unordered_map<uint32, GSVertexShader11> m_vs;
-	CComPtr<ID3D11Buffer> m_vs_cb;
-	std::unordered_map<uint32, CComPtr<ID3D11GeometryShader>> m_gs;
-	CComPtr<ID3D11Buffer> m_gs_cb;
-	std::unordered_map<uint64, CComPtr<ID3D11PixelShader>> m_ps;
-	CComPtr<ID3D11Buffer> m_ps_cb;
-	std::unordered_map<uint32, CComPtr<ID3D11SamplerState>> m_ps_ss;
-	CComPtr<ID3D11SamplerState> m_palette_ss;
-	std::unordered_map<uint32, CComPtr<ID3D11DepthStencilState>> m_om_dss;
-	std::unordered_map<uint32, CComPtr<ID3D11BlendState>> m_om_bs;
+	wil::com_ptr_nothrow<ID3D11Buffer> m_vs_cb;
+	std::unordered_map<uint32, wil::com_ptr_nothrow<ID3D11GeometryShader>> m_gs;
+	wil::com_ptr_nothrow<ID3D11Buffer> m_gs_cb;
+	std::unordered_map<uint64, wil::com_ptr_nothrow<ID3D11PixelShader>> m_ps;
+	wil::com_ptr_nothrow<ID3D11Buffer> m_ps_cb;
+	std::unordered_map<uint32, wil::com_ptr_nothrow<ID3D11SamplerState>> m_ps_ss;
+	wil::com_ptr_nothrow<ID3D11SamplerState> m_palette_ss;
+	std::unordered_map<uint32, wil::com_ptr_nothrow<ID3D11DepthStencilState>> m_om_dss;
+	std::unordered_map<uint32, wil::com_ptr_nothrow<ID3D11BlendState>> m_om_bs;
 
 	VSConstantBuffer m_vs_cb_cache;
 	GSConstantBuffer m_gs_cb_cache;
@@ -584,13 +581,13 @@ public:
 	void SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel);
 	void SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, uint8 afix);
 
-	ID3D11Device* operator->() { return m_dev; }
-	operator ID3D11Device*() { return m_dev; }
-	operator ID3D11DeviceContext*() { return m_ctx; }
+	ID3D11Device* operator->() { return m_dev.get(); }
+	operator ID3D11Device*() { return m_dev.get(); }
+	operator ID3D11DeviceContext*() { return m_ctx.get(); }
 
 	void CreateShader(const std::vector<char>& source, const char* fn, ID3DInclude* include, const char* entry, D3D_SHADER_MACRO* macro, ID3D11VertexShader** vs, D3D11_INPUT_ELEMENT_DESC* layout, int count, ID3D11InputLayout** il);
 	void CreateShader(const std::vector<char>& source, const char* fn, ID3DInclude* include, const char* entry, D3D_SHADER_MACRO* macro, ID3D11GeometryShader** gs);
 	void CreateShader(const std::vector<char>& source, const char* fn, ID3DInclude* include, const char* entry, D3D_SHADER_MACRO* macro, ID3D11PixelShader** ps);
 
-	void CompileShader(const std::vector<char>& source, const char* fn, ID3DInclude* include, const char* entry, D3D_SHADER_MACRO* macro, ID3DBlob** shader, std::string shader_model);
+	void CompileShader(const std::vector<char>& source, const char* fn, ID3DInclude* include, const char* entry, D3D_SHADER_MACRO* macro, ID3DBlob** shader, const std::string& shader_model);
 };
diff --git a/pcsx2/GS/Renderers/DX11/GSTexture11.cpp b/pcsx2/GS/Renderers/DX11/GSTexture11.cpp
index e0a0dec86a..513ed634a5 100644
--- a/pcsx2/GS/Renderers/DX11/GSTexture11.cpp
+++ b/pcsx2/GS/Renderers/DX11/GSTexture11.cpp
@@ -17,15 +17,15 @@
 #include "GSTexture11.h"
 #include "GS/GSPng.h"
 
-GSTexture11::GSTexture11(ID3D11Texture2D* texture)
-	: m_texture(texture), m_layer(0)
+GSTexture11::GSTexture11(wil::com_ptr_nothrow<ID3D11Texture2D> texture)
+	: m_texture(std::move(texture)), m_layer(0)
 {
 	ASSERT(m_texture);
 
-	m_texture->GetDevice(&m_dev);
+	m_texture->GetDevice(m_dev.put());
 	m_texture->GetDesc(&m_desc);
 
-	m_dev->GetImmediateContext(&m_ctx);
+	m_dev->GetImmediateContext(m_ctx.put());
 
 	m_size.x = (int)m_desc.Width;
 	m_size.y = (int)m_desc.Height;
@@ -54,7 +54,7 @@ bool GSTexture11::Update(const GSVector4i& r, const void* data, int pitch, int l
 		D3D11_BOX box = {(UINT)r.left, (UINT)r.top, 0U, (UINT)r.right, (UINT)r.bottom, 1U};
 		UINT subresource = layer; // MipSlice + (ArraySlice * MipLevels).
 
-		m_ctx->UpdateSubresource(m_texture, subresource, &box, data, pitch, 0);
+		m_ctx->UpdateSubresource(m_texture.get(), subresource, &box, data, pitch, 0);
 
 		return true;
 	}
@@ -78,7 +78,7 @@ bool GSTexture11::Map(GSMap& m, const GSVector4i* r, int layer)
 		D3D11_MAPPED_SUBRESOURCE map;
 		UINT subresource = layer;
 
-		if (SUCCEEDED(m_ctx->Map(m_texture, subresource, D3D11_MAP_READ_WRITE, 0, &map)))
+		if (SUCCEEDED(m_ctx->Map(m_texture.get(), subresource, D3D11_MAP_READ_WRITE, 0, &map)))
 		{
 			m.bits = (uint8*)map.pData;
 			m.pitch = (int)map.RowPitch;
@@ -97,13 +97,12 @@ void GSTexture11::Unmap()
 	if (m_texture)
 	{
 		UINT subresource = m_layer;
-		m_ctx->Unmap(m_texture, subresource);
+		m_ctx->Unmap(m_texture.get(), subresource);
 	}
 }
 
 bool GSTexture11::Save(const std::string& fn)
 {
-	CComPtr<ID3D11Texture2D> res;
 	D3D11_TEXTURE2D_DESC desc;
 
 	m_texture->GetDesc(&desc);
@@ -112,22 +111,22 @@ bool GSTexture11::Save(const std::string& fn)
 	desc.BindFlags = 0;
 	desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
 
-	HRESULT hr = m_dev->CreateTexture2D(&desc, nullptr, &res);
+	wil::com_ptr_nothrow<ID3D11Texture2D> res;
+	HRESULT hr = m_dev->CreateTexture2D(&desc, nullptr, res.put());
 	if (FAILED(hr))
 	{
 		return false;
 	}
 
-	m_ctx->CopyResource(res, m_texture);
+	m_ctx->CopyResource(res.get(), m_texture.get());
 
 	if (m_desc.BindFlags & D3D11_BIND_DEPTH_STENCIL)
 	{
-		CComPtr<ID3D11Texture2D> dst;
-
 		desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
 		desc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE;
 
-		hr = m_dev->CreateTexture2D(&desc, nullptr, &dst);
+		wil::com_ptr_nothrow<ID3D11Texture2D> dst;
+		hr = m_dev->CreateTexture2D(&desc, nullptr, dst.put());
 		if (FAILED(hr))
 		{
 			return false;
@@ -135,17 +134,23 @@ bool GSTexture11::Save(const std::string& fn)
 
 		D3D11_MAPPED_SUBRESOURCE sm, dm;
 
-		hr = m_ctx->Map(res, 0, D3D11_MAP_READ, 0, &sm);
+		hr = m_ctx->Map(res.get(), 0, D3D11_MAP_READ, 0, &sm);
 		if (FAILED(hr))
 		{
 			return false;
 		}
-		hr = m_ctx->Map(dst, 0, D3D11_MAP_WRITE, 0, &dm);
+		auto unmap_res = wil::scope_exit([&]{
+			m_ctx->Unmap(res.get(), 0);
+		});
+
+		hr = m_ctx->Map(dst.get(), 0, D3D11_MAP_WRITE, 0, &dm);
 		if (FAILED(hr))
 		{
-			m_ctx->Unmap(res, 0);
 			return false;
 		}
+		auto unmap_dst = wil::scope_exit([&]{
+			m_ctx->Unmap(dst.get(), 0);
+		});
 
 		uint8* s = static_cast<uint8*>(sm.pData);
 		uint8* d = static_cast<uint8*>(dm.pData);
@@ -158,10 +163,7 @@ bool GSTexture11::Save(const std::string& fn)
 			}
 		}
 
-		m_ctx->Unmap(res, 0);
-		m_ctx->Unmap(dst, 0);
-
-		res = dst;
+		res = std::move(dst);
 	}
 
 	res->GetDesc(&desc);
@@ -184,7 +186,7 @@ bool GSTexture11::Save(const std::string& fn)
 	}
 
 	D3D11_MAPPED_SUBRESOURCE sm;
-	hr = m_ctx->Map(res, 0, D3D11_MAP_READ, 0, &sm);
+	hr = m_ctx->Map(res.get(), 0, D3D11_MAP_READ, 0, &sm);
 	if (FAILED(hr))
 	{
 		return false;
@@ -193,14 +195,14 @@ bool GSTexture11::Save(const std::string& fn)
 	int compression = theApp.GetConfigI("png_compression_level");
 	bool success = GSPng::Save(format, fn, static_cast<uint8*>(sm.pData), desc.Width, desc.Height, sm.RowPitch, compression);
 
-	m_ctx->Unmap(res, 0);
+	m_ctx->Unmap(res.get(), 0);
 
 	return success;
 }
 
 GSTexture11::operator ID3D11Texture2D*()
 {
-	return m_texture;
+	return m_texture.get();
 }
 
 GSTexture11::operator ID3D11ShaderResourceView*()
@@ -215,15 +217,15 @@ GSTexture11::operator ID3D11ShaderResourceView*()
 			srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
 			srvd.Texture2D.MipLevels = 1;
 
-			m_dev->CreateShaderResourceView(m_texture, &srvd, &m_srv);
+			m_dev->CreateShaderResourceView(m_texture.get(), &srvd, m_srv.put());
 		}
 		else
 		{
-			m_dev->CreateShaderResourceView(m_texture, NULL, &m_srv);
+			m_dev->CreateShaderResourceView(m_texture.get(), nullptr, m_srv.put());
 		}
 	}
 
-	return m_srv;
+	return m_srv.get();
 }
 
 GSTexture11::operator ID3D11RenderTargetView*()
@@ -232,10 +234,10 @@ GSTexture11::operator ID3D11RenderTargetView*()
 
 	if (!m_rtv && m_dev && m_texture)
 	{
-		m_dev->CreateRenderTargetView(m_texture, NULL, &m_rtv);
+		m_dev->CreateRenderTargetView(m_texture.get(), nullptr, m_rtv.put());
 	}
 
-	return m_rtv;
+	return m_rtv.get();
 }
 
 GSTexture11::operator ID3D11DepthStencilView*()
@@ -249,15 +251,15 @@ GSTexture11::operator ID3D11DepthStencilView*()
 			dsvd.Format = DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
 			dsvd.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
 
-			m_dev->CreateDepthStencilView(m_texture, &dsvd, &m_dsv);
+			m_dev->CreateDepthStencilView(m_texture.get(), &dsvd, m_dsv.put());
 		}
 		else
 		{
-			m_dev->CreateDepthStencilView(m_texture, NULL, &m_dsv);
+			m_dev->CreateDepthStencilView(m_texture.get(), nullptr, m_dsv.put());
 		}
 	}
 
-	return m_dsv;
+	return m_dsv.get();
 }
 
 bool GSTexture11::Equal(GSTexture11* tex)
diff --git a/pcsx2/GS/Renderers/DX11/GSTexture11.h b/pcsx2/GS/Renderers/DX11/GSTexture11.h
index 649e0278d3..1f470a35f8 100644
--- a/pcsx2/GS/Renderers/DX11/GSTexture11.h
+++ b/pcsx2/GS/Renderers/DX11/GSTexture11.h
@@ -17,22 +17,23 @@
 
 #include "GS.h"
 #include "GS/Renderers/Common/GSTexture.h"
+#include <wil/com.h>
 
 class GSTexture11 : public GSTexture
 {
-	CComPtr<ID3D11Device> m_dev;
-	CComPtr<ID3D11DeviceContext> m_ctx;
-	CComPtr<ID3D11Texture2D> m_texture;
+	wil::com_ptr_nothrow<ID3D11Device> m_dev;
+	wil::com_ptr_nothrow<ID3D11DeviceContext> m_ctx;
+	wil::com_ptr_nothrow<ID3D11Texture2D> m_texture;
 	D3D11_TEXTURE2D_DESC m_desc;
-	CComPtr<ID3D11ShaderResourceView> m_srv;
-	CComPtr<ID3D11RenderTargetView> m_rtv;
-	CComPtr<ID3D11DepthStencilView> m_dsv;
+	wil::com_ptr_nothrow<ID3D11ShaderResourceView> m_srv;
+	wil::com_ptr_nothrow<ID3D11RenderTargetView> m_rtv;
+	wil::com_ptr_nothrow<ID3D11DepthStencilView> m_dsv;
 
 	int m_layer;
 	int m_max_layer;
 
 public:
-	explicit GSTexture11(ID3D11Texture2D* texture);
+	explicit GSTexture11(wil::com_ptr_nothrow<ID3D11Texture2D> texture);
 
 	bool Update(const GSVector4i& r, const void* data, int pitch, int layer = 0);
 	bool Map(GSMap& m, const GSVector4i* r = NULL, int layer = 0);
diff --git a/pcsx2/GS/Renderers/DX11/GSTextureFX11.cpp b/pcsx2/GS/Renderers/DX11/GSTextureFX11.cpp
index 4eb82e3c66..a45ad36ece 100644
--- a/pcsx2/GS/Renderers/DX11/GSTextureFX11.cpp
+++ b/pcsx2/GS/Renderers/DX11/GSTextureFX11.cpp
@@ -30,7 +30,7 @@ bool GSDevice11::CreateTextureFX()
 	bd.Usage = D3D11_USAGE_DEFAULT;
 	bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 
-	hr = m_dev->CreateBuffer(&bd, NULL, &m_vs_cb);
+	hr = m_dev->CreateBuffer(&bd, nullptr, m_vs_cb.put());
 
 	if (FAILED(hr))
 		return false;
@@ -41,7 +41,7 @@ bool GSDevice11::CreateTextureFX()
 	bd.Usage = D3D11_USAGE_DEFAULT;
 	bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 
-	hr = m_dev->CreateBuffer(&bd, NULL, &m_gs_cb);
+	hr = m_dev->CreateBuffer(&bd, nullptr, m_gs_cb.put());
 
 	if (FAILED(hr))
 		return false;
@@ -52,7 +52,7 @@ bool GSDevice11::CreateTextureFX()
 	bd.Usage = D3D11_USAGE_DEFAULT;
 	bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
 
-	hr = m_dev->CreateBuffer(&bd, NULL, &m_ps_cb);
+	hr = m_dev->CreateBuffer(&bd, nullptr, m_ps_cb.put());
 
 	if (FAILED(hr))
 		return false;
@@ -70,7 +70,7 @@ bool GSDevice11::CreateTextureFX()
 	sd.MaxAnisotropy = D3D11_MIN_MAXANISOTROPY;
 	sd.ComparisonFunc = D3D11_COMPARISON_NEVER;
 
-	hr = m_dev->CreateSamplerState(&sd, &m_palette_ss);
+	hr = m_dev->CreateSamplerState(&sd, m_palette_ss.put());
 
 	if (FAILED(hr))
 		return false;
@@ -117,28 +117,26 @@ void GSDevice11::SetupVS(VSSelector sel, const VSConstantBuffer* cb)
 
 		std::vector<char> shader;
 		theApp.LoadResource(IDR_TFX_FX, shader);
-		CreateShader(shader, "tfx.fx", nullptr, "vs_main", sm.GetPtr(), &vs.vs, layout, countof(layout), &vs.il);
+		CreateShader(shader, "tfx.fx", nullptr, "vs_main", sm.GetPtr(), &vs.vs, layout, countof(layout), vs.il.put());
 
 		m_vs[sel] = vs;
 
-		i = m_vs.find(sel);
+		i = m_vs.try_emplace(sel, std::move(vs)).first;
 	}
 
 	if (m_vs_cb_cache.Update(cb))
 	{
-		ID3D11DeviceContext* ctx = m_ctx;
-
-		ctx->UpdateSubresource(m_vs_cb, 0, NULL, cb, 0, 0);
+		m_ctx->UpdateSubresource(m_vs_cb.get(), 0, NULL, cb, 0, 0);
 	}
 
-	VSSetShader(i->second.vs, m_vs_cb);
+	VSSetShader(i->second.vs.get(), m_vs_cb.get());
 
-	IASetInputLayout(i->second.il);
+	IASetInputLayout(i->second.il.get());
 }
 
 void GSDevice11::SetupGS(GSSelector sel, const GSConstantBuffer* cb)
 {
-	CComPtr<ID3D11GeometryShader> gs;
+	wil::com_ptr_nothrow<ID3D11GeometryShader> gs;
 
 	const bool unscale_pt_ln = (sel.point == 1 || sel.line == 1);
 	// Geometry shader is disabled if sprite conversion is done on the cpu (sel.cpu_sprite).
@@ -161,7 +159,7 @@ void GSDevice11::SetupGS(GSSelector sel, const GSConstantBuffer* cb)
 
 			std::vector<char> shader;
 			theApp.LoadResource(IDR_TFX_FX, shader);
-			CreateShader(shader, "tfx.fx", nullptr, "gs_main", sm.GetPtr(), &gs);
+			CreateShader(shader, "tfx.fx", nullptr, "gs_main", sm.GetPtr(), gs.put());
 
 			m_gs[sel] = gs;
 		}
@@ -170,12 +168,10 @@ void GSDevice11::SetupGS(GSSelector sel, const GSConstantBuffer* cb)
 
 	if (m_gs_cb_cache.Update(cb))
 	{
-		ID3D11DeviceContext* ctx = m_ctx;
-
-		ctx->UpdateSubresource(m_gs_cb, 0, NULL, cb, 0, 0);
+		m_ctx->UpdateSubresource(m_gs_cb.get(), 0, NULL, cb, 0, 0);
 	}
 
-	GSSetShader(gs, m_gs_cb);
+	GSSetShader(gs.get(), m_gs_cb.get());
 }
 
 void GSDevice11::SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel)
@@ -221,25 +217,21 @@ void GSDevice11::SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSe
 		sm.AddMacro("PS_DITHER", sel.dither);
 		sm.AddMacro("PS_ZCLAMP", sel.zclamp);
 
-		CComPtr<ID3D11PixelShader> ps;
+		wil::com_ptr_nothrow<ID3D11PixelShader> ps;
 
 		std::vector<char> shader;
 		theApp.LoadResource(IDR_TFX_FX, shader);
-		CreateShader(shader, "tfx.fx", nullptr, "ps_main", sm.GetPtr(), &ps);
+		CreateShader(shader, "tfx.fx", nullptr, "ps_main", sm.GetPtr(), ps.put());
 
-		m_ps[sel] = ps;
-
-		i = m_ps.find(sel);
+		i = m_ps.try_emplace(sel, std::move(ps)).first;
 	}
 
 	if (m_ps_cb_cache.Update(cb))
 	{
-		ID3D11DeviceContext* ctx = m_ctx;
-
-		ctx->UpdateSubresource(m_ps_cb, 0, NULL, cb, 0, 0);
+		m_ctx->UpdateSubresource(m_ps_cb.get(), 0, NULL, cb, 0, 0);
 	}
 
-	CComPtr<ID3D11SamplerState> ss0, ss1;
+	wil::com_ptr_nothrow<ID3D11SamplerState> ss0, ss1;
 
 	if (sel.tfx != 4)
 	{
@@ -282,9 +274,9 @@ void GSDevice11::SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSe
 		}
 	}
 
-	PSSetSamplerState(ss0, ss1);
+	PSSetSamplerState(ss0.get(), ss1.get());
 
-	PSSetShader(i->second, m_ps_cb);
+	PSSetShader(i->second.get(), m_ps_cb.get());
 }
 
 void GSDevice11::SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, uint8 afix)
@@ -327,16 +319,13 @@ void GSDevice11::SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, uin
 			dsd.DepthFunc = ztst[dssel.ztst];
 		}
 
-		CComPtr<ID3D11DepthStencilState> dss;
+		wil::com_ptr_nothrow<ID3D11DepthStencilState> dss;
+		m_dev->CreateDepthStencilState(&dsd, dss.put());
 
-		m_dev->CreateDepthStencilState(&dsd, &dss);
-
-		m_om_dss[dssel] = dss;
-
-		i = m_om_dss.find(dssel);
+		i = m_om_dss.try_emplace(dssel, std::move(dss)).first;
 	}
 
-	OMSetDepthStencilState(i->second, 1);
+	OMSetDepthStencilState(i->second.get(), 1);
 
 	auto j = std::as_const(m_om_bs).find(bsel);
 
@@ -369,14 +358,11 @@ void GSDevice11::SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, uin
 		if (bsel.wb) bd.RenderTarget[0].RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_BLUE;
 		if (bsel.wa) bd.RenderTarget[0].RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_ALPHA;
 
-		CComPtr<ID3D11BlendState> bs;
+		wil::com_ptr_nothrow<ID3D11BlendState> bs;
+		m_dev->CreateBlendState(&bd, bs.put());
 
-		m_dev->CreateBlendState(&bd, &bs);
-
-		m_om_bs[bsel] = bs;
-
-		j = m_om_bs.find(bsel);
+		j = m_om_bs.try_emplace(bsel, std::move(bs)).first;
 	}
 
-	OMSetBlendState(j->second, (float)(int)afix / 0x80);
+	OMSetBlendState(j->second.get(), (float)(int)afix / 0x80);
 }
diff --git a/pcsx2/GS/Window/GSSettingsDlg.cpp b/pcsx2/GS/Window/GSSettingsDlg.cpp
index c2001be372..c002399928 100644
--- a/pcsx2/GS/Window/GSSettingsDlg.cpp
+++ b/pcsx2/GS/Window/GSSettingsDlg.cpp
@@ -21,6 +21,7 @@
 #include "GS/resource.h"
 #include "GSSetting.h"
 #include <algorithm>
+#include <wil/com.h>
 
 GSSettingsDlg::GSSettingsDlg()
 	: GSDialog(IDD_CONFIG)
@@ -41,8 +42,8 @@ GSSettingsDlg::GSSettingsDlg()
 
 std::vector<GSSettingsDlg::Adapter> GSSettingsDlg::EnumerateD3D11Adapters()
 {
-	CComPtr<IDXGIFactory1> dxgi_factory;
-	CreateDXGIFactory1(IID_PPV_ARGS(&dxgi_factory));
+	wil::com_ptr_nothrow<IDXGIFactory1> dxgi_factory;
+	CreateDXGIFactory1(IID_PPV_ARGS(dxgi_factory.put()));
 	if (dxgi_factory == nullptr)
 		return {};
 
@@ -53,19 +54,15 @@ std::vector<GSSettingsDlg::Adapter> GSSettingsDlg::EnumerateD3D11Adapters()
 #endif
 	};
 
-	CComPtr<IDXGIAdapter1> adapter;
-	for (int i = 0; dxgi_factory->EnumAdapters1(i, &adapter) == S_OK; ++i, adapter = nullptr)
+	wil::com_ptr_nothrow<IDXGIAdapter1> adapter;
+	for (int i = 0; SUCCEEDED(dxgi_factory->EnumAdapters1(i, adapter.put())); ++i)
 	{
 		DXGI_ADAPTER_DESC1 desc;
-		if (adapter->GetDesc1(&desc) != S_OK)
+		if (FAILED(adapter->GetDesc1(&desc)))
 			continue;
 
-		D3D_FEATURE_LEVEL level = GSUtil::CheckDirect3D11Level(adapter, D3D_DRIVER_TYPE_UNKNOWN);
-
-		const int size = WideCharToMultiByte(CP_ACP, 0, desc.Description, sizeof(desc.Description), nullptr, 0, nullptr, nullptr);
-		std::vector<char> buf(size);
-		WideCharToMultiByte(CP_ACP, 0, desc.Description, sizeof(desc.Description), buf.data(), size, nullptr, nullptr);
-		adapters.push_back({buf.data(), GSAdapter(desc), level});
+		D3D_FEATURE_LEVEL level = GSUtil::CheckDirect3D11Level(adapter.get(), D3D_DRIVER_TYPE_UNKNOWN);
+		adapters.emplace_back(convert_utf16_to_utf8(desc.Description), GSAdapter(desc), level);
 	}
 
 	auto unsupported_adapter = [](const auto& adapter) { return adapter.level < D3D_FEATURE_LEVEL_10_0; };