diff --git a/OptiScaler/upscalers/xess/XeSSFeature.cpp b/OptiScaler/upscalers/xess/XeSSFeature.cpp
index 7b64f6a8..a5bbc820 100644
--- a/OptiScaler/upscalers/xess/XeSSFeature.cpp
+++ b/OptiScaler/upscalers/xess/XeSSFeature.cpp
@@ -87,6 +87,9 @@ bool XeSSFeature::InitXeSS(ID3D12Device* device, const NVSDK_NGX_Parameter* InPa
         LOG_DEBUG("xessParams.initFlags (ReactiveMaskActive) {0:b}", xessParams.initFlags);
     }
 
+    _xessInitFlags = xessParams.initFlags;
+    LOG_DEBUG("_xessInitFlags: {}", _xessInitFlags);
+
     switch (PerfQualityValue())
     {
     case NVSDK_NGX_PerfQuality_Value_UltraPerformance:
diff --git a/OptiScaler/upscalers/xess/XeSSFeature.h b/OptiScaler/upscalers/xess/XeSSFeature.h
index b9bb4370..61bee3e0 100644
--- a/OptiScaler/upscalers/xess/XeSSFeature.h
+++ b/OptiScaler/upscalers/xess/XeSSFeature.h
@@ -52,6 +52,7 @@ class XeSSFeature : public virtual IFeature
   protected:
     xess_context_handle_t _xessContext = nullptr;
 
+    uint32_t _xessInitFlags = 0;
     int dumpCount = 0;
 
     bool InitXeSS(ID3D12Device* device, const NVSDK_NGX_Parameter* InParameters);
diff --git a/OptiScaler/upscalers/xess/XeSSFeature_Dx11.cpp b/OptiScaler/upscalers/xess/XeSSFeature_Dx11.cpp
index 81b8020d..5489b803 100644
--- a/OptiScaler/upscalers/xess/XeSSFeature_Dx11.cpp
+++ b/OptiScaler/upscalers/xess/XeSSFeature_Dx11.cpp
@@ -125,6 +125,8 @@ bool XeSSFeature_Dx11::Init(ID3D11Device* InDevice, ID3D11DeviceContext* InConte
         LOG_DEBUG("xessParams.initFlags (ReactiveMaskActive) {0:b}", xessParams.initFlags);
     }
 
+    _xessInitFlags = xessParams.initFlags;
+
     switch (PerfQualityValue())
     {
     case NVSDK_NGX_PerfQuality_Value_UltraPerformance:
@@ -433,26 +435,28 @@ bool XeSSFeature_Dx11::Evaluate(ID3D11DeviceContext* DeviceContext, NVSDK_NGX_Pa
     //    LOG_DEBUG("AutoExposure is always enabled for XeSS Dx11!");
     //}
 
-    if (!Config::Instance()->DisableReactiveMask.value_or(true))
-    {
-        ID3D11Resource* paramReactiveMask = nullptr;
-        if (InParameters->Get(NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, &paramReactiveMask) !=
-            NVSDK_NGX_Result_Success)
-            InParameters->Get(NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, (void**) &paramReactiveMask);
+    ID3D11Resource* paramReactiveMask = nullptr;
+    if (InParameters->Get(NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, &paramReactiveMask) !=
+        NVSDK_NGX_Result_Success)
+        InParameters->Get(NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, (void**) &paramReactiveMask);
 
+    bool supportsFloatResponsivePixelMask = Version() >= feature_version { 2, 0, 1 };
+
+    if (!Config::Instance()->DisableReactiveMask.value_or(true) && supportsFloatResponsivePixelMask)
+    {
         if (paramReactiveMask)
         {
             LOG_DEBUG("Input Bias mask exist..");
-            Config::Instance()->DisableReactiveMask = false;
             params.pResponsivePixelMaskTexture = paramReactiveMask;
         }
-        else
-        {
-            LOG_WARN("Bias mask not exist and its enabled in config, it may cause problems!!");
-            Config::Instance()->DisableReactiveMask = true;
-            State::Instance().changeBackend[_handle->Id] = true;
-            return true;
-        }
+    }
+
+    if ((_xessInitFlags & XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK) > 0 && params.pResponsivePixelMaskTexture == nullptr)
+    {
+        LOG_WARN("Bias mask not exist and its enabled in config, it may cause problems!!");
+        Config::Instance()->DisableReactiveMask = true;
+        State::Instance().changeBackend[_handle->Id] = true;
+        return true;
     }
 
     _hasColor = params.pColorTexture != nullptr;
diff --git a/OptiScaler/upscalers/xess/XeSSFeature_Dx11.h b/OptiScaler/upscalers/xess/XeSSFeature_Dx11.h
index 8b9167a5..bdc8f1a5 100644
--- a/OptiScaler/upscalers/xess/XeSSFeature_Dx11.h
+++ b/OptiScaler/upscalers/xess/XeSSFeature_Dx11.h
@@ -12,6 +12,8 @@ class XeSSFeature_Dx11 : public virtual IFeature_Dx11
 
   protected:
     xess_context_handle_t _xessContext = nullptr;
+
+    uint32_t _xessInitFlags = 0;
     int dumpCount = 0;
 
   public:
diff --git a/OptiScaler/upscalers/xess/XeSSFeature_Dx11on12.cpp b/OptiScaler/upscalers/xess/XeSSFeature_Dx11on12.cpp
index 9a666c46..493e9cb0 100644
--- a/OptiScaler/upscalers/xess/XeSSFeature_Dx11on12.cpp
+++ b/OptiScaler/upscalers/xess/XeSSFeature_Dx11on12.cpp
@@ -244,24 +244,38 @@ bool XeSSFeatureDx11on12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_N
         params.pExposureScaleTexture = dx11Exp.Dx12Resource;
         _hasExposure = params.pExposureScaleTexture != nullptr;
 
+        bool supportsFloatResponsivePixelMask = Version() >= feature_version { 2, 0, 1 };
+
         if (dx11Reactive.Dx12Resource != nullptr)
         {
-            if (Config::Instance()->DlssReactiveMaskBias.value_or(0.0f) > 0.0f && Bias->IsInit() &&
-                Bias->CreateBufferResource(State::Instance().currentD3D12Device, dx11Reactive.Dx12Resource,
-                                           D3D12_RESOURCE_STATE_UNORDERED_ACCESS) &&
-                Bias->CanRender())
+            if (!Config::Instance()->DisableReactiveMask.value_or(true) && supportsFloatResponsivePixelMask)
             {
-                Bias->SetBufferState(cmdList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
-
-                if (Bias->Dispatch(State::Instance().currentD3D12Device, cmdList, dx11Reactive.Dx12Resource,
-                                   Config::Instance()->DlssReactiveMaskBias.value_or(0.0f), Bias->Buffer()))
+                if (Config::Instance()->DlssReactiveMaskBias.value_or_default() > 0.0f && Bias->IsInit() &&
+                    Bias->CreateBufferResource(State::Instance().currentD3D12Device, dx11Reactive.Dx12Resource,
+                                               D3D12_RESOURCE_STATE_UNORDERED_ACCESS) &&
+                    Bias->CanRender())
                 {
-                    Bias->SetBufferState(cmdList, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
-                    params.pResponsivePixelMaskTexture = Bias->Buffer();
+                    Bias->SetBufferState(cmdList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+
+                    if (Bias->Dispatch(State::Instance().currentD3D12Device, cmdList, dx11Reactive.Dx12Resource,
+                                       Config::Instance()->DlssReactiveMaskBias.value_or_default(), Bias->Buffer()))
+                    {
+                        Bias->SetBufferState(cmdList, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
+                        params.pResponsivePixelMaskTexture = Bias->Buffer();
+                    }
                 }
             }
         }
 
+        if ((_xessInitFlags & XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK) > 0 &&
+            params.pResponsivePixelMaskTexture == nullptr)
+        {
+            Config::Instance()->DisableReactiveMask = true;
+            LOG_WARN("Reactive mask not exist not enabled, disabling it!");
+            State::Instance().changeBackend[_handle->Id] = true;
+            return true;
+        }
+
         float MVScaleX;
         float MVScaleY;
 
diff --git a/OptiScaler/upscalers/xess/XeSSFeature_Dx12.cpp b/OptiScaler/upscalers/xess/XeSSFeature_Dx12.cpp
index 8aafe76c..1b8d2d78 100644
--- a/OptiScaler/upscalers/xess/XeSSFeature_Dx12.cpp
+++ b/OptiScaler/upscalers/xess/XeSSFeature_Dx12.cpp
@@ -245,10 +245,18 @@ bool XeSSFeatureDx12::Evaluate(ID3D12GraphicsCommandList* InCommandList, NVSDK_N
     InParameters->Get("FSR.reactive", &paramReactiveMask);
     bool supportsFloatResponsivePixelMask = Version() >= feature_version { 2, 0, 1 };
 
-    if (supportsFloatResponsivePixelMask && paramReactiveMask != nullptr)
+    if (paramReactiveMask != nullptr)
     {
-        if (!Config::Instance()->DisableReactiveMask.value_or(false))
+        if (!Config::Instance()->DisableReactiveMask.value_or(!supportsFloatResponsivePixelMask))
         {
+            if ((_xessInitFlags & XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK) == 0)
+            {
+                Config::Instance()->DisableReactiveMask = false;
+                LOG_WARN("Reactive mask exist but not enabled, enabling it!");
+                State::Instance().changeBackend[_handle->Id] = true;
+                return true;
+            }
+
             LOG_DEBUG("Using FSR reactive mask");
             params.pResponsivePixelMaskTexture = paramReactiveMask;
         }
@@ -259,40 +267,45 @@ bool XeSSFeatureDx12::Evaluate(ID3D12GraphicsCommandList* InCommandList, NVSDK_N
             NVSDK_NGX_Result_Success)
             InParameters->Get(NVSDK_NGX_Parameter_DLSS_Input_Bias_Current_Color_Mask, (void**) &paramReactiveMask);
 
-        if (!Config::Instance()->DisableReactiveMask.value_or(!supportsFloatResponsivePixelMask) && paramReactiveMask)
+        if (!Config::Instance()->DisableReactiveMask.value_or(true) && paramReactiveMask)
         {
             LOG_DEBUG("Input Bias mask exist..");
-            Config::Instance()->DisableReactiveMask = false;
+
+            if ((_xessInitFlags & XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK) == 0)
+            {
+                Config::Instance()->DisableReactiveMask = false;
+                LOG_WARN("Reactive mask exist but not enabled, enabling it!");
+                State::Instance().changeBackend[_handle->Id] = true;
+                return true;
+            }
 
             if (Config::Instance()->MaskResourceBarrier.has_value())
                 ResourceBarrier(InCommandList, params.pResponsivePixelMaskTexture,
                                 (D3D12_RESOURCE_STATES) Config::Instance()->MaskResourceBarrier.value(),
                                 D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
 
-            if (Config::Instance()->DlssReactiveMaskBias.value_or(0.0f) > 0.0f && Bias->IsInit() &&
+            if (Config::Instance()->DlssReactiveMaskBias.value_or_default() > 0.0f && Bias->IsInit() &&
                 Bias->CreateBufferResource(Device, paramReactiveMask, D3D12_RESOURCE_STATE_UNORDERED_ACCESS) &&
                 Bias->CanRender())
             {
                 Bias->SetBufferState(InCommandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
 
                 if (Bias->Dispatch(Device, InCommandList, paramReactiveMask,
-                                   Config::Instance()->DlssReactiveMaskBias.value_or(0.0f), Bias->Buffer()))
+                                   Config::Instance()->DlssReactiveMaskBias.value_or_default(), Bias->Buffer()))
                 {
                     Bias->SetBufferState(InCommandList, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
                     params.pResponsivePixelMaskTexture = Bias->Buffer();
                 }
             }
         }
-        else
-        {
-            if (!Config::Instance()->DisableReactiveMask.value_or(true))
-            {
-                LOG_WARN("Bias mask not exist and its enabled in config, it may cause problems!!");
-                Config::Instance()->DisableReactiveMask = true;
-                State::Instance().changeBackend[_handle->Id] = true;
-                return true;
-            }
-        }
+    }
+
+    if ((_xessInitFlags & XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK) > 0 && params.pResponsivePixelMaskTexture == nullptr)
+    {
+        LOG_WARN("Bias mask not exist and its enabled in config, it may cause problems!!");
+        Config::Instance()->DisableReactiveMask = true;
+        State::Instance().changeBackend[_handle->Id] = true;
+        return true;
     }
 
     _hasColor = params.pColorTexture != nullptr;
diff --git a/OptiScaler/upscalers/xess/XeSSFeature_Vk.cpp b/OptiScaler/upscalers/xess/XeSSFeature_Vk.cpp
index 86e27514..8045e168 100644
--- a/OptiScaler/upscalers/xess/XeSSFeature_Vk.cpp
+++ b/OptiScaler/upscalers/xess/XeSSFeature_Vk.cpp
@@ -157,6 +157,8 @@ bool XeSSFeature_Vk::Init(VkInstance InInstance, VkPhysicalDevice InPD, VkDevice
         LOG_DEBUG("xessParams.initFlags (ReactiveMaskActive) {0:b}", xessParams.initFlags);
     }
 
+    _xessInitFlags = xessParams.initFlags;
+
     switch (PerfQualityValue())
     {
     case NVSDK_NGX_PerfQuality_Value_UltraPerformance:
@@ -513,11 +515,20 @@ bool XeSSFeature_Vk::Evaluate(VkCommandBuffer InCmdBuffer, NVSDK_NGX_Parameter*
     bool supportsFloatResponsivePixelMask = Version() >= feature_version { 2, 0, 1 };
     NVSDK_NGX_Resource_VK* paramReactiveMask = nullptr;
 
-    if (supportsFloatResponsivePixelMask &&
-        InParameters->Get("FSR.reactive", (void**) &paramReactiveMask) == NVSDK_NGX_Result_Success)
+    if (InParameters->Get("FSR.reactive", (void**) &paramReactiveMask) == NVSDK_NGX_Result_Success)
     {
-        if (!Config::Instance()->DisableReactiveMask.value_or(true))
+        if (!Config::Instance()->DisableReactiveMask.value_or(!supportsFloatResponsivePixelMask))
+        {
+            if ((_xessInitFlags & XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK) == 0)
+            {
+                Config::Instance()->DisableReactiveMask = false;
+                LOG_WARN("Reactive mask exist but not enabled, enabling it!");
+                State::Instance().changeBackend[_handle->Id] = true;
+                return true;
+            }
+
             params.responsivePixelMaskTexture = NV_to_XeSS(paramReactiveMask);
+        }
     }
     else
     {
@@ -526,21 +537,27 @@ bool XeSSFeature_Vk::Evaluate(VkCommandBuffer InCmdBuffer, NVSDK_NGX_Parameter*
             paramReactiveMask != nullptr)
         {
             LOG_DEBUG("Input Bias mask exist..");
-            Config::Instance()->DisableReactiveMask = false;
 
-            if (!Config::Instance()->DisableReactiveMask.value_or(!supportsFloatResponsivePixelMask))
-                params.responsivePixelMaskTexture = NV_to_XeSS(paramReactiveMask);
-        }
-        else
-        {
             if (!Config::Instance()->DisableReactiveMask.value_or(true))
             {
-                LOG_WARN("Bias mask not exist and its enabled in config, it may cause problems!!");
-                Config::Instance()->DisableReactiveMask = true;
-                State::Instance().changeBackend[_handle->Id] = true;
-                return true;
+                if ((_xessInitFlags & XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK) == 0)
+                {
+                    Config::Instance()->DisableReactiveMask = false;
+                    LOG_WARN("Reactive mask exist but not enabled, enabling it!");
+                    State::Instance().changeBackend[_handle->Id] = true;
+                    return true;
+                }
+
+                params.responsivePixelMaskTexture = NV_to_XeSS(paramReactiveMask);
             }
         }
+        else if ((_xessInitFlags & XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK) > 0)
+        {
+            LOG_WARN("Bias mask not exist and its enabled in config, it may cause problems!!");
+            Config::Instance()->DisableReactiveMask = true;
+            State::Instance().changeBackend[_handle->Id] = true;
+            return true;
+        }
     }
 
     _hasColor = params.colorTexture.image != VK_NULL_HANDLE;
diff --git a/OptiScaler/upscalers/xess/XeSSFeature_Vk.h b/OptiScaler/upscalers/xess/XeSSFeature_Vk.h
index 1b69f066..48df877a 100644
--- a/OptiScaler/upscalers/xess/XeSSFeature_Vk.h
+++ b/OptiScaler/upscalers/xess/XeSSFeature_Vk.h
@@ -14,6 +14,8 @@ class XeSSFeature_Vk : public virtual IFeature_Vk
 
   protected:
     xess_context_handle_t _xessContext = nullptr;
+    
+    uint32_t _xessInitFlags = 0;
     int dumpCount = 0;
 
   public: