diff --git a/src/common/d3d11/shader_cache.cpp b/src/common/d3d11/shader_cache.cpp
index 2464b64b2..12286c8e3 100644
--- a/src/common/d3d11/shader_cache.cpp
+++ b/src/common/d3d11/shader_cache.cpp
@@ -2,6 +2,7 @@
 #include "../file_system.h"
 #include "../log.h"
 #include "../md5_digest.h"
+#include "shader_compiler.h"
 #include <d3dcompiler.h>
 Log_SetChannel(D3D11::ShaderCache);
 
@@ -234,15 +235,7 @@ ShaderCache::ComPtr<ID3D11VertexShader> ShaderCache::GetVertexShader(ID3D11Devic
   if (!blob)
     return {};
 
-  ComPtr<ID3D11VertexShader> vs;
-  HRESULT hr = device->CreateVertexShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, vs.GetAddressOf());
-  if (FAILED(hr))
-  {
-    Log_ErrorPrintf("Failed to create vertex shader from blob: 0x%08X", hr);
-    return {};
-  }
-
-  return vs;
+  return D3D11::ShaderCompiler::CreateVertexShader(device, blob.Get());
 }
 
 ShaderCache::ComPtr<ID3D11GeometryShader> ShaderCache::GetGeometryShader(ID3D11Device* device,
@@ -252,16 +245,7 @@ ShaderCache::ComPtr<ID3D11GeometryShader> ShaderCache::GetGeometryShader(ID3D11D
   if (!blob)
     return {};
 
-  ComPtr<ID3D11GeometryShader> gs;
-  HRESULT hr =
-    device->CreateGeometryShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, gs.GetAddressOf());
-  if (FAILED(hr))
-  {
-    Log_ErrorPrintf("Failed to create geometry shader from blob: 0x%08X", hr);
-    return {};
-  }
-
-  return gs;
+  return D3D11::ShaderCompiler::CreateGeometryShader(device, blob.Get());
 }
 
 ShaderCache::ComPtr<ID3D11PixelShader> ShaderCache::GetPixelShader(ID3D11Device* device, std::string_view shader_code)
@@ -270,15 +254,7 @@ ShaderCache::ComPtr<ID3D11PixelShader> ShaderCache::GetPixelShader(ID3D11Device*
   if (!blob)
     return {};
 
-  ComPtr<ID3D11PixelShader> ps;
-  HRESULT hr = device->CreatePixelShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, ps.GetAddressOf());
-  if (FAILED(hr))
-  {
-    Log_ErrorPrintf("Failed to create pixel shader from blob: 0x%08X", hr);
-    return {};
-  }
-
-  return ps;
+  return D3D11::ShaderCompiler::CreatePixelShader(device, blob.Get());
 }
 
 ShaderCache::ComPtr<ID3D11ComputeShader> ShaderCache::GetComputeShader(ID3D11Device* device,
@@ -288,15 +264,7 @@ ShaderCache::ComPtr<ID3D11ComputeShader> ShaderCache::GetComputeShader(ID3D11Dev
   if (!blob)
     return {};
 
-  ComPtr<ID3D11ComputeShader> cs;
-  HRESULT hr = device->CreateComputeShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, cs.GetAddressOf());
-  if (FAILED(hr))
-  {
-    Log_ErrorPrintf("Failed to create compute shader from blob: 0x%08X", hr);
-    return {};
-  }
-
-  return cs;
+  return D3D11::ShaderCompiler::CreateComputeShader(device, blob.Get());
 }
 
 ShaderCache::ComPtr<ID3DBlob> ShaderCache::CompileAndAddShaderBlob(const CacheIndexKey& key,
diff --git a/src/common/d3d11/shader_compiler.cpp b/src/common/d3d11/shader_compiler.cpp
index 84a4153d7..3f225b39a 100644
--- a/src/common/d3d11/shader_compiler.cpp
+++ b/src/common/d3d11/shader_compiler.cpp
@@ -90,9 +90,40 @@ ComPtr<ID3D11VertexShader> CompileAndCreateVertexShader(ID3D11Device* device, st
   if (!blob)
     return {};
 
+  return CreateVertexShader(device, blob.Get());
+}
+
+ComPtr<ID3D11GeometryShader> CompileAndCreateGeometryShader(ID3D11Device* device, std::string_view code, bool debug)
+{
+  ComPtr<ID3DBlob> blob = CompileShader(Type::Geometry, device->GetFeatureLevel(), std::move(code), debug);
+  if (!blob)
+    return {};
+
+  return CreateGeometryShader(device, blob.Get());
+}
+
+ComPtr<ID3D11PixelShader> CompileAndCreatePixelShader(ID3D11Device* device, std::string_view code, bool debug)
+{
+  ComPtr<ID3DBlob> blob = CompileShader(Type::Pixel, device->GetFeatureLevel(), std::move(code), debug);
+  if (!blob)
+    return {};
+
+  return CreatePixelShader(device, blob.Get());
+}
+
+ComPtr<ID3D11ComputeShader> CompileAndCreateComputeShader(ID3D11Device* device, std::string_view code, bool debug)
+{
+  ComPtr<ID3DBlob> blob = CompileShader(Type::Compute, device->GetFeatureLevel(), std::move(code), debug);
+  if (!blob)
+    return {};
+
+  return CreateComputeShader(device, blob.Get());
+}
+
+ComPtr<ID3D11VertexShader> CreateVertexShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length)
+{
   ComPtr<ID3D11VertexShader> shader;
-  const HRESULT hr =
-    device->CreateVertexShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, shader.GetAddressOf());
+  const HRESULT hr = device->CreateVertexShader(bytecode, bytecode_length, nullptr, shader.GetAddressOf());
   if (FAILED(hr))
   {
     Log_ErrorPrintf("Failed to create vertex shader: 0x%08X", hr);
@@ -102,15 +133,16 @@ ComPtr<ID3D11VertexShader> CompileAndCreateVertexShader(ID3D11Device* device, st
   return shader;
 }
 
-ComPtr<ID3D11GeometryShader> CompileAndCreateGeometryShader(ID3D11Device* device, std::string_view code, bool debug)
+ComPtr<ID3D11VertexShader> CreateVertexShader(ID3D11Device* device, const ID3DBlob* blob)
 {
-  ComPtr<ID3DBlob> blob = CompileShader(Type::Geometry, device->GetFeatureLevel(), std::move(code), debug);
-  if (!blob)
-    return {};
+  return CreateVertexShader(device, const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
+                            const_cast<ID3DBlob*>(blob)->GetBufferSize());
+}
 
+ComPtr<ID3D11GeometryShader> CreateGeometryShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length)
+{
   ComPtr<ID3D11GeometryShader> shader;
-  const HRESULT hr =
-    device->CreateGeometryShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, shader.GetAddressOf());
+  const HRESULT hr = device->CreateGeometryShader(bytecode, bytecode_length, nullptr, shader.GetAddressOf());
   if (FAILED(hr))
   {
     Log_ErrorPrintf("Failed to create geometry shader: 0x%08X", hr);
@@ -120,15 +152,16 @@ ComPtr<ID3D11GeometryShader> CompileAndCreateGeometryShader(ID3D11Device* device
   return shader;
 }
 
-ComPtr<ID3D11PixelShader> CompileAndCreatePixelShader(ID3D11Device* device, std::string_view code, bool debug)
+ComPtr<ID3D11GeometryShader> CreateGeometryShader(ID3D11Device* device, const ID3DBlob* blob)
 {
-  ComPtr<ID3DBlob> blob = CompileShader(Type::Pixel, device->GetFeatureLevel(), std::move(code), debug);
-  if (!blob)
-    return {};
+  return CreateGeometryShader(device, const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
+                              const_cast<ID3DBlob*>(blob)->GetBufferSize());
+}
 
+ComPtr<ID3D11PixelShader> CreatePixelShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length)
+{
   ComPtr<ID3D11PixelShader> shader;
-  const HRESULT hr =
-    device->CreatePixelShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, shader.GetAddressOf());
+  const HRESULT hr = device->CreatePixelShader(bytecode, bytecode_length, nullptr, shader.GetAddressOf());
   if (FAILED(hr))
   {
     Log_ErrorPrintf("Failed to create pixel shader: 0x%08X", hr);
@@ -138,15 +171,16 @@ ComPtr<ID3D11PixelShader> CompileAndCreatePixelShader(ID3D11Device* device, std:
   return shader;
 }
 
-ComPtr<ID3D11ComputeShader> CompileAndCreateComputeShader(ID3D11Device* device, std::string_view code, bool debug)
+ComPtr<ID3D11PixelShader> CreatePixelShader(ID3D11Device* device, const ID3DBlob* blob)
 {
-  ComPtr<ID3DBlob> blob = CompileShader(Type::Compute, device->GetFeatureLevel(), std::move(code), debug);
-  if (!blob)
-    return {};
+  return CreatePixelShader(device, const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
+                           const_cast<ID3DBlob*>(blob)->GetBufferSize());
+}
 
+ComPtr<ID3D11ComputeShader> CreateComputeShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length)
+{
   ComPtr<ID3D11ComputeShader> shader;
-  const HRESULT hr =
-    device->CreateComputeShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, shader.GetAddressOf());
+  const HRESULT hr = device->CreateComputeShader(bytecode, bytecode_length, nullptr, shader.GetAddressOf());
   if (FAILED(hr))
   {
     Log_ErrorPrintf("Failed to create compute shader: 0x%08X", hr);
@@ -156,4 +190,10 @@ ComPtr<ID3D11ComputeShader> CompileAndCreateComputeShader(ID3D11Device* device,
   return shader;
 }
 
+ComPtr<ID3D11ComputeShader> CreateComputeShader(ID3D11Device* device, const ID3DBlob* blob)
+{
+  return CreateComputeShader(device, const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
+                             const_cast<ID3DBlob*>(blob)->GetBufferSize());
+}
+
 } // namespace D3D11::ShaderCompiler
\ No newline at end of file
diff --git a/src/common/d3d11/shader_compiler.h b/src/common/d3d11/shader_compiler.h
index 162b0c584..f5e23dafc 100644
--- a/src/common/d3d11/shader_compiler.h
+++ b/src/common/d3d11/shader_compiler.h
@@ -24,4 +24,13 @@ ComPtr<ID3D11GeometryShader> CompileAndCreateGeometryShader(ID3D11Device* device
 ComPtr<ID3D11PixelShader> CompileAndCreatePixelShader(ID3D11Device* device, std::string_view code, bool debug);
 ComPtr<ID3D11ComputeShader> CompileAndCreateComputeShader(ID3D11Device* device, std::string_view code, bool debug);
 
+ComPtr<ID3D11VertexShader> CreateVertexShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length);
+ComPtr<ID3D11VertexShader> CreateVertexShader(ID3D11Device* device, const ID3DBlob* blob);
+ComPtr<ID3D11GeometryShader> CreateGeometryShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length);
+ComPtr<ID3D11GeometryShader> CreateGeometryShader(ID3D11Device* device, const ID3DBlob* blob);
+ComPtr<ID3D11PixelShader> CreatePixelShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length);
+ComPtr<ID3D11PixelShader> CreatePixelShader(ID3D11Device* device, const ID3DBlob* blob);
+ComPtr<ID3D11ComputeShader> CreateComputeShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length);
+ComPtr<ID3D11ComputeShader> CreateComputeShader(ID3D11Device* device, const ID3DBlob* blob);
+
 }; // namespace D3D11::ShaderCompiler