diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b35c2d..4c15048 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,116 @@
 # Changelog
 
+## 1.5.79.0 Stable - 2026-07-04
+
+- Promotes the exact-window `BeginPaint`/`FillRect` Explorer background renderer to production.
+- Removes periodic managed diagnostics, native paint counters, obsolete draw exports, and diagnostic build markers.
+- Retains strict `DirectUIHWND` validation, safe hook rollback, crash reporting, and operational error logs.
+
+## 1.5.78.0 Diagnostic - 2026-07-04
+
+- Replaces the overwritten `WM_ERASEBKGND` draw with process API detours matching the proven ExplorerBgTool paint order.
+- Draws immediately after DirectUI's own `FillRect`, before folders, files, and labels are painted.
+- Restricts rendering to HDCs resolved to exact registered `DirectUIHWND` instances and fully rolls back partial hook installation.
+
+## 1.5.77.0 Diagnostic - 2026-07-04
+
+- Moves exact-window background rendering from the post-paint overlay to `WM_ERASEBKGND`.
+- Draws after the default background erase and before Explorer paints folders, files, and labels.
+- Uses the message-provided HDC, removes the post-paint redraw loop, and keeps all IAT hooks disabled.
+
+## 1.5.76.0 Diagnostic - 2026-07-04
+
+- Fixes exact-window registration for the hook-free after-paint renderer by checking the initialized renderer state rather than the obsolete installed-hook state.
+- Preserves the 1.5.75 exact `DirectUIHWND` rendering path with all background IAT hooks disabled.
+
+## 1.5.75.0 Diagnostic - 2026-07-03
+
+- Replaces background-mode IAT interception with exact-window rendering dispatched by QTTabBar's existing `DirectUIHWND` after-paint message.
+- Uses the WinSpy-confirmed registered file-list window and disables all scoped background IAT hooks.
+- Adds after-paint render telemetry while retaining the WIC image loader and strict window validation.
+
+## 1.5.74.0 Diagnostic - 2026-07-03
+
+- Extends the isolated background renderer to scoped `FillRect` and `CreateCompatibleDC` imports in `shell32` and `ExplorerFrame`.
+- Adds per-module paint telemetry plus image/paint overlap and clip-region diagnostics.
+- Retains exact registered-window filtering and avoids process-wide API hooks.
+
+## 1.5.73.0 Diagnostic - 2026-07-03
+
+- Replaced the non-windowed `dui70!GetDC(NULL)` diagnostic path with scoped `shell32!BeginPaint` and `shell32!EndPaint` import hooks.
+- Mirrors the reference renderer's DirectUI paint-DC association while retaining exact registered-window filtering.
+
+## 1.5.72.0 Diagnostic - 2026-07-03
+
+- Replaced the unrelated `ExplorerFrame!BeginPaint` import hook with scoped `dui70!GetDC` and `dui70!ReleaseDC` import hooks.
+- Associates only exact registered `DirectUIHWND` DCs with the background renderer.
+- Retains delayed telemetry to verify DC resolution and alpha blending in the target Windows 10 VM.
+
+## 1.5.71.0 Diagnostic - 2026-07-03
+
+- Added read-only native telemetry for the isolated Explorer background renderer.
+- Logs delayed snapshots for `BeginPaint`, compatible DC propagation, `FillRect`, and `AlphaBlend` without changing hook targets or rendering behavior.
+- Keeps 1.5.70.0 Stable as the rollback baseline.
+
+## 1.5.70.0 Stable - 2026-07-03
+
+- Adds a scoped `ExplorerFrame.dll` `BeginPaint` import patch to capture the real
+  DirectUI paint DC without installing a process-wide hook
+- Maps the captured paint DC to the already registered `DirectUIHWND`
+- Keeps `FillRect` and `CreateCompatibleDC` patches limited to `dui70.dll`
+- Retains the stable background-only state separation from 1.5.69
+
+## 1.5.69.0 Stable - 2026-07-03
+
+- Separates isolated background-renderer state from the legacy QTHookLib state
+- Skips the invalid ShellBrowser-hook call in background-only mode
+- Removes the additional `dui70.dll` `DeleteDC` patch not used by the reference implementation
+- Replaces DeleteDC tracking with bounded, overwrite-on-create compatible-DC mapping
+
+## 1.5.68.0 Stable - 2026-07-03
+
+- Removed `std::random_device` from Explorer background renderer construction
+- Uses a deterministic renderer seed so startup does not enter platform entropy code
+- Added phase diagnostics for singleton creation, configuration, image enumeration,
+  WIC decode, DIB creation, pixel copy, and state commit
+- Logs the exact native renderer phase after both success and guarded failure
+
+## 1.5.67.0 Stable - 2026-07-03
+
+- Replaced the background renderer's GDI+ decoder with Windows Imaging Component
+- Removed `GdiplusStartup`, raw `LockBits` access and manual source-stride traversal
+- Decodes PNG/BMP/JPEG directly into validated premultiplied `32bppPBGRA` DIB surfaces
+- Addresses the renderer-stage access violation observed on Windows 10 22H2 build 19045.5679
+- Retains phased renderer/hook diagnostics and guarded `dui70.dll` activation
+
+## 1.5.66.0 Stable - 2026-07-03
+
+- Hardened `dui70.dll` PE/import parsing for later Windows 10 22H2 servicing builds
+- Bounded every descriptor, thunk and import-name read to the loaded module image
+- Guarded native IAT reads and writes against structured exceptions
+- Split renderer initialization from IAT activation for precise managed diagnostics
+- Added native export guards so unsupported layouts return an error instead of terminating Explorer
+
+## 1.5.65.0 Stable - 2026-07-03
+
+- Moved Explorer background ownership into the already loaded `QTTabBarNative.dll`
+- Stopped loading the legacy monolithic `QTHookLib` in background-only mode
+- Removed the background feature's file dependency on `QTHookLib32/64.dll`
+- Preserved the three module-scoped `dui70.dll` import hooks and safe image renderer
+- Added an architecture smoke test proving initialization succeeds with no legacy hook DLL
+
+## 1.5.64.0 Stable - 2026-07-03
+
+- Replaced the legacy Explorer background path with an encapsulated renderer
+- Removed MinHook entirely from background-only initialization
+- Limited interception to three `dui70.dll` import slots and registered `DirectUIHWND` views
+- Added validated immutable image snapshots and safe live configuration reloads
+- Added correct premultiplied PNG alpha rendering and HDC lifecycle tracking
+- Added window-property tokens to prevent reused HWND values from matching stale state
+- Added configurable image directories, random selection and path-specific images
+- Added ESC startup recovery while keeping legacy Shell hooks disabled by default
+- Preserved native HRESULT diagnostics across the managed bridge
+
 ## 1.5.62.0 Stable - 2026-07-02
 
 - Consolidated the native and .NET Framework 4.8 QTTabBar code lines
@@ -16,4 +127,3 @@
 - Added isolated Explorer background rendering from `config.ini`
 - Improved Win+E capture, tab focus and toolbar persistence
 - Removed release debug paths and reduced success-log noise
-
diff --git a/CREDITS.md b/CREDITS.md
index 90e38c0..ff189c7 100644
--- a/CREDITS.md
+++ b/CREDITS.md
@@ -14,10 +14,10 @@ QTTabBar Native Enhanced combines and extends work from several generations of Q
 
 - **Akay Devel Coder** - project owner, product direction, integration decisions, visual design and extensive Windows/VM testing
 - **OpenAI Codex** - major integration, debugging, native/managed implementation and release-engineering assistance under the project owner's direction
+- **Maplespe / ExplorerBgTool** - inspiration for configurable and path-specific Explorer background images; this project uses an independently reworked renderer integrated with QTTabBar's targeted window registration
 
 The attribution list is intentionally open for correction and expansion as additional upstream history is identified.
 
 ## Third-party components
 
 This repository contains or references third-party components including MinHook, WiX build definitions and NotifyPropertyWeaver. Their original license and attribution terms continue to apply.
-
diff --git a/Installer/Bundle.wxs b/Installer/Bundle.wxs
index 41d306c..048ae13 100644
--- a/Installer/Bundle.wxs
+++ b/Installer/Bundle.wxs
@@ -3,8 +3,8 @@
      xmlns:bal="http://schemas.microsoft.com/wix/BalExtension"
      xmlns:netfx="http://schemas.microsoft.com/wix/NetFxExtension">
 
-    <Bundle Name="QTTabBar 1.5.62.0 Stable"
-            Version="1.5.62.0"
+    <Bundle Name="QTTabBar 1.5.79.0 Stable"
+            Version="1.5.79.0"
             Manufacturer="indiff"
             UpgradeCode="{6E6EAFA9-B39E-4A2F-88A0-E52B365F33D8}"
             IconSourceFile="QTTabBar.ico">
diff --git a/Installer/Installer.wxs b/Installer/Installer.wxs
index 73adb25..729de66 100644
--- a/Installer/Installer.wxs
+++ b/Installer/Installer.wxs
@@ -23,14 +23,14 @@
 
     <?define SkuName = "QTTabBar"?>
     <?define RTMProductVersion="1.5.0" ?>
-    <?define ProductVersion="1.5.62" ?> <!-- MSI compares only the first three version fields. -->
-    <?define VersionString="1.5.62.0 Stable (2026)" ?>
+    <?define ProductVersion="1.5.79" ?> <!-- MSI compares only the first three version fields. -->
+    <?define VersionString="1.5.79.0 Stable (2026)" ?>
     <?define UpgradeCode="{ec9baff7-58fb-40cb-9f67-1c438a7524a5}"?> <!-- NEVER CHANGE THIS, EVER!! -->
     <!-- Quizo and Paul Accisano and indiff -->
     <?define Manufacturer="indiff"?>
     <?define ProductCode="*"?>
     <!-- 重点这里一定要改 -->
-    <?define AssemblyVersion="1.5.62.0"?>
+    <?define AssemblyVersion="1.5.79.0"?>
     <?define StrongName="QTTabBar, Version=$(var.AssemblyVersion), Culture=neutral, PublicKeyToken=973461f1cd23d8eb"?>
     <?define MyLanguage="1033"?>
     <!-- Language code page 1252 1033
diff --git a/Installer/config.ini b/Installer/config.ini
index 6c54449..6db3386 100644
--- a/Installer/config.ini
+++ b/Installer/config.ini
@@ -4,8 +4,14 @@ enabled=false
 
 [image]
 enabled=true
+# Hold ESC while Explorer starts to bypass the background renderer for recovery.
 # 遍历模式生效
 random=false
+# Optional directory containing additional PNG/BMP/JPG/JPEG images.
+# Relative paths are resolved below C:\ProgramData\QTTabBar.
+folder=Image
+# Allow a section named after the current Explorer path to select an image.
+custom=false
 # 图片位置
 #0 = Left top
 #1 = Right top
@@ -19,3 +25,10 @@ posType=3
 imgAlpha= 255
 # 如果自定义存在则加载，反之加载目录的图片 *.png *.jpg *.jpeg C:\\ProgramData\\QTTabBar\\Image\\bgImage.png
 imgPath=%ProgramData%\QTTabBar\libai.png
+
+# Example for custom=true (the image must exist in the configured folder):
+#[C:\Users\Public\Pictures]
+#img=example.png
+#
+#[::{20D04FE0-3AEA-1069-A2D8-08002B30309D}]
+#img=this-pc.png
diff --git a/MinHook/libMinHook.vcxproj b/MinHook/libMinHook.vcxproj
index 7520ea5..e82f04e 100644
--- a/MinHook/libMinHook.vcxproj
+++ b/MinHook/libMinHook.vcxproj
@@ -83,7 +83,7 @@
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
@@ -102,7 +102,7 @@
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
@@ -117,7 +117,7 @@
       <Optimization>MaxSpeed</Optimization>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <PrecompiledHeader>
       </PrecompiledHeader>
@@ -136,7 +136,7 @@
       <Optimization>MaxSpeed</Optimization>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <PrecompiledHeader>
       </PrecompiledHeader>
diff --git a/QTHookLib/ExplorerBackgroundRenderer.cpp b/QTHookLib/ExplorerBackgroundRenderer.cpp
new file mode 100644
index 0000000..73f63df
--- /dev/null
+++ b/QTHookLib/ExplorerBackgroundRenderer.cpp
@@ -0,0 +1,734 @@
+#include "ExplorerBackgroundRenderer.h"
+
+#include <shlwapi.h>
+#include <wincodec.h>
+#include <wrl/client.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cwchar>
+#include <cwctype>
+#include <memory>
+#include <mutex>
+#include <new>
+#include <limits>
+#include <random>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#pragma comment(lib, "Msimg32.lib")
+#pragma comment(lib, "Shlwapi.lib")
+#pragma comment(lib, "Windowscodecs.lib")
+
+namespace qttabbar {
+namespace background {
+namespace {
+
+constexpr wchar_t kRegisteredWindowProperty[] =
+    L"QTTabBar.NativeEnhanced.BackgroundWindow";
+
+struct ImageAsset {
+    ~ImageAsset() {
+        if(memoryDc != nullptr && previousBitmap != nullptr && previousBitmap != HGDI_ERROR) {
+            ::SelectObject(memoryDc, previousBitmap);
+        }
+        if(bitmap != nullptr) {
+            ::DeleteObject(bitmap);
+        }
+        if(memoryDc != nullptr) {
+            ::DeleteDC(memoryDc);
+        }
+    }
+
+    std::wstring path;
+    std::wstring fileName;
+    HDC memoryDc = nullptr;
+    HBITMAP bitmap = nullptr;
+    HGDIOBJ previousBitmap = nullptr;
+    SIZE size{};
+    mutable std::mutex drawMutex;
+};
+
+struct ConfigSnapshot {
+    std::wstring configPath;
+    std::wstring imageFolder;
+    int positionMode = 3;
+    BYTE alpha = 255;
+    bool random = false;
+    bool customByPath = false;
+    std::vector<std::shared_ptr<ImageAsset>> images;
+};
+
+struct WindowState {
+    SIZE lastSize{};
+    std::size_t imageIndex = 0;
+    std::wstring path;
+};
+
+std::wstring ToLower(std::wstring value) {
+    std::transform(value.begin(), value.end(), value.begin(),
+        [](wchar_t ch) { return static_cast<wchar_t>(std::towlower(ch)); });
+    return value;
+}
+
+std::wstring FileNameOf(const std::wstring& path) {
+    const std::wstring::size_type slash = path.find_last_of(L"\\/");
+    return slash == std::wstring::npos ? path : path.substr(slash + 1);
+}
+
+bool FileExists(const std::wstring& path) {
+    const DWORD attributes = ::GetFileAttributesW(path.c_str());
+    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
+}
+
+bool DirectoryExists(const std::wstring& path) {
+    const DWORD attributes = ::GetFileAttributesW(path.c_str());
+    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+}
+
+std::wstring ModuleDirectory(HMODULE module) {
+    std::vector<wchar_t> buffer(MAX_PATH);
+    for(;;) {
+        const DWORD length = ::GetModuleFileNameW(module, buffer.data(), static_cast<DWORD>(buffer.size()));
+        if(length == 0) {
+            return {};
+        }
+        if(length < buffer.size() - 1) {
+            std::wstring path(buffer.data(), length);
+            const std::wstring::size_type slash = path.find_last_of(L"\\/");
+            return slash == std::wstring::npos ? std::wstring() : path.substr(0, slash);
+        }
+        buffer.resize(buffer.size() * 2);
+    }
+}
+
+std::wstring ReadIni(const std::wstring& file, const std::wstring& section,
+                     const wchar_t* key, const wchar_t* fallback = L"") {
+    std::vector<wchar_t> buffer(32768, L'\0');
+    const DWORD length = ::GetPrivateProfileStringW(section.c_str(), key, fallback,
+        buffer.data(), static_cast<DWORD>(buffer.size()), file.c_str());
+    return std::wstring(buffer.data(), length);
+}
+
+bool ReadBool(const std::wstring& file, const wchar_t* section, const wchar_t* key,
+              bool fallback) {
+    const std::wstring value = ToLower(ReadIni(file, section, key, fallback ? L"true" : L"false"));
+    return value == L"true" || value == L"1" || value == L"yes" || value == L"on";
+}
+
+int ReadInt(const std::wstring& file, const wchar_t* section, const wchar_t* key,
+            int fallback, int minimum, int maximum) {
+    const std::wstring value = ReadIni(file, section, key, L"");
+    if(value.empty()) {
+        return fallback;
+    }
+    wchar_t* end = nullptr;
+    const long parsed = std::wcstol(value.c_str(), &end, 10);
+    if(end == value.c_str() || *end != L'\0') {
+        return fallback;
+    }
+    const long clamped = parsed < minimum ? minimum : (parsed > maximum ? maximum : parsed);
+    return static_cast<int>(clamped);
+}
+
+std::wstring ExpandPath(const std::wstring& value, const std::wstring& baseDirectory) {
+    if(value.empty()) {
+        return {};
+    }
+    const DWORD required = ::ExpandEnvironmentStringsW(value.c_str(), nullptr, 0);
+    std::wstring expanded = value;
+    if(required > 0) {
+        std::vector<wchar_t> buffer(required, L'\0');
+        if(::ExpandEnvironmentStringsW(value.c_str(), buffer.data(), required) != 0) {
+            expanded.assign(buffer.data());
+        }
+    }
+    if(::PathIsRelativeW(expanded.c_str())) {
+        return baseDirectory + L"\\" + expanded;
+    }
+    return expanded;
+}
+
+bool IsSupportedImage(const std::wstring& name) {
+    const std::wstring lower = ToLower(name);
+    return lower.size() > 4 &&
+        (lower.compare(lower.size() - 4, 4, L".png") == 0 ||
+         lower.compare(lower.size() - 4, 4, L".bmp") == 0 ||
+         lower.compare(lower.size() - 4, 4, L".jpg") == 0 ||
+         (lower.size() > 5 && lower.compare(lower.size() - 5, 5, L".jpeg") == 0));
+}
+
+void EnumerateImages(const std::wstring& directory, std::vector<std::wstring>& paths) {
+    if(!DirectoryExists(directory)) {
+        return;
+    }
+    WIN32_FIND_DATAW data{};
+    const std::wstring pattern = directory + L"\\*";
+    HANDLE find = ::FindFirstFileW(pattern.c_str(), &data);
+    if(find == INVALID_HANDLE_VALUE) {
+        return;
+    }
+    do {
+        if((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0 && IsSupportedImage(data.cFileName)) {
+            paths.push_back(directory + L"\\" + data.cFileName);
+        }
+    } while(::FindNextFileW(find, &data));
+    ::FindClose(find);
+    std::sort(paths.begin(), paths.end(), [](const std::wstring& left, const std::wstring& right) {
+        return ToLower(left) < ToLower(right);
+    });
+}
+
+std::shared_ptr<ImageAsset> LoadImage(const std::wstring& path) {
+    using Microsoft::WRL::ComPtr;
+
+    ComPtr<IWICImagingFactory> factory;
+    HRESULT result = ::CoCreateInstance(CLSID_WICImagingFactory, nullptr,
+        CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&factory));
+    if(FAILED(result)) {
+        return {};
+    }
+
+    ComPtr<IWICBitmapDecoder> decoder;
+    result = factory->CreateDecoderFromFilename(path.c_str(), nullptr, GENERIC_READ,
+        WICDecodeMetadataCacheOnLoad, &decoder);
+    if(FAILED(result)) {
+        return {};
+    }
+
+    ComPtr<IWICBitmapFrameDecode> frame;
+    result = decoder->GetFrame(0, &frame);
+    if(FAILED(result)) {
+        return {};
+    }
+
+    UINT width = 0;
+    UINT height = 0;
+    result = frame->GetSize(&width, &height);
+    if(FAILED(result) || width == 0 || height == 0 ||
+       width > static_cast<UINT>((std::numeric_limits<LONG>::max)()) ||
+       height > static_cast<UINT>((std::numeric_limits<LONG>::max)()) ||
+       width > (std::numeric_limits<UINT>::max)() / 4) {
+        return {};
+    }
+
+    const UINT stride = width * 4;
+    if(height > (std::numeric_limits<UINT>::max)() / stride) {
+        return {};
+    }
+    const UINT bufferSize = stride * height;
+
+    ComPtr<IWICFormatConverter> converter;
+    result = factory->CreateFormatConverter(&converter);
+    if(FAILED(result)) {
+        return {};
+    }
+    result = converter->Initialize(frame.Get(), GUID_WICPixelFormat32bppPBGRA,
+        WICBitmapDitherTypeNone, nullptr, 0.0, WICBitmapPaletteTypeCustom);
+    if(FAILED(result)) {
+        return {};
+    }
+
+    auto image = std::make_shared<ImageAsset>();
+    image->path = path;
+    image->fileName = FileNameOf(path);
+    image->size.cx = static_cast<LONG>(width);
+    image->size.cy = static_cast<LONG>(height);
+    image->memoryDc = ::CreateCompatibleDC(nullptr);
+    if(image->memoryDc == nullptr) {
+        return {};
+    }
+    BITMAPINFO bitmapInfo{};
+    bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    bitmapInfo.bmiHeader.biWidth = image->size.cx;
+    bitmapInfo.bmiHeader.biHeight = -image->size.cy;
+    bitmapInfo.bmiHeader.biPlanes = 1;
+    bitmapInfo.bmiHeader.biBitCount = 32;
+    bitmapInfo.bmiHeader.biCompression = BI_RGB;
+    void* destinationBits = nullptr;
+    image->bitmap = ::CreateDIBSection(image->memoryDc, &bitmapInfo, DIB_RGB_COLORS,
+        &destinationBits, nullptr, 0);
+    if(image->bitmap == nullptr || destinationBits == nullptr) {
+        return {};
+    }
+
+    result = converter->CopyPixels(nullptr, stride, bufferSize,
+        static_cast<BYTE*>(destinationBits));
+    if(FAILED(result)) {
+        return {};
+    }
+
+    image->previousBitmap = ::SelectObject(image->memoryDc, image->bitmap);
+    if(image->previousBitmap == nullptr || image->previousBitmap == HGDI_ERROR) {
+        return {};
+    }
+    return image;
+}
+
+bool SameFileTime(const FILETIME& left, const FILETIME& right) {
+    return left.dwLowDateTime == right.dwLowDateTime && left.dwHighDateTime == right.dwHighDateTime;
+}
+
+FILETIME LastWriteTime(const std::wstring& path) {
+    WIN32_FILE_ATTRIBUTE_DATA data{};
+    if(::GetFileAttributesExW(path.c_str(), GetFileExInfoStandard, &data)) {
+        return data.ftLastWriteTime;
+    }
+    return {};
+}
+
+class Renderer {
+public:
+    Renderer() noexcept : random_(0x51545442u) {
+    }
+
+    HRESULT Initialize(HMODULE module) {
+        std::lock_guard<std::mutex> loadGuard(loadMutex_);
+        if(active_.load(std::memory_order_acquire)) {
+            return S_OK;
+        }
+        if((::GetAsyncKeyState(VK_ESCAPE) & 0x8000) != 0) {
+            return HRESULT_FROM_WIN32(ERROR_CANCELLED);
+        }
+        moduleDirectory_ = ModuleDirectory(module);
+        if(moduleDirectory_.empty()) {
+            return E_FAIL;
+        }
+        configPath_ = moduleDirectory_ + L"\\config.ini";
+        if(!FileExists(configPath_) || !ReadBool(configPath_, L"image", L"enabled", true)) {
+            return S_FALSE;
+        }
+
+        std::shared_ptr<const ConfigSnapshot> snapshot = BuildSnapshot();
+        if(!snapshot || snapshot->images.empty()) {
+            return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
+        }
+        {
+            std::lock_guard<std::mutex> stateGuard(stateMutex_);
+            config_ = std::move(snapshot);
+            windows_.clear();
+            dcWindows_.clear();
+            configWriteTime_ = LastWriteTime(configPath_);
+        }
+        active_.store(true, std::memory_order_release);
+        return S_OK;
+    }
+
+    void Shutdown() noexcept {
+        std::lock_guard<std::mutex> loadGuard(loadMutex_);
+        active_.store(false, std::memory_order_release);
+        {
+            std::lock_guard<std::mutex> stateGuard(stateMutex_);
+            for(const auto& entry : windows_) {
+                if(::IsWindow(entry.first) &&
+                   ::GetPropW(entry.first, kRegisteredWindowProperty) == this) {
+                    ::RemovePropW(entry.first, kRegisteredWindowProperty);
+                }
+            }
+            windows_.clear();
+            dcWindows_.clear();
+            config_.reset();
+        }
+    }
+
+    bool IsActive() const noexcept {
+        return active_.load(std::memory_order_acquire);
+    }
+
+    HRESULT RegisterWindow(HWND window, const wchar_t* path) {
+        if(!IsActive() || !::IsWindow(window)) {
+            return E_FAIL;
+        }
+        wchar_t className[64]{};
+        ::GetClassNameW(window, className, ARRAYSIZE(className));
+        if(std::wcscmp(className, L"DirectUIHWND") != 0) {
+            return E_INVALIDARG;
+        }
+        ReloadIfChanged();
+
+        const std::wstring currentPath = path == nullptr ? std::wstring() : path;
+        std::lock_guard<std::mutex> stateGuard(stateMutex_);
+        if(!config_ || config_->images.empty()) {
+            return E_FAIL;
+        }
+        if(!::SetPropW(window, kRegisteredWindowProperty, this)) {
+            const DWORD error = ::GetLastError();
+            return HRESULT_FROM_WIN32(error == ERROR_SUCCESS ? ERROR_NOT_ENOUGH_MEMORY : error);
+        }
+        WindowState& state = windows_[window];
+        state.path = currentPath;
+        state.imageIndex = SelectImageIndex(*config_, currentPath);
+        state.lastSize = {};
+        ::InvalidateRect(window, nullptr, TRUE);
+        return S_OK;
+    }
+
+    HRESULT UpdateWindow(HWND window, const wchar_t* path) {
+        if(!IsActive() || !::IsWindow(window)) {
+            return E_FAIL;
+        }
+        if(::GetPropW(window, kRegisteredWindowProperty) != this) {
+            return E_INVALIDARG;
+        }
+        ReloadIfChanged();
+        const std::wstring currentPath = path == nullptr ? std::wstring() : path;
+        std::lock_guard<std::mutex> stateGuard(stateMutex_);
+        auto found = windows_.find(window);
+        if(found == windows_.end() || !config_ || config_->images.empty()) {
+            return E_FAIL;
+        }
+        found->second.path = currentPath;
+        found->second.imageIndex = SelectImageIndex(*config_, currentPath);
+        ::InvalidateRect(window, nullptr, TRUE);
+        return S_OK;
+    }
+
+    void OnWindowDcAcquired(HWND window, HDC dc) noexcept {
+        if(!IsActive() || window == nullptr || dc == nullptr) {
+            return;
+        }
+        std::lock_guard<std::mutex> guard(stateMutex_);
+        dcWindows_.erase(dc);
+        if(windows_.find(window) != windows_.end() &&
+           ::IsWindow(window) &&
+           ::GetPropW(window, kRegisteredWindowProperty) == this) {
+            dcWindows_[dc] = window;
+        }
+    }
+
+    void OnCompatibleDcCreated(HDC sourceDc, HDC compatibleDc) noexcept {
+        if(!IsActive() || sourceDc == nullptr || compatibleDc == nullptr) {
+            return;
+        }
+        std::lock_guard<std::mutex> guard(stateMutex_);
+        dcWindows_.erase(compatibleDc);
+        if(dcWindows_.size() > 2048) {
+            dcWindows_.clear();
+        }
+        const HWND window = ResolveWindowLocked(sourceDc);
+        if(window != nullptr) {
+            dcWindows_[compatibleDc] = window;
+        }
+    }
+
+    void OnDcDeleted(HDC dc) noexcept {
+        if(dc == nullptr) {
+            return;
+        }
+        std::lock_guard<std::mutex> guard(stateMutex_);
+        dcWindows_.erase(dc);
+    }
+
+    void OnFillRect(HDC targetDc, const RECT* paintedRect) noexcept {
+        if(!IsActive() || targetDc == nullptr || paintedRect == nullptr) {
+            return;
+        }
+
+        HWND window = nullptr;
+        SIZE previousSize{};
+        std::shared_ptr<const ConfigSnapshot> config;
+        std::shared_ptr<ImageAsset> image;
+        {
+            std::lock_guard<std::mutex> guard(stateMutex_);
+            window = ResolveWindowLocked(targetDc);
+            auto found = windows_.find(window);
+            if(found != windows_.end()) {
+                const WindowState& state = found->second;
+                previousSize = state.lastSize;
+                config = config_;
+                if(config && !config->images.empty()) {
+                    const std::size_t index = state.imageIndex < config->images.size() ? state.imageIndex : 0;
+                    image = config->images[index];
+                }
+            }
+        }
+        if(window == nullptr || !image || !config || image->memoryDc == nullptr ||
+           image->size.cx <= 0 || image->size.cy <= 0) {
+            return;
+        }
+
+        RECT client{};
+        if(!::GetClientRect(window, &client)) {
+            return;
+        }
+        const SIZE windowSize{client.right - client.left, client.bottom - client.top};
+        if(windowSize.cx <= 0 || windowSize.cy <= 0) {
+            return;
+        }
+        if(config->positionMode != 0 &&
+           (previousSize.cx != windowSize.cx || previousSize.cy != windowSize.cy)) {
+            ::InvalidateRect(window, nullptr, TRUE);
+        }
+
+        POINT position{};
+        SIZE destination = image->size;
+        CalculatePlacement(config->positionMode, windowSize, image->size, position, destination);
+        if(destination.cx <= 0 || destination.cy <= 0) {
+            return;
+        }
+
+        const int saved = ::SaveDC(targetDc);
+        if(saved == 0) {
+            return;
+        }
+        const int clipResult = ::IntersectClipRect(targetDc, paintedRect->left, paintedRect->top,
+            paintedRect->right, paintedRect->bottom);
+        if(clipResult == NULLREGION || clipResult == ERROR) {
+            ::RestoreDC(targetDc, saved);
+            return;
+        }
+        const BLENDFUNCTION blend{AC_SRC_OVER, 0, config->alpha, AC_SRC_ALPHA};
+        {
+            std::lock_guard<std::mutex> drawGuard(image->drawMutex);
+            ::AlphaBlend(targetDc, position.x, position.y, destination.cx, destination.cy,
+                image->memoryDc, 0, 0, image->size.cx, image->size.cy, blend);
+        }
+        ::RestoreDC(targetDc, saved);
+
+        std::lock_guard<std::mutex> guard(stateMutex_);
+        auto found = windows_.find(window);
+        if(found != windows_.end()) {
+            found->second.lastSize = windowSize;
+        }
+    }
+
+private:
+    HWND ResolveWindowLocked(HDC dc) {
+        const auto mapped = dcWindows_.find(dc);
+        if(mapped != dcWindows_.end()) {
+            if(windows_.find(mapped->second) != windows_.end() && ::IsWindow(mapped->second) &&
+               ::GetPropW(mapped->second, kRegisteredWindowProperty) == this) {
+                return mapped->second;
+            }
+            dcWindows_.erase(mapped);
+        }
+
+        HWND candidate = ::WindowFromDC(dc);
+        for(int depth = 0; candidate != nullptr && depth < 8; ++depth) {
+            if(windows_.find(candidate) != windows_.end() &&
+               ::GetPropW(candidate, kRegisteredWindowProperty) == this) {
+                return candidate;
+            }
+            candidate = ::GetParent(candidate);
+        }
+        return nullptr;
+    }
+
+    std::shared_ptr<const ConfigSnapshot> BuildSnapshot() const {
+        auto snapshot = std::make_shared<ConfigSnapshot>();
+        snapshot->configPath = configPath_;
+        snapshot->positionMode = ReadInt(configPath_, L"image", L"posType", 3, 0, 6);
+        snapshot->alpha = static_cast<BYTE>(ReadInt(configPath_, L"image", L"imgAlpha", 255, 0, 255));
+        snapshot->random = ReadBool(configPath_, L"image", L"random", false);
+        snapshot->customByPath = ReadBool(configPath_, L"image", L"custom", false);
+
+        const std::wstring configuredFolder = ExpandPath(
+            ReadIni(configPath_, L"image", L"folder", L""), moduleDirectory_);
+        snapshot->imageFolder = configuredFolder.empty() ? moduleDirectory_ + L"\\Image" : configuredFolder;
+
+        std::vector<std::wstring> paths;
+        const std::wstring defaultImage = ExpandPath(
+            ReadIni(configPath_, L"image", L"imgPath", L""), moduleDirectory_);
+        if(FileExists(defaultImage) && IsSupportedImage(defaultImage)) {
+            paths.push_back(defaultImage);
+        }
+        EnumerateImages(snapshot->imageFolder, paths);
+
+        std::unordered_set<std::wstring> seen;
+        for(const std::wstring& path : paths) {
+            const std::wstring key = ToLower(path);
+            if(!seen.insert(key).second) {
+                continue;
+            }
+            std::shared_ptr<ImageAsset> image = LoadImage(path);
+            if(image) {
+                snapshot->images.push_back(std::move(image));
+            }
+        }
+        return snapshot;
+    }
+
+    void ReloadIfChanged() {
+        const FILETIME currentWriteTime = LastWriteTime(configPath_);
+        {
+            std::lock_guard<std::mutex> guard(stateMutex_);
+            if(SameFileTime(currentWriteTime, configWriteTime_)) {
+                return;
+            }
+        }
+        std::lock_guard<std::mutex> loadGuard(loadMutex_);
+        {
+            std::lock_guard<std::mutex> guard(stateMutex_);
+            if(SameFileTime(currentWriteTime, configWriteTime_)) {
+                return;
+            }
+        }
+        std::shared_ptr<const ConfigSnapshot> replacement = BuildSnapshot();
+        if(!replacement || replacement->images.empty()) {
+            return;
+        }
+        std::vector<HWND> invalidate;
+        {
+            std::lock_guard<std::mutex> guard(stateMutex_);
+            config_ = std::move(replacement);
+            configWriteTime_ = currentWriteTime;
+            for(auto& entry : windows_) {
+                entry.second.imageIndex = SelectImageIndex(*config_, entry.second.path);
+                invalidate.push_back(entry.first);
+            }
+        }
+        for(HWND window : invalidate) {
+            if(::IsWindow(window)) {
+                ::InvalidateRect(window, nullptr, TRUE);
+            }
+        }
+    }
+
+    std::size_t SelectImageIndex(const ConfigSnapshot& config, const std::wstring& path) {
+        if(config.customByPath && !path.empty()) {
+            const std::wstring requested = ToLower(FileNameOf(
+                ReadIni(config.configPath, path, L"img", L"")));
+            if(!requested.empty()) {
+                for(std::size_t i = 0; i < config.images.size(); ++i) {
+                    if(ToLower(config.images[i]->fileName) == requested) {
+                        return i;
+                    }
+                }
+            }
+        }
+        if(config.random && config.images.size() > 1) {
+            std::uniform_int_distribution<std::size_t> distribution(0, config.images.size() - 1);
+            return distribution(random_);
+        }
+        return 0;
+    }
+
+    static void CalculatePlacement(int mode, const SIZE& window, const SIZE& image,
+                                   POINT& position, SIZE& destination) {
+        destination = image;
+        switch(mode) {
+            case 0:
+                position = {0, 0};
+                break;
+            case 1:
+                position = {window.cx - image.cx, 0};
+                break;
+            case 2:
+                position = {0, window.cy - image.cy};
+                break;
+            case 3:
+                position = {window.cx - image.cx, window.cy - image.cy};
+                break;
+            case 4:
+                position = {(window.cx - image.cx) / 2, (window.cy - image.cy) / 2};
+                break;
+            case 5:
+                position = {0, 0};
+                destination = window;
+                break;
+            case 6: {
+                const double scaleX = static_cast<double>(window.cx) / image.cx;
+                const double scaleY = static_cast<double>(window.cy) / image.cy;
+                const double scale = scaleX > scaleY ? scaleX : scaleY;
+                const LONG scaledWidth = static_cast<LONG>(image.cx * scale + 0.5);
+                const LONG scaledHeight = static_cast<LONG>(image.cy * scale + 0.5);
+                destination.cx = scaledWidth > 0 ? scaledWidth : 1;
+                destination.cy = scaledHeight > 0 ? scaledHeight : 1;
+                position.x = (window.cx - destination.cx) / 2;
+                position.y = (window.cy - destination.cy) / 2;
+                break;
+            }
+            default:
+                position = {window.cx - image.cx, window.cy - image.cy};
+                break;
+        }
+    }
+
+    std::atomic<bool> active_{false};
+    std::mutex stateMutex_;
+    std::mutex loadMutex_;
+    std::unordered_map<HWND, WindowState> windows_;
+    std::unordered_map<HDC, HWND> dcWindows_;
+    std::shared_ptr<const ConfigSnapshot> config_;
+    std::wstring moduleDirectory_;
+    std::wstring configPath_;
+    FILETIME configWriteTime_{};
+    std::mt19937 random_;
+};
+
+Renderer& GetRenderer() {
+    // Explicit Shutdown releases GDI objects before the DLL is unloaded. The tiny
+    // coordinator intentionally survives to avoid destructor work under loader lock.
+    static Renderer* renderer = new Renderer();
+    return *renderer;
+}
+
+}  // namespace
+
+HRESULT Initialize(HMODULE module) {
+    try {
+        return GetRenderer().Initialize(module);
+    }
+    catch(const std::bad_alloc&) {
+        return E_OUTOFMEMORY;
+    }
+    catch(...) {
+        return E_FAIL;
+    }
+}
+
+void Shutdown() noexcept {
+    GetRenderer().Shutdown();
+}
+
+bool IsActive() noexcept {
+    return GetRenderer().IsActive();
+}
+
+HRESULT RegisterWindow(HWND window, const wchar_t* path) {
+    try {
+        return GetRenderer().RegisterWindow(window, path);
+    }
+    catch(const std::bad_alloc&) {
+        return E_OUTOFMEMORY;
+    }
+    catch(...) {
+        return E_FAIL;
+    }
+}
+
+HRESULT UpdateWindow(HWND window, const wchar_t* path) {
+    try {
+        return GetRenderer().UpdateWindow(window, path);
+    }
+    catch(const std::bad_alloc&) {
+        return E_OUTOFMEMORY;
+    }
+    catch(...) {
+        return E_FAIL;
+    }
+}
+
+void OnCompatibleDcCreated(HDC sourceDc, HDC compatibleDc) noexcept {
+    GetRenderer().OnCompatibleDcCreated(sourceDc, compatibleDc);
+}
+
+void OnWindowDcAcquired(HWND window, HDC dc) noexcept {
+    GetRenderer().OnWindowDcAcquired(window, dc);
+}
+
+void OnDcDeleted(HDC dc) noexcept {
+    GetRenderer().OnDcDeleted(dc);
+}
+
+void OnFillRect(HDC targetDc, const RECT* paintedRect) noexcept {
+    GetRenderer().OnFillRect(targetDc, paintedRect);
+}
+
+}  // namespace background
+}  // namespace qttabbar
diff --git a/QTHookLib/ExplorerBackgroundRenderer.h b/QTHookLib/ExplorerBackgroundRenderer.h
new file mode 100644
index 0000000..84a15ac
--- /dev/null
+++ b/QTHookLib/ExplorerBackgroundRenderer.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <windows.h>
+
+namespace qttabbar {
+namespace background {
+
+HRESULT Initialize(HMODULE module);
+void Shutdown() noexcept;
+bool IsActive() noexcept;
+
+HRESULT RegisterWindow(HWND window, const wchar_t* path);
+HRESULT UpdateWindow(HWND window, const wchar_t* path);
+
+void OnWindowDcAcquired(HWND window, HDC dc) noexcept;
+void OnCompatibleDcCreated(HDC sourceDc, HDC compatibleDc) noexcept;
+void OnDcDeleted(HDC dc) noexcept;
+void OnFillRect(HDC targetDc, const RECT* paintedRect) noexcept;
+
+}  // namespace background
+}  // namespace qttabbar
diff --git a/QTHookLib/QTHookLib.vcxproj b/QTHookLib/QTHookLib.vcxproj
index c4dce08..1eb4e35 100644
--- a/QTHookLib/QTHookLib.vcxproj
+++ b/QTHookLib/QTHookLib.vcxproj
@@ -162,10 +162,14 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="ExplorerBackgroundRenderer.cpp" />
+    <ClCompile Include="ScopedBackgroundHooks.cpp" />
     <ClCompile Include="main.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="CComPtr.h" />
+    <ClInclude Include="ExplorerBackgroundRenderer.h" />
+    <ClInclude Include="ScopedBackgroundHooks.h" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\MinHook\libMinHook.vcxproj">
diff --git a/QTHookLib/ScopedBackgroundHooks.cpp b/QTHookLib/ScopedBackgroundHooks.cpp
new file mode 100644
index 0000000..8e44bf6
--- /dev/null
+++ b/QTHookLib/ScopedBackgroundHooks.cpp
@@ -0,0 +1,189 @@
+#include "ScopedBackgroundHooks.h"
+
+#include "ExplorerBackgroundRenderer.h"
+#include "../MinHook/MinHook.h"
+
+#include <array>
+#include <atomic>
+#include <mutex>
+
+namespace qttabbar {
+namespace background {
+namespace hooks {
+namespace {
+
+using FillRectFn = int (WINAPI*)(HDC, const RECT*, HBRUSH);
+using CreateCompatibleDcFn = HDC (WINAPI*)(HDC);
+using DeleteDcFn = BOOL (WINAPI*)(HDC);
+using BeginPaintFn = HDC (WINAPI*)(HWND, LPPAINTSTRUCT);
+using EndPaintFn = BOOL (WINAPI*)(HWND, const PAINTSTRUCT*);
+
+std::mutex hookMutex;
+std::atomic<bool> installed{false};
+bool ownsMinHook = false;
+
+FillRectFn originalFillRect = nullptr;
+CreateCompatibleDcFn originalCreateCompatibleDc = nullptr;
+DeleteDcFn originalDeleteDc = nullptr;
+BeginPaintFn originalBeginPaint = nullptr;
+EndPaintFn originalEndPaint = nullptr;
+
+const std::array<LPVOID, 5> targets{{
+    reinterpret_cast<LPVOID>(&::BeginPaint),
+    reinterpret_cast<LPVOID>(&::CreateCompatibleDC),
+    reinterpret_cast<LPVOID>(&::FillRect),
+    reinterpret_cast<LPVOID>(&::EndPaint),
+    reinterpret_cast<LPVOID>(&::DeleteDC),
+}};
+
+HDC WINAPI ScopedBeginPaint(HWND window, LPPAINTSTRUCT paint) {
+    HDC const dc = originalBeginPaint != nullptr
+        ? originalBeginPaint(window, paint)
+        : nullptr;
+    OnWindowDcAcquired(window, dc);
+    return dc;
+}
+
+HDC WINAPI ScopedCreateCompatibleDc(HDC sourceDc) {
+    HDC const compatibleDc = originalCreateCompatibleDc != nullptr
+        ? originalCreateCompatibleDc(sourceDc)
+        : nullptr;
+    OnCompatibleDcCreated(sourceDc, compatibleDc);
+    return compatibleDc;
+}
+
+int WINAPI ScopedFillRect(HDC dc, const RECT* rect, HBRUSH brush) {
+    const int result = originalFillRect != nullptr
+        ? originalFillRect(dc, rect, brush)
+        : 0;
+    if(result != 0) {
+        static thread_local bool dispatching = false;
+        if(!dispatching) {
+            dispatching = true;
+            OnFillRect(dc, rect);
+            dispatching = false;
+        }
+    }
+    return result;
+}
+
+BOOL WINAPI ScopedEndPaint(HWND window, const PAINTSTRUCT* paint) {
+    const BOOL result = originalEndPaint != nullptr
+        ? originalEndPaint(window, paint)
+        : FALSE;
+    if(paint != nullptr) {
+        OnDcDeleted(paint->hdc);
+    }
+    return result;
+}
+
+BOOL WINAPI ScopedDeleteDc(HDC dc) {
+    OnDcDeleted(dc);
+    return originalDeleteDc != nullptr ? originalDeleteDc(dc) : FALSE;
+}
+
+HRESULT HookFailure(MH_STATUS status) noexcept {
+    return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF,
+        static_cast<USHORT>(0x300 + static_cast<unsigned int>(status)));
+}
+
+void ClearOriginals() noexcept {
+    originalFillRect = nullptr;
+    originalCreateCompatibleDc = nullptr;
+    originalDeleteDc = nullptr;
+    originalBeginPaint = nullptr;
+    originalEndPaint = nullptr;
+}
+
+}  // namespace
+
+HRESULT Install() {
+    std::lock_guard<std::mutex> guard(hookMutex);
+    if(installed.load(std::memory_order_acquire)) {
+        return S_OK;
+    }
+
+    MH_STATUS status = MH_Initialize();
+    if(status != MH_OK) {
+        return HookFailure(status);
+    }
+    ownsMinHook = true;
+
+    struct HookDefinition {
+        LPVOID target;
+        LPVOID detour;
+        LPVOID* original;
+    };
+    const std::array<HookDefinition, 5> definitions{{
+        {targets[0], reinterpret_cast<LPVOID>(&ScopedBeginPaint),
+            reinterpret_cast<LPVOID*>(&originalBeginPaint)},
+        {targets[1], reinterpret_cast<LPVOID>(&ScopedCreateCompatibleDc),
+            reinterpret_cast<LPVOID*>(&originalCreateCompatibleDc)},
+        {targets[2], reinterpret_cast<LPVOID>(&ScopedFillRect),
+            reinterpret_cast<LPVOID*>(&originalFillRect)},
+        {targets[3], reinterpret_cast<LPVOID>(&ScopedEndPaint),
+            reinterpret_cast<LPVOID*>(&originalEndPaint)},
+        {targets[4], reinterpret_cast<LPVOID>(&ScopedDeleteDc),
+            reinterpret_cast<LPVOID*>(&originalDeleteDc)},
+    }};
+
+    std::size_t created = 0;
+    for(; created < definitions.size(); ++created) {
+        status = MH_CreateHook(definitions[created].target,
+            definitions[created].detour, definitions[created].original);
+        if(status != MH_OK) {
+            break;
+        }
+    }
+    if(created != definitions.size()) {
+        MH_Uninitialize();
+        ownsMinHook = false;
+        ClearOriginals();
+        return HookFailure(status);
+    }
+
+    std::size_t enabled = 0;
+    for(; enabled < definitions.size(); ++enabled) {
+        status = MH_EnableHook(definitions[enabled].target);
+        if(status != MH_OK) {
+            break;
+        }
+    }
+    if(enabled != definitions.size()) {
+        while(enabled > 0) {
+            --enabled;
+            MH_DisableHook(definitions[enabled].target);
+        }
+        MH_Uninitialize();
+        ownsMinHook = false;
+        ClearOriginals();
+        return HookFailure(status);
+    }
+
+    installed.store(true, std::memory_order_release);
+    return S_OK;
+}
+
+void Remove() noexcept {
+    std::lock_guard<std::mutex> guard(hookMutex);
+    if(!installed.exchange(false, std::memory_order_acq_rel)) {
+        return;
+    }
+
+    for(std::size_t index = targets.size(); index > 0; --index) {
+        MH_DisableHook(targets[index - 1]);
+    }
+    if(ownsMinHook) {
+        MH_Uninitialize();
+    }
+    ownsMinHook = false;
+    ClearOriginals();
+}
+
+bool IsInstalled() noexcept {
+    return installed.load(std::memory_order_acquire);
+}
+
+}  // namespace hooks
+}  // namespace background
+}  // namespace qttabbar
diff --git a/QTHookLib/ScopedBackgroundHooks.h b/QTHookLib/ScopedBackgroundHooks.h
new file mode 100644
index 0000000..aed1931
--- /dev/null
+++ b/QTHookLib/ScopedBackgroundHooks.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <windows.h>
+
+namespace qttabbar {
+namespace background {
+namespace hooks {
+
+HRESULT Install();
+void Remove() noexcept;
+bool IsInstalled() noexcept;
+
+}  // namespace hooks
+}  // namespace background
+}  // namespace qttabbar
diff --git a/QTHookLib/main.cpp b/QTHookLib/main.cpp
index b1fcb8c..58951bc 100644
--- a/QTHookLib/main.cpp
+++ b/QTHookLib/main.cpp
@@ -35,6 +35,8 @@
 #pragma comment(lib, "GdiPlus.lib")
 
 #include "CComPtr.h"
+#include "ExplorerBackgroundRenderer.h"
+#include "ScopedBackgroundHooks.h"
 #include "..\MinHook\MinHook.h"
 
 
@@ -198,6 +200,7 @@ struct CallbackStruct {
     bool (*fpNewWindow)(LPCITEMIDLIST pIDL);
 };
 CallbackStruct callbacks;
+volatile LONG g_backgroundInitializationState = 0;
 
 // Other stuff
 HMODULE hModAutomation = NULL;
@@ -535,11 +538,14 @@ extern "C" __declspec(dllexport) int InitializeBackground(CallbackStruct* cb);
 extern "C" __declspec(dllexport) int Dispose();
 extern "C" __declspec(dllexport) int InitShellBrowserHook(IShellBrowser* psb);
 extern "C" __declspec(dllexport) int RegisterBackgroundWindow(HWND hwnd);
+extern "C" __declspec(dllexport) int UpdateBackgroundWindow(HWND hwnd, LPCWSTR path);
 
 BOOL APIENTRY DllMain(HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) {
     switch (ul_reason_for_call) {
         case DLL_PROCESS_DETACH:
-            return Dispose();
+            // Hook shutdown is performed explicitly by HookLibraryBridge before
+            // FreeLibrary. Avoid MinHook/GDI cleanup while the loader lock is held.
+            break;
 
         case DLL_PROCESS_ATTACH:
         case DLL_THREAD_ATTACH:
@@ -670,37 +676,36 @@ int Initialize(CallbackStruct* cb) {
 
 
 int InitializeBackground(CallbackStruct* cb) {
-    volatile static long initialized;
-    if (InterlockedIncrement(&initialized) != 1) {
-        initialized = 1;
+    const LONG state = InterlockedCompareExchange(&g_backgroundInitializationState, 1, 0);
+    if(state == 2) {
         return MH_OK;
     }
+    if(state != 0) {
+        return HRESULT_FROM_WIN32(ERROR_BUSY);
+    }
+    if(!cb) {
+        InterlockedExchange(&g_backgroundInitializationState, 0);
+        return E_INVALIDARG;
+    }
 
-    if (!cb) return E_INVALIDARG;
-
-    srand((int)time(0));
-    MH_STATUS ret = MH_Initialize();
-    if (ret != MH_OK && ret != MH_ERROR_ALREADY_INITIALIZED) return ret;
-
-    callbacks = *cb;
-    if (m_gdiplusToken == 0) {
-        Gdiplus::GdiplusStartupInput startupInput;
-        if (Gdiplus::GdiplusStartup(&m_gdiplusToken, &startupInput, nullptr) != Gdiplus::Ok) {
-            m_gdiplusToken = 0;
-            return ERROR_DLL_INIT_FAILED;
-        }
+    // Build and validate the complete immutable image snapshot before any
+    // process-wide drawing function is intercepted.
+    const HRESULT rendererResult = qttabbar::background::Initialize(g_hModule);
+    if(rendererResult != S_OK) {
+        InterlockedExchange(&g_backgroundInitializationState, 0);
+        return rendererResult;
     }
 
-    // Background-only mode intentionally avoids the legacy Shell, window capture,
-    // navigation and drag/drop hooks. These four hooks are the complete drawing
-    // path used by a DirectUIHWND registered through RegisterBackgroundWindow.
-    CREATE_HOOK(&DestroyWindow, DestroyWindow)
-    CREATE_HOOK(&BeginPaint, BeginPaint)
-    CREATE_HOOK(&FillRect, FillRect)
-    CREATE_HOOK(&CreateCompatibleDC, CreateCompatibleDC)
-    LoadSettings(true);
+    const HRESULT hookResult = qttabbar::background::hooks::Install();
+    if(FAILED(hookResult)) {
+        qttabbar::background::Shutdown();
+        InterlockedExchange(&g_backgroundInitializationState, 0);
+        return hookResult;
+    }
 
-    return MH_OK;
+    callbacks = *cb;
+    InterlockedExchange(&g_backgroundInitializationState, 2);
+    return S_OK;
 }
 
 
@@ -740,6 +745,9 @@ int InitShellBrowserHook(IShellBrowser* psb) {
 }
 
 int RegisterBackgroundWindow(HWND hwnd) {
+    if(qttabbar::background::IsActive()) {
+        return qttabbar::background::RegisterWindow(hwnd, nullptr);
+    }
     if (!IsWindow(hwnd)) return E_INVALIDARG;
 
     wchar_t className[64] = {};
@@ -759,8 +767,20 @@ int RegisterBackgroundWindow(HWND hwnd) {
     return S_OK;
 }
 
+int UpdateBackgroundWindow(HWND hwnd, LPCWSTR path) {
+    if(!qttabbar::background::IsActive()) {
+        return E_NOTIMPL;
+    }
+    return qttabbar::background::UpdateWindow(hwnd, path);
+}
+
 int Dispose() {
-    // Uninitialize MinHook.
+    if(qttabbar::background::IsActive()) {
+        qttabbar::background::hooks::Remove();
+        qttabbar::background::Shutdown();
+        InterlockedExchange(&g_backgroundInitializationState, 0);
+    }
+    // Uninitialize MinHook after renderer state is no longer reachable by hooks.
     MH_Uninitialize();
 
     // Free the Automation library
@@ -916,7 +936,6 @@ int WINAPI DetourFillRect(HDC hDC, const RECT* lprc, HBRUSH hbr)
 {
     int ret = fpFillRect(hDC, lprc, hbr);
 
-
 	// Box1(L"DetourFillRect in ");
 	auto iter = m_duiList.find(GetCurrentThreadId());
     if (iter != m_duiList.end()) {
@@ -1084,7 +1103,6 @@ HDC WINAPI DetourCreateCompatibleDC(HDC hDC)
     return retDC;
 }
 
-
 // The purpose of this hook is to intercept the creation of the NameSpaceTreeControl object, and 
 // send a reference to the control to QTTabBar.  We can use this reference to hit test the
 // control, which is how opening new tabs from middle-click works.
diff --git a/QTTabBar/HookLibManager.cs b/QTTabBar/HookLibManager.cs
index d6a462b..7a5b5b9 100644
--- a/QTTabBar/HookLibManager.cs
+++ b/QTTabBar/HookLibManager.cs
@@ -28,6 +28,7 @@ namespace QTTabBarLib {
     public static class HookLibManager {
         private static bool fShellBrowserIsHooked;
         private static bool fHookLibraryLoaded;
+        private static bool fBackgroundRendererLoaded;
         private static int[] hookStatus = Enumerable.Repeat(-1, Enum.GetNames(typeof(Hooks)).Length).ToArray();
 
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
@@ -54,6 +55,12 @@ private struct HookCallbacks
         [DllImport("QTTabBarNative.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
         private static extern int QTTabBarNative_InitializeBackgroundLibrary(ref HookCallbacks callbacks, string libraryPath);
 
+        [DllImport("QTTabBarNative.dll", CallingConvention = CallingConvention.StdCall)]
+        private static extern int QTTabBarNative_InitializeBackgroundRenderer(ref HookCallbacks callbacks);
+
+        [DllImport("QTTabBarNative.dll", CallingConvention = CallingConvention.StdCall)]
+        private static extern int QTTabBarNative_InstallBackgroundHooks();
+
         [DllImport("QTTabBarNative.dll", CallingConvention = CallingConvention.StdCall)]
         private static extern void QTTabBarNative_ShutdownHookLibrary();
 
@@ -63,6 +70,10 @@ private struct HookCallbacks
         [DllImport("QTTabBarNative.dll", CallingConvention = CallingConvention.StdCall)]
         private static extern int QTTabBarNative_RegisterBackgroundWindow(IntPtr window);
 
+        [DllImport("QTTabBarNative.dll", CallingConvention = CallingConvention.StdCall,
+            CharSet = CharSet.Unicode)]
+        private static extern int QTTabBarNative_UpdateBackgroundWindow(IntPtr window, string path);
+
         [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
         private static extern uint GetPrivateProfileString(string section, string key,
                 string defaultValue, StringBuilder value, uint size, string filePath);
@@ -180,6 +191,7 @@ public static void Initialize()
                     QTTabBarNative_ShutdownHookLibrary();
                 }
                 fHookLibraryLoaded = false;
+                fBackgroundRendererLoaded = false;
                 LoadedHook = false;
                 QTUtility2.flog("Legacy QTHookLib disabled by safe mode; Explorer background is not enabled");
                 return;
@@ -193,9 +205,6 @@ public static void Initialize()
                     return;
                 }
                 
-                if(backgroundOnly) {
-                    QTUtility2.flog("Loading isolated Explorer background renderer; legacy Shell hooks remain disabled");
-                }
                 ManagementObjectSearcher searcher = backgroundOnly
                         ? null
                         : new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem");
@@ -237,6 +246,7 @@ public static void Initialize()
                 {
                     QTTabBarNative_ShutdownHookLibrary();
                     fHookLibraryLoaded = false;
+                    fBackgroundRendererLoaded = false;
                     LoadedHook = false;
                 }
                 return;
@@ -244,28 +254,18 @@ public static void Initialize()
 
             if (!shouldLoadHookLibrary)
             {
+                fBackgroundRendererLoaded = false;
                 LoadedHook = false;
                 return;
             }
 
-            if (!File.Exists(Path.Combine(installPath, filename))) // 如果文件不存在则设置为不自动加载
+            if (!backgroundOnly && !File.Exists(Path.Combine(installPath, filename))) // 如果文件不存在则设置为不自动加载
             {
                 QTUtility2.flog("not exists file , close auto hook " + Path.Combine(installPath, filename));
                 Config.Window.AutoHookWindow = false;
                 LoadedHook = false;
                 return;
             }
-            QTUtility2.flog("load library " + Path.Combine(installPath, filename) );
-            string bridgePath = Path.Combine(installPath, "QTTabBarNative.dll");
-            try
-            {
-                string bridgeVersion = System.Diagnostics.FileVersionInfo.GetVersionInfo(bridgePath).FileVersion;
-                QTUtility2.flog("hook bridge " + bridgePath + " version " + bridgeVersion);
-            }
-            catch (Exception ex)
-            {
-                QTUtility2.MakeErrorLog(ex, "Could not read the native hook bridge version.");
-            }
             if(!FluentGlassManager.EnsureNativeModuleLoaded()) {
                 QTUtility2.log("Hook library skipped: QTTabBarNative.dll could not be loaded from ProgramData.");
                 fHookLibraryLoaded = false;
@@ -276,9 +276,19 @@ public static void Initialize()
             int hr = -1;
             try
             {
-                hr = backgroundOnly
-                        ? QTTabBarNative_InitializeBackgroundLibrary(ref nativeCallbacks, Path.Combine(installPath, filename))
-                        : QTTabBarNative_InitializeHookLibrary(ref nativeCallbacks, Path.Combine(installPath, filename));
+                if(backgroundOnly) {
+                    hr = QTTabBarNative_InitializeBackgroundRenderer(ref nativeCallbacks);
+                    if(hr == 0) {
+                        int hookHr = QTTabBarNative_InstallBackgroundHooks();
+                        if(hookHr != 0) {
+                            hr = hookHr;
+                        }
+                    }
+                }
+                else {
+                    hr = QTTabBarNative_InitializeHookLibrary(ref nativeCallbacks,
+                            Path.Combine(installPath, filename));
+                }
             }
             catch (DllNotFoundException ex)
             {
@@ -305,16 +315,14 @@ public static void Initialize()
             if (hr == 0)
             {
                 fHookLibraryLoaded = true;
+                fBackgroundRendererLoaded = backgroundOnly;
                 LoadedHook = true;
-                QTUtility2.log(backgroundOnly
-                        ? "Explorer background renderer initialize success"
-                        : "HookLib Initialize success");
-                // MessageBox.Show("HookLib Initialize success");
                 return;
             }
             QTUtility2.MakeErrorLog(null, "HookLib Initialize failed: 0x" + hr.ToString("X8"));
             LoadedHook = false;
             fHookLibraryLoaded = false;
+            fBackgroundRendererLoaded = false;
         }
 
         private static bool IsLegacyHookExplicitlyEnabled(string installPath)
@@ -351,15 +359,22 @@ private static bool IsExplorerBackgroundEnabled(string installPath)
                 if(File.Exists(imagePath)) return true;
             }
 
-            string imageDirectory = Path.Combine(installPath, "Image");
+            value.Clear();
+            GetPrivateProfileString("image", "folder", "Image", value,
+                    (uint)value.Capacity, configPath);
+            string imageDirectory = Environment.ExpandEnvironmentVariables(
+                    value.ToString().Trim().Trim('"'));
+            if(String.IsNullOrEmpty(imageDirectory)) imageDirectory = "Image";
+            if(!Path.IsPathRooted(imageDirectory)) imageDirectory = Path.Combine(installPath, imageDirectory);
             if(!Directory.Exists(imageDirectory)) return false;
             return Directory.EnumerateFiles(imageDirectory).Any(path =>
                     path.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ||
+                    path.EndsWith(".bmp", StringComparison.OrdinalIgnoreCase) ||
                     path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) ||
                     path.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase));
         }
 
-        internal static void RegisterBackgroundWindow(IntPtr window)
+        internal static void RegisterBackgroundWindow(IntPtr window, string path = null)
         {
             if(!fHookLibraryLoaded || window == IntPtr.Zero) return;
             try {
@@ -368,7 +383,9 @@ internal static void RegisterBackgroundWindow(IntPtr window)
                     QTUtility2.log("RegisterBackgroundWindow failed: 0x" + result.ToString("X8"));
                 }
                 else {
-                    QTUtility2.flog("RegisterBackgroundWindow success hwnd=0x" + window.ToInt64().ToString("X"));
+                    if(!String.IsNullOrEmpty(path)) {
+                        UpdateBackgroundWindow(window, path);
+                    }
                 }
             }
             catch(Exception ex) {
@@ -376,6 +393,19 @@ internal static void RegisterBackgroundWindow(IntPtr window)
             }
         }
 
+        internal static void UpdateBackgroundWindow(IntPtr window, string path)
+        {
+            if(!fHookLibraryLoaded || window == IntPtr.Zero) return;
+            try {
+                int result = QTTabBarNative_UpdateBackgroundWindow(window, path ?? String.Empty);
+                if(result != 0) {
+                    QTUtility2.log("UpdateBackgroundWindow failed: 0x" + result.ToString("X8"));
+                }
+            }
+            catch(Exception ex) {
+                QTUtility2.MakeErrorLog(ex, "UpdateBackgroundWindow");
+            }
+        }
 
         private static void HookResult(int hookId, int retcode, IntPtr context) {
             try {
@@ -432,7 +462,14 @@ public static void InitShellBrowserHook(IShellBrowser shellBrowser)
         {
             lock (typeof(HookLibManager))
             {
-                if(fShellBrowserIsHooked || !fHookLibraryLoaded) return;
+                if(fShellBrowserIsHooked || !fHookLibraryLoaded || fBackgroundRendererLoaded)
+                {
+                    if(fBackgroundRendererLoaded)
+                    {
+                        QTUtility2.flog("InitShellBrowserHook skipped for isolated background renderer");
+                    }
+                    return;
+                }
                 IntPtr pShellBrowser = Marshal.GetComInterfaceForObject(shellBrowser, typeof(IShellBrowser));
                 if(pShellBrowser == IntPtr.Zero) return;
                 int retcode = -1;
diff --git a/QTTabBar/ListViewMonitor.cs b/QTTabBar/ListViewMonitor.cs
index 8dc810f..763b4c8 100644
--- a/QTTabBar/ListViewMonitor.cs
+++ b/QTTabBar/ListViewMonitor.cs
@@ -106,6 +106,17 @@ private void RecaptureHandles(IntPtr hwndShellView) {
                 QTUtility2.log("new ExtendedItemsView");
                 CurrentListView = new ExtendedItemsView(ShellBrowser, hwndShellView, hwndListView, hwndSubDirTipMessageReflect);
             }
+            if(!fIsSysListView && hwndListView != IntPtr.Zero) {
+                try {
+                    using(IDLWrapper path = ShellBrowser.GetShellPath()) {
+                        HookLibManager.UpdateBackgroundWindow(hwndListView,
+                            path != null && path.Available ? path.Path : String.Empty);
+                    }
+                }
+                catch(Exception ex) {
+                    QTUtility2.MakeErrorLog(ex, "Explorer background initial path");
+                }
+            }
             CurrentListView.ListViewDestroyed += ListView_Destroyed;
             ListViewChanged(this, null);
         }
diff --git a/QTTabBar/Properties/AssemblyInfo.cs b/QTTabBar/Properties/AssemblyInfo.cs
index 29bbb56..1cba6ac 100644
--- a/QTTabBar/Properties/AssemblyInfo.cs
+++ b/QTTabBar/Properties/AssemblyInfo.cs
@@ -54,8 +54,8 @@
 // You can specify all the values or you can default the Revision and Build Numbers 
 // by using the '*' as shown below:
 
-[assembly: AssemblyVersion("1.5.62.0")]
-[assembly: AssemblyFileVersion("1.5.62.0")]	// edit this
+[assembly: AssemblyVersion("1.5.79.0")]
+[assembly: AssemblyFileVersion("1.5.79.0")]	// edit this
 //
 // In order to sign your assembly you must specify a key to use. Refer to the 
 // Microsoft .NET Framework documentation for more information on assembly signing.
diff --git a/QTTabBar/QTTabBarClass.cs b/QTTabBar/QTTabBarClass.cs
index a931a89..d98304a 100644
--- a/QTTabBar/QTTabBarClass.cs
+++ b/QTTabBar/QTTabBarClass.cs
@@ -3122,6 +3122,10 @@ private void Explorer_NavigateComplete2(object pDisp, ref object URL) {
                     tabControl1.SetRedraw(true);
                     ApplyFluentGlass();
                     ScheduleFluentGlassRefresh();
+                    if(listViewManager != null && listViewManager.CurrentListView != null) {
+                        HookLibManager.UpdateBackgroundWindow(
+                            listViewManager.CurrentListView.Handle, path);
+                    }
                     FirstNavigationCompleted = true;
                     RefreshTaskbarTabPreviews(true);
                     // this.listView
diff --git a/QTTabBar/QTUtility.cs b/QTTabBar/QTUtility.cs
index eda47f9..ba807c8 100644
--- a/QTTabBar/QTUtility.cs
+++ b/QTTabBar/QTUtility.cs
@@ -42,7 +42,7 @@
 namespace QTTabBarLib {
     internal static class QTUtility {
         internal static readonly Version BetaRevision = new Version(0, 0);
-        internal static readonly Version CurrentVersion = new Version(1, 5, 62, 0);
+        internal static readonly Version CurrentVersion = new Version(1, 5, 79, 0);
         internal static readonly string BuildVerion = string.Empty;
         internal const int FIRST_MOUSE_ONLY_ACTION = 1000;
         internal static readonly string REG_PERSONALIZE = @"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize";
diff --git a/QTTabBar/TaskbarTabPreviewManager.cs b/QTTabBar/TaskbarTabPreviewManager.cs
index 5e436af..656dedc 100644
--- a/QTTabBar/TaskbarTabPreviewManager.cs
+++ b/QTTabBar/TaskbarTabPreviewManager.cs
@@ -427,7 +427,6 @@ private interface ITaskbarList3 {
         public TaskbarTabPreviewManager(Action<int> activateCallback, Action<int> closeCallback) {
             this.activateCallback = activateCallback;
             this.closeCallback = closeCallback;
-            QTUtility2.log("TaskbarTabPreviewManager build=1.5.62.0 Stable mode=isolated-explorer-background deferred-thumbnail-close sharp-offset-live-preview owned-proxies fixed-versatile-width");
         }
 
         public void Update(IntPtr ownerExplorerHandle, bool enable, IList<Entry> entries) {
diff --git a/README.md b/README.md
index 79d42cd..f6c80d0 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ An enhanced native/managed QTTabBar fork for the classic Windows Explorer interf
 
 ## Stable release
 
-Current version: **1.5.62.0 Stable**
+Current version: **1.5.70.0 Stable**
 
 Download the installer from [GitHub Releases](https://github.com/akaydev-coder/qttabbar_native_enhanced/releases/latest).
 
@@ -22,7 +22,7 @@ Download the installer from [GitHub Releases](https://github.com/akaydev-coder/q
 - Per-tab taskbar thumbnails and full-size DWM live previews
 - Taskbar thumbnail activation and close-button support
 - Explorer background images configured through `C:\ProgramData\QTTabBar\config.ini`
-- Isolated background renderer that leaves legacy Shell hooks disabled by default
+- Background renderer owned by the stable native bridge; the legacy hook DLL remains unloaded by default
 - Stable options dialog lifecycle and runtime settings refresh
 - Explorer registration, toolbar persistence, focus and Win+E capture fixes
 
@@ -35,7 +35,7 @@ Windows 11 may require a classic Explorer restoration solution. Test changes in
 
 ## Installation
 
-1. Download `QTTabBar Setup - 1.5.62.0 Stable.exe` from the latest release.
+1. Download `QTTabBar Setup - 1.5.70.0 Stable.exe` from the latest release.
 2. Run the installer as an administrator.
 3. Restart Windows when requested.
 4. In Explorer, enable **QTTabBar** under **View > Toolbars**.
@@ -45,7 +45,7 @@ Error logs are written to `%APPDATA%\QTTabBar\QTTabBarException.log`.
 
 ## Explorer background
 
-The installer creates `C:\ProgramData\QTTabBar\config.ini` and a default `libai.png` image. The background renderer is independent from the disabled legacy Shell hooks.
+The installer creates `C:\ProgramData\QTTabBar\config.ini` and a default `libai.png` image. The background renderer runs directly inside `QTTabBarNative.dll`; it does not load the legacy `QTHookLib` in background-only mode. Images are decoded through Windows Imaging Component into premultiplied `32bppPBGRA` surfaces before only the required `dui70.dll` import slots are patched.
 
 ```ini
 [hook]
@@ -54,6 +54,8 @@ enabled=false
 [image]
 enabled=true
 random=false
+folder=Image
+custom=false
 posType=3
 imgAlpha=255
 imgPath=%ProgramData%\QTTabBar\libai.png
@@ -61,6 +63,15 @@ imgPath=%ProgramData%\QTTabBar\libai.png
 
 `posType` values: `0` top-left, `1` top-right, `2` bottom-left, `3` bottom-right, `4` centered, `5` stretch, `6` zoom-fill.
 
+Place additional PNG/BMP/JPG/JPEG files in the configured `folder`. With `custom=true`, a section named after an Explorer path can select one of those files:
+
+```ini
+[C:\Users\Public\Pictures]
+img=example.png
+```
+
+Hold Escape while Explorer starts to bypass background initialization for recovery.
+
 ## Building
 
 Requirements:
@@ -95,4 +106,3 @@ Major integration, debugging and implementation assistance for this enhanced edi
 ## License
 
 This project is distributed under the [GNU General Public License v3.0](LICENSE.txt). Existing copyright and attribution notices in inherited source files remain in effect.
-
diff --git a/docs/releases/v1.5.64.0.md b/docs/releases/v1.5.64.0.md
new file mode 100644
index 0000000..4b5816e
--- /dev/null
+++ b/docs/releases/v1.5.64.0.md
@@ -0,0 +1,22 @@
+# QTTabBar Native Enhanced 1.5.64.0 Stable
+
+This maintenance release replaces the crash-prone Explorer background-image path with a module-scoped renderer.
+
+## Changes
+
+- Removes MinHook from background-only initialization
+- Patches only `FillRect`, `CreateCompatibleDC` and `DeleteDC` imports in `dui70.dll`
+- Chains through pre-existing API hooks instead of replacing them
+- Tracks only explicitly registered Explorer `DirectUIHWND` folder views
+- Uses premultiplied 32-bit alpha rendering for PNG/BMP/JPEG files
+- Supports image folders, random image selection and path-specific profiles
+- Reloads valid configuration changes without exposing partial renderer state
+- Uses window-property tokens to reject stale or reused window handles
+- Keeps the legacy process-wide Shell hook path disabled by default
+- Allows holding Escape during Explorer startup to bypass background initialization
+
+## Installation
+
+Run the setup executable as administrator and restart Windows when requested. This release targets Windows 10 x64 and .NET Framework 4.8.
+
+SHA-256: `9C1140D67F9728CB23037C7A541282960608BB3505E9642D11B22262EC6D4C87`
diff --git a/docs/releases/v1.5.65.0.md b/docs/releases/v1.5.65.0.md
new file mode 100644
index 0000000..5d28865
--- /dev/null
+++ b/docs/releases/v1.5.65.0.md
@@ -0,0 +1,18 @@
+# QTTabBar Native Enhanced 1.5.65.0 Stable
+
+This compatibility release removes the legacy hook library from the normal Explorer-background startup path.
+
+## Changes
+
+- Hosts the Explorer background renderer directly in `QTTabBarNative.dll`
+- Does not load `QTHookLib32.dll` or `QTHookLib64.dll` when only background images are enabled
+- Keeps legacy Shell hooks available only when `[hook] enabled=true` is explicitly configured
+- Retains the three scoped `dui70.dll` imports and registered-window filtering
+- Preserves PNG/BMP/JPEG alpha rendering, image folders, random selection and path profiles
+- Keeps Escape startup recovery for problematic configurations
+
+## Installation
+
+Run the setup executable as administrator and restart Windows when requested. This release targets Windows 10 x64 and .NET Framework 4.8.
+
+SHA-256: `9D6EC3E4A333B0B97A5A8DCF77755221BD55C4090C9495354F6508F52A1610D9`
diff --git a/docs/releases/v1.5.66.0.md b/docs/releases/v1.5.66.0.md
new file mode 100644
index 0000000..cae33da
--- /dev/null
+++ b/docs/releases/v1.5.66.0.md
@@ -0,0 +1,18 @@
+# QTTabBar Native Enhanced 1.5.66.0 Stable
+
+This compatibility release hardens Explorer background initialization for later Windows 10 22H2 servicing builds.
+
+## Changes
+
+- Validates every `dui70.dll` PE import descriptor and thunk before access
+- Bounds import-name scans to the loaded module image
+- Converts native parser and IAT access faults into HRESULT diagnostics
+- Separates image-renderer startup from scoped-hook activation in the log
+- Keeps Explorer operational if a serviced `dui70.dll` layout is unsupported
+- Continues to leave the legacy monolithic hook library unloaded by default
+
+## Installation
+
+Run the setup executable as administrator and restart Windows when requested. This release targets Windows 10 x64 and .NET Framework 4.8.
+
+SHA-256: `34DFACBDF7F88B16CAEB5276BCAF576F56C3B79C7249B96F6A57DFEEEBCFC94B`
diff --git a/docs/releases/v1.5.67.0.md b/docs/releases/v1.5.67.0.md
new file mode 100644
index 0000000..2986fdf
--- /dev/null
+++ b/docs/releases/v1.5.67.0.md
@@ -0,0 +1,17 @@
+# QTTabBar Native Enhanced 1.5.67.0 Stable
+
+This compatibility release replaces the Explorer background image decoder after isolating an access violation to the renderer stage on a later Windows 10 22H2 servicing build.
+
+## Changes
+
+- Uses Windows Imaging Component instead of GDI+ for PNG/BMP/JPEG decoding
+- Produces premultiplied `32bppPBGRA` pixels directly in the renderer DIB
+- Removes raw bitmap stride traversal from Explorer startup
+- Preserves phased renderer and scoped-hook diagnostics
+- Keeps validated `dui70.dll` imports and legacy-hook isolation
+
+## Installation
+
+Run the setup executable as administrator and restart Windows when requested. This release targets Windows 10 x64 and .NET Framework 4.8.
+
+SHA-256: `D06AC72D69C9D3FC587CF194A90C663A040E8B48598689C18A935E84114C81A3`
diff --git a/docs/releases/v1.5.68.0.md b/docs/releases/v1.5.68.0.md
new file mode 100644
index 0000000..bb16179
--- /dev/null
+++ b/docs/releases/v1.5.68.0.md
@@ -0,0 +1,20 @@
+# QTTabBar Native Enhanced 1.5.68.0 Stable
+
+This compatibility release removes the remaining platform-dependent operation from
+Explorer background renderer construction and makes guarded initialization failures
+phase-identifiable.
+
+## Changes
+
+- Replaces `std::random_device` with a deterministic visual-selection seed
+- Records each renderer initialization phase in lock-free native state
+- Logs whether a failure occurred during configuration, WIC decode, DIB creation,
+  pixel copying, or final state commit
+- Preserves the WIC image decoder and scoped `dui70.dll` hooks
+
+## Installation
+
+Run the setup executable as administrator and restart Windows when requested. This
+release targets Windows 10 x64 and .NET Framework 4.8.
+
+SHA-256: `A1BE5DFC3CC71218391C5C0D0F62F049668B525037A893A1483A6A1C91722BD4`
diff --git a/docs/releases/v1.5.69.0.md b/docs/releases/v1.5.69.0.md
new file mode 100644
index 0000000..4e19523
--- /dev/null
+++ b/docs/releases/v1.5.69.0.md
@@ -0,0 +1,19 @@
+# QTTabBar Native Enhanced 1.5.69.0 Stable
+
+This final compatibility attempt removes two differences exposed by the successful
+renderer diagnostics and comparison with the reference Explorer background hook.
+
+## Changes
+
+- Keeps background-only mode out of the legacy ShellBrowser-hook path
+- Patches only `FillRect` and `CreateCompatibleDC` imports in `dui70.dll`
+- Removes the extra `DeleteDC` patch
+- Bounds and refreshes compatible-DC mappings without intercepting DC destruction
+- Preserves WIC decoding and detailed initialization-phase diagnostics
+
+## Installation
+
+Run the setup executable as administrator and restart Windows when requested. This
+release targets Windows 10 x64 and .NET Framework 4.8.
+
+SHA-256: `3B68FEA87DC89FF5B95902EAEE8D124AAD74B4E9D57E99E5C67C2E8688C81143`
diff --git a/docs/releases/v1.5.70.0.md b/docs/releases/v1.5.70.0.md
new file mode 100644
index 0000000..e1e6837
--- /dev/null
+++ b/docs/releases/v1.5.70.0.md
@@ -0,0 +1,18 @@
+# QTTabBar Native Enhanced 1.5.70.0 Stable
+
+This release completes the stable background renderer path by providing the paint-DC
+association used by the reference implementation without introducing a global hook.
+
+## Changes
+
+- Patches `BeginPaint` only in `ExplorerFrame.dll`
+- Associates the resulting HDC with registered `DirectUIHWND` file views
+- Keeps drawing hooks scoped to `dui70.dll`
+- Does not restore the removed `DeleteDC` interception
+
+## Installation
+
+Run the setup executable as administrator and restart Windows when requested. This
+release targets Windows 10 x64 and .NET Framework 4.8.
+
+SHA-256: `FA15F2039E235FE6CB460948888FE917A61B022A4C15BC05BEC9F292C8F657D1`
diff --git a/native/QTTabBarNative/HookLibraryBridge.cpp b/native/QTTabBarNative/HookLibraryBridge.cpp
index 4c90785..256d9ab 100644
--- a/native/QTTabBarNative/HookLibraryBridge.cpp
+++ b/native/QTTabBarNative/HookLibraryBridge.cpp
@@ -1,6 +1,8 @@
 #include "pch.h"
 
 #include "HookLibraryBridge.h"
+#include "..\..\QTHookLib\ExplorerBackgroundRenderer.h"
+#include "..\..\QTHookLib\ScopedBackgroundHooks.h"
 
 #include <shlwapi.h>
 
@@ -20,6 +22,7 @@ using InitializeFn = int(__cdecl*)(CallbackStruct*);
 using DisposeFn = int(__cdecl*)();
 using InitShellBrowserHookFn = int(__cdecl*)(IShellBrowser*);
 using RegisterBackgroundWindowFn = int(__cdecl*)(HWND);
+using UpdateBackgroundWindowFn = int(__cdecl*)(HWND, LPCWSTR);
 
 int InitializeWithSeh(InitializeFn initialize, CallbackStruct* callbacks, DWORD& exceptionCode) noexcept {
     exceptionCode = ERROR_SUCCESS;
@@ -43,6 +46,15 @@ bool DisposeWithSeh(DisposeFn dispose, DWORD& exceptionCode) noexcept {
 }
 
 std::mutex g_mutex;
+
+HMODULE CurrentModule() noexcept {
+    HMODULE module = nullptr;
+    const DWORD flags = GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
+        GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT;
+    ::GetModuleHandleExW(flags,
+        reinterpret_cast<LPCWSTR>(&CurrentModule), &module);
+    return module;
+}
 }  // namespace
 
 HookLibraryBridge& HookLibraryBridge::Instance() {
@@ -56,7 +68,56 @@ HRESULT HookLibraryBridge::Initialize(const HookCallbacks& callbacks, const wcha
 
 HRESULT HookLibraryBridge::InitializeBackground(const HookCallbacks& callbacks,
                                                 const wchar_t* libraryPath) {
-    return InitializeEntry(callbacks, libraryPath, "InitializeBackground");
+    (void)libraryPath;
+    HRESULT result = InitializeBackgroundRenderer(callbacks);
+    return SUCCEEDED(result) ? InstallBackgroundHooks() : result;
+}
+
+HRESULT HookLibraryBridge::InitializeBackgroundRenderer(const HookCallbacks& callbacks) {
+    std::scoped_lock lock(g_mutex);
+
+    if (backgroundRendererInitialized_) {
+        callbacks_ = callbacks;
+        return S_OK;
+    }
+    if (module_ != nullptr || initializationFailed_) {
+        return E_UNEXPECTED;
+    }
+
+    HMODULE const currentModule = CurrentModule();
+    if (currentModule == nullptr) {
+        return HRESULT_FROM_WIN32(::GetLastError());
+    }
+
+    const HRESULT rendererResult = qttabbar::background::Initialize(currentModule);
+    if (rendererResult != S_OK) {
+        return rendererResult;
+    }
+
+    callbacks_ = callbacks;
+    backgroundRendererInitialized_ = true;
+    return S_OK;
+}
+
+HRESULT HookLibraryBridge::InstallBackgroundHooks() {
+    std::scoped_lock lock(g_mutex);
+
+    if (backgroundInitialized_) {
+        return S_OK;
+    }
+    if (!backgroundRendererInitialized_ || module_ != nullptr || initializationFailed_) {
+        return E_UNEXPECTED;
+    }
+
+    const HRESULT hookResult = qttabbar::background::hooks::Install();
+    if (FAILED(hookResult)) {
+        qttabbar::background::Shutdown();
+        backgroundRendererInitialized_ = false;
+        return hookResult;
+    }
+
+    backgroundInitialized_ = true;
+    return S_OK;
 }
 
 HRESULT HookLibraryBridge::InitializeEntry(const HookCallbacks& callbacks,
@@ -111,6 +172,10 @@ HRESULT HookLibraryBridge::InitializeEntry(const HookCallbacks& callbacks,
         if (exceptionCode != ERROR_SUCCESS) {
             return static_cast<HRESULT>(exceptionCode);
         }
+        const HRESULT initializationResult = static_cast<HRESULT>(result);
+        if (FAILED(initializationResult)) {
+            return initializationResult;
+        }
         return HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION);
     }
 
@@ -121,6 +186,14 @@ HRESULT HookLibraryBridge::InitializeEntry(const HookCallbacks& callbacks,
 
 void HookLibraryBridge::Shutdown() {
     std::scoped_lock lock(g_mutex);
+    if (backgroundInitialized_) {
+        qttabbar::background::hooks::Remove();
+        backgroundInitialized_ = false;
+    }
+    if (backgroundRendererInitialized_) {
+        qttabbar::background::Shutdown();
+        backgroundRendererInitialized_ = false;
+    }
     if (module_ != nullptr) {
         if (auto dispose = reinterpret_cast<DisposeFn>(::GetProcAddress(module_, "Dispose"))) {
             DWORD exceptionCode = ERROR_SUCCESS;
@@ -154,7 +227,13 @@ HRESULT HookLibraryBridge::InitShellBrowserHook(IUnknown* shellBrowser) {
 }
 
 HRESULT HookLibraryBridge::RegisterBackgroundWindow(HWND window) {
-    if (module_ == nullptr || !::IsWindow(window)) {
+    if (!::IsWindow(window)) {
+        return E_FAIL;
+    }
+    if (backgroundRendererInitialized_) {
+        return qttabbar::background::RegisterWindow(window, nullptr);
+    }
+    if (module_ == nullptr) {
         return E_FAIL;
     }
     auto registerWindow = reinterpret_cast<RegisterBackgroundWindowFn>(
@@ -165,6 +244,25 @@ HRESULT HookLibraryBridge::RegisterBackgroundWindow(HWND window) {
     return registerWindow(window) == 0 ? S_OK : E_FAIL;
 }
 
+HRESULT HookLibraryBridge::UpdateBackgroundWindow(HWND window, const wchar_t* path) {
+    if (!::IsWindow(window)) {
+        return E_FAIL;
+    }
+    if (backgroundRendererInitialized_) {
+        return qttabbar::background::UpdateWindow(window, path == nullptr ? L"" : path);
+    }
+    if (module_ == nullptr) {
+        return E_FAIL;
+    }
+    auto updateWindow = reinterpret_cast<UpdateBackgroundWindowFn>(
+        ::GetProcAddress(module_, "UpdateBackgroundWindow"));
+    if (updateWindow == nullptr) {
+        return HRESULT_FROM_WIN32(ERROR_PROC_NOT_FOUND);
+    }
+    const int result = updateWindow(window, path == nullptr ? L"" : path);
+    return result == 0 ? S_OK : static_cast<HRESULT>(result);
+}
+
 void __cdecl HookLibraryBridge::ForwardHookResult(int hookId, int retcode) {
     HookLibraryBridge& bridge = HookLibraryBridge::Instance();
     if (bridge.callbacks_.hookResult != nullptr) {
diff --git a/native/QTTabBarNative/HookLibraryBridge.h b/native/QTTabBarNative/HookLibraryBridge.h
index 36f79ab..006c50c 100644
--- a/native/QTTabBarNative/HookLibraryBridge.h
+++ b/native/QTTabBarNative/HookLibraryBridge.h
@@ -18,9 +18,12 @@ class HookLibraryBridge {
 
     HRESULT Initialize(const HookCallbacks& callbacks, const wchar_t* libraryPath);
     HRESULT InitializeBackground(const HookCallbacks& callbacks, const wchar_t* libraryPath);
+    HRESULT InitializeBackgroundRenderer(const HookCallbacks& callbacks);
+    HRESULT InstallBackgroundHooks();
     void Shutdown();
     HRESULT InitShellBrowserHook(IUnknown* shellBrowser);
     HRESULT RegisterBackgroundWindow(HWND window);
+    HRESULT UpdateBackgroundWindow(HWND window, const wchar_t* path);
 
 private:
     HookLibraryBridge() = default;
@@ -34,6 +37,8 @@ class HookLibraryBridge {
 
     HookCallbacks callbacks_{};
     HMODULE module_ = nullptr;
+    bool backgroundRendererInitialized_ = false;
+    bool backgroundInitialized_ = false;
     bool initializationFailed_ = false;
 };
 
diff --git a/native/QTTabBarNative/NativeExports.cpp b/native/QTTabBarNative/NativeExports.cpp
index 03c1086..778d8e8 100644
--- a/native/QTTabBarNative/NativeExports.cpp
+++ b/native/QTTabBarNative/NativeExports.cpp
@@ -6,6 +6,7 @@
 
 #include "HookLibraryBridge.h"
 #include "FluentGlassBridge.h"
+#include "..\..\QTHookLib\ExplorerBackgroundRenderer.h"
 
 using namespace qttabbar::plugins;
 
@@ -110,6 +111,29 @@ __declspec(dllexport) int __stdcall QTTabBarNative_InitializeBackgroundLibrary(
     return qttabbar::hooks::HookLibraryBridge::Instance().InitializeBackground(local, libraryPath);
 }
 
+__declspec(dllexport) int __stdcall QTTabBarNative_InitializeBackgroundRenderer(
+        const qttabbar::hooks::HookCallbacks* callbacks) {
+    if (callbacks == nullptr) {
+        return E_POINTER;
+    }
+    __try {
+        qttabbar::hooks::HookCallbacks local = *callbacks;
+        return qttabbar::hooks::HookLibraryBridge::Instance().InitializeBackgroundRenderer(local);
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER) {
+        return static_cast<int>(GetExceptionCode());
+    }
+}
+
+__declspec(dllexport) int __stdcall QTTabBarNative_InstallBackgroundHooks() {
+    __try {
+        return qttabbar::hooks::HookLibraryBridge::Instance().InstallBackgroundHooks();
+    }
+    __except(EXCEPTION_EXECUTE_HANDLER) {
+        return static_cast<int>(GetExceptionCode());
+    }
+}
+
 __declspec(dllexport) void __stdcall QTTabBarNative_ShutdownHookLibrary() {
     qttabbar::hooks::HookLibraryBridge::Instance().Shutdown();
 }
@@ -150,6 +174,11 @@ __declspec(dllexport) int __stdcall QTTabBarNative_RegisterBackgroundWindow(HWND
     return qttabbar::hooks::HookLibraryBridge::Instance().RegisterBackgroundWindow(window);
 }
 
+__declspec(dllexport) int __stdcall QTTabBarNative_UpdateBackgroundWindow(HWND window,
+                                                                          const wchar_t* path) {
+    return qttabbar::hooks::HookLibraryBridge::Instance().UpdateBackgroundWindow(window, path);
+}
+
 __declspec(dllexport) HRESULT __stdcall QTTabBarNative_ActivateAutoLoader(IUnknown* site) {
     if (site == nullptr) {
         return E_POINTER;
diff --git a/native/QTTabBarNative/QTTabBarNative.rc b/native/QTTabBarNative/QTTabBarNative.rc
index c452828..32e006e 100644
--- a/native/QTTabBarNative/QTTabBarNative.rc
+++ b/native/QTTabBarNative/QTTabBarNative.rc
@@ -288,8 +288,8 @@ BEGIN
 END
 
 VS_VERSION_INFO VERSIONINFO
-FILEVERSION 1,5,62,0
-PRODUCTVERSION 1,5,62,0
+FILEVERSION 1,5,79,0
+PRODUCTVERSION 1,5,79,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -306,11 +306,11 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "QTTabBar"
             VALUE "FileDescription", "QTTabBar Native Deskband"
-            VALUE "FileVersion", "1.5.62.0"
+            VALUE "FileVersion", "1.5.79.0"
             VALUE "InternalName", "QTTabBarNative"
             VALUE "OriginalFilename", "QTTabBarNative.dll"
             VALUE "ProductName", "QTTabBar"
-            VALUE "ProductVersion", "1.5.62.0"
+            VALUE "ProductVersion", "1.5.79.0"
         END
     END
     BLOCK "VarFileInfo"
diff --git a/native/QTTabBarNative/QTTabBarNative.vcxproj b/native/QTTabBarNative/QTTabBarNative.vcxproj
index 2ba21c7..2853af2 100644
--- a/native/QTTabBarNative/QTTabBarNative.vcxproj
+++ b/native/QTTabBarNative/QTTabBarNative.vcxproj
@@ -188,6 +188,8 @@
     <ClInclude Include="InstanceManager.h" />
     <ClInclude Include="InstanceManagerNative.h" />
     <ClInclude Include="HookLibraryBridge.h" />
+    <ClInclude Include="..\..\QTHookLib\ExplorerBackgroundRenderer.h" />
+    <ClInclude Include="..\..\QTHookLib\ScopedBackgroundHooks.h" />
     <ClInclude Include="HookManagerNative.h" />
     <ClInclude Include="HookMessages.h" />
     <ClInclude Include="OptionsDialog.h" />
@@ -227,6 +229,12 @@
     <ClCompile Include="Config.cpp" />
     <ClCompile Include="FluentGlassBridge.cpp" />
     <ClCompile Include="HookLibraryBridge.cpp" />
+    <ClCompile Include="..\..\QTHookLib\ExplorerBackgroundRenderer.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="..\..\QTHookLib\ScopedBackgroundHooks.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
     <ClCompile Include="HookManagerNative.cpp" />
     <ClCompile Include="InstanceManager.cpp" />
     <ClCompile Include="InstanceManagerNative.cpp" />
@@ -253,6 +261,11 @@
   <ItemGroup>
     <ResourceCompile Include="QTTabBarNative.rc" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\MinHook\libMinHook.vcxproj">
+      <Project>{65021938-D251-46FA-BC3D-85C385D4C06D}</Project>
+    </ProjectReference>
+  </ItemGroup>
   <ItemGroup>
     <Midl Include="QTTabBarNative.idl" />
   </ItemGroup>
diff --git a/native/QTTabBarNative/QTTabBarNative_i.c b/native/QTTabBarNative/QTTabBarNative_i.c
index 39a0949..cddcefc 100644
--- a/native/QTTabBarNative/QTTabBarNative_i.c
+++ b/native/QTTabBarNative/QTTabBarNative_i.c
@@ -9,8 +9,8 @@
 /* at Tue Jan 19 04:14:07 2038
  */
 /* Compiler settings for QTTabBarNative.idl:
-    Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 
-    protocol : all , ms_ext, c_ext, robust
+    Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0628
+    protocol : dce , ms_ext, c_ext, robust
     error checks: allocation ref bounds_check enum stub_data 
     VC __declspec() decoration level: 
          __declspec(uuid()), __declspec(selectany), __declspec(novtable)
diff --git a/native/QTTabBarNative/QTTabBarNative_i.h b/native/QTTabBarNative/QTTabBarNative_i.h
index 30f6cd0..1d10171 100644
--- a/native/QTTabBarNative/QTTabBarNative_i.h
+++ b/native/QTTabBarNative/QTTabBarNative_i.h
@@ -7,8 +7,8 @@
 /* at Tue Jan 19 04:14:07 2038
  */
 /* Compiler settings for QTTabBarNative.idl:
-    Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 
-    protocol : all , ms_ext, c_ext, robust
+    Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0628
+    protocol : dce , ms_ext, c_ext, robust
     error checks: allocation ref bounds_check enum stub_data 
     VC __declspec() decoration level: 
          __declspec(uuid()), __declspec(selectany), __declspec(novtable)
diff --git a/native/Tests/BackgroundRendererSmoke/BackgroundRendererSmoke.vcxproj b/native/Tests/BackgroundRendererSmoke/BackgroundRendererSmoke.vcxproj
new file mode 100644
index 0000000..a9e534f
--- /dev/null
+++ b/native/Tests/BackgroundRendererSmoke/BackgroundRendererSmoke.vcxproj
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{7A21D5A9-CC8A-47E9-AB2B-95F7722AA7A4}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(ProjectDir)bin\</OutDir>
+    <IntDir>$(ProjectDir)obj\</IntDir>
+    <TargetName>BackgroundRendererSmoke</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="Smoke.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>
diff --git a/native/Tests/BackgroundRendererSmoke/Smoke.cpp b/native/Tests/BackgroundRendererSmoke/Smoke.cpp
new file mode 100644
index 0000000..a188090
--- /dev/null
+++ b/native/Tests/BackgroundRendererSmoke/Smoke.cpp
@@ -0,0 +1,51 @@
+#include <windows.h>
+#include <shlobj.h>
+
+#include <cstdio>
+
+struct HookCallbacks {
+    void(__stdcall* hookResult)(int, int, void*) = nullptr;
+    BOOL(__stdcall* newWindow)(PCIDLIST_ABSOLUTE, void*) = nullptr;
+    void* context = nullptr;
+};
+
+using InitializeRendererFn = int(__stdcall*)(const HookCallbacks*);
+using InstallHooksFn = int(__stdcall*)();
+using ShutdownFn = void(__stdcall*)();
+
+int wmain(int argc, wchar_t** argv) {
+    if(argc != 2) {
+        return 2;
+    }
+
+    HMODULE explorerFrame = ::LoadLibraryW(L"ExplorerFrame.dll");
+    if(explorerFrame == nullptr) {
+        std::printf("ExplorerFrame=0x%08lX\n", ::GetLastError());
+        return 3;
+    }
+
+    HMODULE module = ::LoadLibraryExW(argv[1], nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
+    if(module == nullptr) {
+        std::printf("NativeModule=0x%08lX\n", ::GetLastError());
+        return 4;
+    }
+
+    auto initialize = reinterpret_cast<InitializeRendererFn>(
+        ::GetProcAddress(module, "QTTabBarNative_InitializeBackgroundRenderer"));
+    auto install = reinterpret_cast<InstallHooksFn>(
+        ::GetProcAddress(module, "QTTabBarNative_InstallBackgroundHooks"));
+    auto shutdown = reinterpret_cast<ShutdownFn>(
+        ::GetProcAddress(module, "QTTabBarNative_ShutdownHookLibrary"));
+    if(initialize == nullptr || install == nullptr || shutdown == nullptr) {
+        return 5;
+    }
+
+    HookCallbacks callbacks{};
+    const int rendererResult = initialize(&callbacks);
+    const int hookResult = rendererResult == 0 ? install() : E_UNEXPECTED;
+    std::printf("Renderer=0x%08X\nHooks=0x%08X\n", rendererResult, hookResult);
+    shutdown();
+    ::FreeLibrary(module);
+    ::FreeLibrary(explorerFrame);
+    return rendererResult == 0 && hookResult == 0 ? 0 : 6;
+}