diff --git a/OptiScaler/Config.h b/OptiScaler/Config.h
index c1bdb39d..36146c5b 100644
--- a/OptiScaler/Config.h
+++ b/OptiScaler/Config.h
@@ -352,7 +352,7 @@ class Config
     CustomOptional<bool> RestoreComputeSignature { false };
     CustomOptional<bool> RestoreGraphicSignature { false };
 
-    CustomOptional<bool> UsePrecompiledShaders { true };
+    CustomOptional<bool> UsePrecompiledShaders { false };
 
     CustomOptional<bool> UseGenericAppIdWithDlss { false };
     CustomOptional<bool> PreferDedicatedGpu { true };
diff --git a/OptiScaler/shaders/Shader_Dx12.cpp b/OptiScaler/shaders/Shader_Dx12.cpp
index 493756ee..10322d21 100644
--- a/OptiScaler/shaders/Shader_Dx12.cpp
+++ b/OptiScaler/shaders/Shader_Dx12.cpp
@@ -54,12 +54,17 @@ DXGI_FORMAT Shader_Dx12::TranslateTypelessFormats(DXGI_FORMAT format)
 }
 
 bool Shader_Dx12::CreateComputeShader(ID3D12Device* device, ID3D12RootSignature* rootSignature,
-                                      ID3D12PipelineState** pipelineState, ID3DBlob* shaderBlob)
+                                      ID3D12PipelineState** pipelineState, ID3DBlob* shaderBlob,
+                                      D3D12_SHADER_BYTECODE byteCode)
 {
     D3D12_COMPUTE_PIPELINE_STATE_DESC psoDesc = {};
     psoDesc.pRootSignature = rootSignature;
     psoDesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
-    psoDesc.CS = CD3DX12_SHADER_BYTECODE(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize());
+
+    if (shaderBlob != nullptr)
+        psoDesc.CS = CD3DX12_SHADER_BYTECODE(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize());
+    else
+        psoDesc.CS = byteCode;
 
     HRESULT hr = device->CreateComputePipelineState(&psoDesc, __uuidof(ID3D12PipelineState*), (void**) pipelineState);
 
diff --git a/OptiScaler/shaders/Shader_Dx12.h b/OptiScaler/shaders/Shader_Dx12.h
index bf8288c2..73a7a86e 100644
--- a/OptiScaler/shaders/Shader_Dx12.h
+++ b/OptiScaler/shaders/Shader_Dx12.h
@@ -16,7 +16,8 @@ class Shader_Dx12
 
     static DXGI_FORMAT TranslateTypelessFormats(DXGI_FORMAT format);
     static bool CreateComputeShader(ID3D12Device* device, ID3D12RootSignature* rootSignature,
-                                    ID3D12PipelineState** pipelineState, ID3DBlob* shaderBlob);
+                                    ID3D12PipelineState** pipelineState, ID3DBlob* shaderBlob,
+                                    D3D12_SHADER_BYTECODE byteCode);
     static bool CreateBufferResource(ID3D12Device* InDevice, ID3D12Resource* InResource, D3D12_RESOURCE_STATES InState,
                                      ID3D12Resource** OutResource, D3D12_RESOURCE_FLAGS ResourceFlags,
                                      uint64_t InWidth = 0, uint32_t InHeight = 0,
@@ -28,4 +29,4 @@ class Shader_Dx12
     bool IsInit() const { return _init; }
 
     Shader_Dx12(std::string InName, ID3D12Device* InDevice);
-};
\ No newline at end of file
+};
diff --git a/OptiScaler/shaders/bias/Bias_Dx11.cpp b/OptiScaler/shaders/bias/Bias_Dx11.cpp
index 1f311199..4d85e653 100644
--- a/OptiScaler/shaders/bias/Bias_Dx11.cpp
+++ b/OptiScaler/shaders/bias/Bias_Dx11.cpp
@@ -210,15 +210,22 @@ Bias_Dx11::Bias_Dx11(std::string InName, ID3D11Device* InDevice) : _name(InName)
     {
         // Compile shader blobs
         ID3DBlob* shaderBlob = Bias_CompileShader(biasShader.c_str(), "CSMain", "cs_5_0");
+
+        HRESULT hr = E_FAIL;
+
         if (shaderBlob == nullptr)
         {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
-        // create pso objects
-        auto hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
-                                               &_computeShader);
+            hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bias_cso), sizeof(bias_cso), nullptr,
+                                              &_computeShader);
+        }
+        else
+        {
+            // create pso objects
+            hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
+                                              &_computeShader);
+        }
 
         if (shaderBlob != nullptr)
         {
diff --git a/OptiScaler/shaders/bias/Bias_Dx12.cpp b/OptiScaler/shaders/bias/Bias_Dx12.cpp
index a104e598..4e5fb770 100644
--- a/OptiScaler/shaders/bias/Bias_Dx12.cpp
+++ b/OptiScaler/shaders/bias/Bias_Dx12.cpp
@@ -220,13 +220,12 @@ Bias_Dx12::Bias_Dx12(std::string InName, ID3D12Device* InDevice) : Shader_Dx12(I
         ID3DBlob* _recEncodeShader = Bias_CompileShader(biasShader.c_str(), "CSMain", "cs_5_0");
 
         if (_recEncodeShader == nullptr)
-        {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
         // create pso objects
-        if (!Shader_Dx12::CreateComputeShader(InDevice, _rootSignature, &_pipelineState, _recEncodeShader))
+        if (!Shader_Dx12::CreateComputeShader(
+                InDevice, _rootSignature, &_pipelineState, _recEncodeShader,
+                CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bias_cso), sizeof(bias_cso))))
         {
             LOG_ERROR("[{0}] CreateComputeShader error!", _name);
             return;
diff --git a/OptiScaler/shaders/depth_invert/DI_Dx12.cpp b/OptiScaler/shaders/depth_invert/DI_Dx12.cpp
index 6e013d1d..c3302721 100644
--- a/OptiScaler/shaders/depth_invert/DI_Dx12.cpp
+++ b/OptiScaler/shaders/depth_invert/DI_Dx12.cpp
@@ -170,15 +170,15 @@ DI_Dx12::DI_Dx12(std::string InName, ID3D12Device* InDevice) : Shader_Dx12(InNam
         _recEncodeShader = DI_CompileShader(shaderCode.c_str(), "CSMain", "cs_5_0");
 
         if (_recEncodeShader == nullptr)
-        {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
         // create pso objects
-        if (!Shader_Dx12::CreateComputeShader(InDevice, _rootSignature, &_pipelineState, _recEncodeShader))
+        if (!Shader_Dx12::CreateComputeShader(
+                InDevice, _rootSignature, &_pipelineState, _recEncodeShader,
+                CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(DI_cso), sizeof(DI_cso))))
         {
             LOG_ERROR("[{0}] CreateComputeShader error!", _name);
+
             return;
         }
 
diff --git a/OptiScaler/shaders/depth_scale/DS_Dx12.cpp b/OptiScaler/shaders/depth_scale/DS_Dx12.cpp
index 569b0dbb..b32c3f94 100644
--- a/OptiScaler/shaders/depth_scale/DS_Dx12.cpp
+++ b/OptiScaler/shaders/depth_scale/DS_Dx12.cpp
@@ -233,13 +233,12 @@ DS_Dx12::DS_Dx12(std::string InName, ID3D12Device* InDevice) : Shader_Dx12(InNam
         _recEncodeShader = DS_CompileShader(shaderCode.c_str(), "CSMain", "cs_5_0");
 
         if (_recEncodeShader == nullptr)
-        {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
         // create pso objects
-        if (!Shader_Dx12::CreateComputeShader(InDevice, _rootSignature, &_pipelineState, _recEncodeShader))
+        if (!Shader_Dx12::CreateComputeShader(
+                InDevice, _rootSignature, &_pipelineState, _recEncodeShader,
+                CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(DS_cso), sizeof(DS_cso))))
         {
             LOG_ERROR("[{0}] CreateComputeShader error!", _name);
             return;
diff --git a/OptiScaler/shaders/depth_transfer/DT_Dx11.cpp b/OptiScaler/shaders/depth_transfer/DT_Dx11.cpp
index c0040d9f..d2214a9a 100644
--- a/OptiScaler/shaders/depth_transfer/DT_Dx11.cpp
+++ b/OptiScaler/shaders/depth_transfer/DT_Dx11.cpp
@@ -159,15 +159,19 @@ DepthTransfer_Dx11::DepthTransfer_Dx11(std::string InName, ID3D11Device* InDevic
     {
         // Compile shader blobs
         ID3DBlob* shaderBlob = DT_CompileShader(shaderCode.c_str(), "CSMain", "cs_5_0");
+
         if (shaderBlob == nullptr)
-        {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
         // create pso objects
-        auto hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
-                                               &_computeShader);
+        HRESULT hr = E_FAIL;
+
+        if (shaderBlob != nullptr)
+            hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
+                                              &_computeShader);
+        else
+            hr = _device->CreateComputeShader(reinterpret_cast<const void*>(dt_dx11_cso), sizeof(dt_dx11_cso), nullptr,
+                                              &_computeShader);
 
         if (shaderBlob != nullptr)
         {
diff --git a/OptiScaler/shaders/format_transfer/FT_Dx12.cpp b/OptiScaler/shaders/format_transfer/FT_Dx12.cpp
index cc53fe60..71e53995 100644
--- a/OptiScaler/shaders/format_transfer/FT_Dx12.cpp
+++ b/OptiScaler/shaders/format_transfer/FT_Dx12.cpp
@@ -206,13 +206,12 @@ FT_Dx12::FT_Dx12(std::string InName, ID3D12Device* InDevice, DXGI_FORMAT InForma
         _recEncodeShader = FT_CompileShader(FT_ShaderCode.c_str(), "CSMain", "cs_5_0");
 
         if (_recEncodeShader == nullptr)
-        {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
         // create pso objects
-        if (!Shader_Dx12::CreateComputeShader(InDevice, _rootSignature, &_pipelineState, _recEncodeShader))
+        if (!Shader_Dx12::CreateComputeShader(
+                InDevice, _rootSignature, &_pipelineState, _recEncodeShader,
+                CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(FT_cso), sizeof(FT_cso))))
         {
             LOG_ERROR("[{0}] CreateComputeShader error!", _name);
             return;
diff --git a/OptiScaler/shaders/hud_copy/HudCopy_Dx12.cpp b/OptiScaler/shaders/hud_copy/HudCopy_Dx12.cpp
index 08ecec81..78a28ee1 100644
--- a/OptiScaler/shaders/hud_copy/HudCopy_Dx12.cpp
+++ b/OptiScaler/shaders/hud_copy/HudCopy_Dx12.cpp
@@ -248,13 +248,12 @@ HudCopy_Dx12::HudCopy_Dx12(std::string InName, ID3D12Device* InDevice) : Shader_
         _recEncodeShader = HudCopy_CompileShader(shaderCode.c_str(), "CSMain", "cs_5_0");
 
         if (_recEncodeShader == nullptr)
-        {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
         // create pso objects
-        if (!Shader_Dx12::CreateComputeShader(InDevice, _rootSignature, &_pipelineState, _recEncodeShader))
+        if (!Shader_Dx12::CreateComputeShader(
+                InDevice, _rootSignature, &_pipelineState, _recEncodeShader,
+                CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(HudCopy_cso), sizeof(HudCopy_cso))))
         {
             LOG_ERROR("[{0}] CreateComputeShader error!", _name);
             return;
diff --git a/OptiScaler/shaders/hudless_compare/HC_Dx12.cpp b/OptiScaler/shaders/hudless_compare/HC_Dx12.cpp
index 963e4bb3..508d72d1 100644
--- a/OptiScaler/shaders/hudless_compare/HC_Dx12.cpp
+++ b/OptiScaler/shaders/hudless_compare/HC_Dx12.cpp
@@ -136,10 +136,16 @@ HC_Dx12::HC_Dx12(std::string InName, ID3D12Device* InDevice) : Shader_Dx12(InNam
         vs = HC_CompileShader(hcCode.c_str(), "VSMain", "vs_5_1");
         if (vs != nullptr)
             graphicsPsoDesc.VS = { vs->GetBufferPointer(), vs->GetBufferSize() };
+        else
+            graphicsPsoDesc.VS = CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(hudless_compare_VS_cso),
+                                                         sizeof(hudless_compare_VS_cso));
 
         ps = HC_CompileShader(hcCode.c_str(), "PSMain", "ps_5_1");
         if (ps != nullptr)
             graphicsPsoDesc.PS = { ps->GetBufferPointer(), ps->GetBufferSize() };
+        else
+            graphicsPsoDesc.PS = CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(hudless_compare_PS_cso),
+                                                         sizeof(hudless_compare_PS_cso));
     }
 
     graphicsPsoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
diff --git a/OptiScaler/shaders/output_scaling/OS_Dx11.cpp b/OptiScaler/shaders/output_scaling/OS_Dx11.cpp
index 86e819c4..4e760786 100644
--- a/OptiScaler/shaders/output_scaling/OS_Dx11.cpp
+++ b/OptiScaler/shaders/output_scaling/OS_Dx11.cpp
@@ -367,15 +367,61 @@ OS_Dx11::OS_Dx11(std::string InName, ID3D11Device* InDevice, bool InUpsample)
             }
         }
 
-        if (shaderBlob == nullptr)
+        HRESULT hr = E_FAIL;
+
+        if (shaderBlob != nullptr)
+        {
+            // create pso objects
+            auto hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
+                                                   &_computeShader);
+        }
+        else
         {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
-        // create pso objects
-        auto hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
-                                               &_computeShader);
+            switch (Config::Instance()->OutputScalingDownscaler.value_or_default())
+            {
+            case Scaler::Bicubic:
+                hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bcds_bicubic_cso),
+                                                  sizeof(bcds_bicubic_cso), nullptr, &_computeShader);
+                break;
+
+            case Scaler::CatmullRom:
+                hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bcds_catmull_cso),
+                                                  sizeof(bcds_catmull_cso), nullptr, &_computeShader);
+                break;
+
+            case Scaler::Lanczos2:
+                hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bcds_lanczos2_cso),
+                                                  sizeof(bcds_lanczos2_cso), nullptr, &_computeShader);
+                break;
+
+            case Scaler::Lanczos3:
+                hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bcds_lanczos3_cso),
+                                                  sizeof(bcds_lanczos3_cso), nullptr, &_computeShader);
+                break;
+
+            case Scaler::Kaiser2:
+                hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bcds_kaiser2_cso),
+                                                  sizeof(bcds_kaiser2_cso), nullptr, &_computeShader);
+                break;
+
+            case Scaler::Kaiser3:
+                hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bcds_kaiser3_cso),
+                                                  sizeof(bcds_kaiser3_cso), nullptr, &_computeShader);
+                break;
+
+            case Scaler::Magic:
+                hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bcds_magc_cso), sizeof(bcds_magc_cso),
+                                                  nullptr, &_computeShader);
+                break;
+
+            default:
+                hr = _device->CreateComputeShader(reinterpret_cast<const void*>(bcds_bicubic_cso),
+                                                  sizeof(bcds_bicubic_cso), nullptr, &_computeShader);
+                break;
+            }
+        }
 
         if (shaderBlob != nullptr)
         {
diff --git a/OptiScaler/shaders/output_scaling/OS_Dx12.cpp b/OptiScaler/shaders/output_scaling/OS_Dx12.cpp
index 77d80db5..d0d918cd 100644
--- a/OptiScaler/shaders/output_scaling/OS_Dx12.cpp
+++ b/OptiScaler/shaders/output_scaling/OS_Dx12.cpp
@@ -335,10 +335,12 @@ OS_Dx12::OS_Dx12(std::string InName, ID3D12Device* InDevice, bool InUpsample)
     {
         // Compile shader blobs
         ID3DBlob* _recEncodeShader = nullptr;
+        D3D12_SHADER_BYTECODE byteCode = {};
 
         if (_upsample)
         {
             _recEncodeShader = OS_CompileShader(upsampleCode.c_str(), "CSMain", "cs_5_0");
+            byteCode = CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcus_cso), sizeof(bcus_cso));
         }
         else
         {
@@ -349,46 +351,65 @@ OS_Dx12::OS_Dx12(std::string InName, ID3D12Device* InDevice, bool InUpsample)
             {
             case Scaler::Bicubic:
                 _recEncodeShader = OS_CompileShader(downsampleCodeBC.c_str(), "CSMain", "cs_5_0");
+                byteCode =
+                    CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcds_bicubic_cso), sizeof(bcds_bicubic_cso));
+
                 break;
 
             case Scaler::CatmullRom:
                 _recEncodeShader = OS_CompileShader(downsampleCodeCatmull.c_str(), "CSMain", "cs_5_0");
+                byteCode =
+                    CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcds_catmull_cso), sizeof(bcds_catmull_cso));
+
                 break;
 
             case Scaler::Lanczos2:
                 _recEncodeShader = OS_CompileShader(downsampleCodeLanczos2.c_str(), "CSMain", "cs_5_0");
+                byteCode = CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcds_lanczos2_cso),
+                                                   sizeof(bcds_lanczos2_cso));
+
                 break;
 
             case Scaler::Lanczos3:
                 _recEncodeShader = OS_CompileShader(downsampleCodeLanczos3.c_str(), "CSMain", "cs_5_0");
+                byteCode = CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcds_lanczos3_cso),
+                                                   sizeof(bcds_lanczos3_cso));
+
                 break;
 
             case Scaler::Kaiser2:
                 _recEncodeShader = OS_CompileShader(downsampleCodeKaiser2.c_str(), "CSMain", "cs_5_0");
+                byteCode =
+                    CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcds_kaiser2_cso), sizeof(bcds_kaiser2_cso));
                 break;
 
             case Scaler::Kaiser3:
                 _recEncodeShader = OS_CompileShader(downsampleCodeKaiser3.c_str(), "CSMain", "cs_5_0");
+                byteCode =
+                    CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcds_kaiser3_cso), sizeof(bcds_kaiser3_cso));
+
                 break;
 
             case Scaler::Magic:
                 _recEncodeShader = OS_CompileShader(downsampleCodeMAGIC.c_str(), "CSMain", "cs_5_0");
+                byteCode = CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcds_magc_cso), sizeof(bcds_magc_cso));
+
                 break;
 
             default:
                 _recEncodeShader = OS_CompileShader(downsampleCodeBC.c_str(), "CSMain", "cs_5_0");
+                byteCode =
+                    CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(bcds_bicubic_cso), sizeof(bcds_bicubic_cso));
+
                 break;
             }
         }
 
         if (_recEncodeShader == nullptr)
-        {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
         // create pso objects
-        if (!Shader_Dx12::CreateComputeShader(InDevice, _rootSignature, &_pipelineState, _recEncodeShader))
+        if (!Shader_Dx12::CreateComputeShader(InDevice, _rootSignature, &_pipelineState, _recEncodeShader, byteCode))
         {
             LOG_ERROR("[{0}] CreateComputeShader error!", _name);
             return;
diff --git a/OptiScaler/shaders/rcas/RCAS_Dx11.cpp b/OptiScaler/shaders/rcas/RCAS_Dx11.cpp
index cc158273..2199d655 100644
--- a/OptiScaler/shaders/rcas/RCAS_Dx11.cpp
+++ b/OptiScaler/shaders/rcas/RCAS_Dx11.cpp
@@ -247,21 +247,35 @@ RCAS_Dx11::RCAS_Dx11(std::string InName, ID3D11Device* InDevice) : _name(InName)
             LOG_ERROR("[{0}] CreateComputeShader error: {1:X}", _name, hr);
             return;
         }
+
+        hr = _device->CreateComputeShader(reinterpret_cast<const void*>(da_sharpen_cso), sizeof(da_sharpen_cso),
+                                          nullptr, &_computeShaderDA);
+        if (FAILED(hr))
+        {
+            LOG_ERROR("[{0}] CreateComputeShader error for depth adaptive shader: {1:X}", _name, hr);
+            return;
+        }
     }
     else
     {
         // Compile shader blobs
         ID3DBlob* shaderBlob = RCAS_CompileShader(rcasCode.c_str(), "CSMain", "cs_5_0");
-        if (shaderBlob == nullptr)
+
+        HRESULT hr = E_FAIL;
+
+        if (shaderBlob != nullptr)
+        {
+            // create pso objects
+            hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
+                                              &_computeShader);
+        }
+        else
         {
             LOG_ERROR("[{0}] RCAS_CompileShader error!", _name);
-            return;
+            hr = _device->CreateComputeShader(reinterpret_cast<const void*>(rcas_cso), sizeof(rcas_cso), nullptr,
+                                              &_computeShader);
         }
 
-        // create pso objects
-        auto hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
-                                               &_computeShader);
-
         if (shaderBlob != nullptr)
         {
             shaderBlob->Release();
@@ -270,7 +284,33 @@ RCAS_Dx11::RCAS_Dx11(std::string InName, ID3D11Device* InDevice) : _name(InName)
 
         if (FAILED(hr))
         {
-            LOG_ERROR("[{0}] CreateComputeShader error: {1:X}", _name, hr);
+            LOG_ERROR("[{0}] CreateComputeShader error for rcas shader: {1:X}", _name, hr);
+            return;
+        }
+
+        shaderBlob = RCAS_CompileShader(daSharpenCode.c_str(), "CSMain", "cs_5_0");
+
+        if (shaderBlob != nullptr)
+        {
+            hr = _device->CreateComputeShader(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), nullptr,
+                                              &_computeShaderDA);
+        }
+        else
+        {
+            LOG_ERROR("[{0}] RCAS_CompileShader error for depth adaptive shader!", _name);
+            hr = _device->CreateComputeShader(reinterpret_cast<const void*>(da_sharpen_cso), sizeof(da_sharpen_cso),
+                                              nullptr, &_computeShaderDA);
+        }
+
+        if (shaderBlob != nullptr)
+        {
+            shaderBlob->Release();
+            shaderBlob = nullptr;
+        }
+
+        if (FAILED(hr))
+        {
+            LOG_ERROR("[{0}] CreateComputeShader error for depth adaptive shader: {1:X}", _name, hr);
             return;
         }
     }
diff --git a/OptiScaler/shaders/render_ui/RUI_Dx12.cpp b/OptiScaler/shaders/render_ui/RUI_Dx12.cpp
index 53388b3c..c0f66594 100644
--- a/OptiScaler/shaders/render_ui/RUI_Dx12.cpp
+++ b/OptiScaler/shaders/render_ui/RUI_Dx12.cpp
@@ -148,20 +148,32 @@ RUI_Dx12::RUI_Dx12(std::string InName, ID3D12Device* InDevice, bool preMultiplie
             vs = RUI_CompileShader(ruiCode.c_str(), "VSMain", "vs_5_1");
             if (vs != nullptr)
                 graphicsPsoDesc.VS = { vs->GetBufferPointer(), vs->GetBufferSize() };
+            else
+                graphicsPsoDesc.VS =
+                    CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(render_ui_VS_cso), sizeof(render_ui_VS_cso));
 
             ps = RUI_CompileShader(ruiCode.c_str(), "PSMain", "ps_5_1");
             if (ps != nullptr)
                 graphicsPsoDesc.PS = { ps->GetBufferPointer(), ps->GetBufferSize() };
+            else
+                graphicsPsoDesc.PS =
+                    CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(render_ui_PS_cso), sizeof(render_ui_PS_cso));
         }
         else
         {
             vs = RUI_CompileShader(ruipmCode.c_str(), "VSMain", "vs_5_1");
             if (vs != nullptr)
                 graphicsPsoDesc.VS = { vs->GetBufferPointer(), vs->GetBufferSize() };
+            else
+                graphicsPsoDesc.VS = CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(render_ui_pm_VS_cso),
+                                                             sizeof(render_ui_pm_VS_cso));
 
             ps = RUI_CompileShader(ruipmCode.c_str(), "PSMain", "ps_5_1");
             if (ps != nullptr)
                 graphicsPsoDesc.PS = { ps->GetBufferPointer(), ps->GetBufferSize() };
+            else
+                graphicsPsoDesc.PS = CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(render_ui_pm_PS_cso),
+                                                             sizeof(render_ui_pm_PS_cso));
         }
     }
 
diff --git a/OptiScaler/shaders/resource_flip/RF_Dx12.cpp b/OptiScaler/shaders/resource_flip/RF_Dx12.cpp
index d60255cd..6c4edfe6 100644
--- a/OptiScaler/shaders/resource_flip/RF_Dx12.cpp
+++ b/OptiScaler/shaders/resource_flip/RF_Dx12.cpp
@@ -211,13 +211,12 @@ RF_Dx12::RF_Dx12(std::string InName, ID3D12Device* InDevice) : Shader_Dx12(InNam
         _recEncodeShader = RF_CompileShader(rfCode.c_str(), "CSMain", "cs_5_0");
 
         if (_recEncodeShader == nullptr)
-        {
             LOG_ERROR("[{0}] CompileShader error!", _name);
-            return;
-        }
 
         // create pso objects
-        if (!Shader_Dx12::CreateComputeShader(InDevice, _rootSignature, &_pipelineState, _recEncodeShader))
+        if (!Shader_Dx12::CreateComputeShader(
+                InDevice, _rootSignature, &_pipelineState, _recEncodeShader,
+                CD3DX12_SHADER_BYTECODE(reinterpret_cast<const void*>(RF_cso), sizeof(RF_cso))))
         {
             LOG_ERROR("[{0}] CreateComputeShader error!", _name);
             return;