diff --git a/SKIV.vcxproj b/SKIV.vcxproj
index 8dabfa0..5ef5e5e 100644
--- a/SKIV.vcxproj
+++ b/SKIV.vcxproj
@@ -23,7 +23,7 @@
     <ProjectGuid>{93301458-CC3B-4924-B659-EB190D6EF9EB}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>SKIV</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
diff --git a/include/tabs/viewer.h b/include/tabs/viewer.h
index 1bcd755..140ddd0 100644
--- a/include/tabs/viewer.h
+++ b/include/tabs/viewer.h
@@ -64,4 +64,4 @@ enum ImageScaling {
 };
 
 uint32_t     SKIV_Viewer_CycleVisualizationModes (void);
-ImageScaling SKIV_Viewer_CycleScalingModes       (void);
\ No newline at end of file
+ImageScaling SKIV_Viewer_CycleScalingModes       (void);
diff --git a/include/utility/fsutil.h b/include/utility/fsutil.h
index 2c2b86a..2c3d963 100644
--- a/include/utility/fsutil.h
+++ b/include/utility/fsutil.h
@@ -96,7 +96,7 @@ struct SKIF_CommonPathsCache {
   wchar_t skiv_install      [MAX_PATH + 2] = { }; // Holds the install folder for SKIV
   wchar_t skiv_userdata     [MAX_PATH + 2] = { }; // Holds the user data folder for SKIV
   wchar_t specialk_userdata [MAX_PATH + 2] = { }; // Holds the user data folder for SK (often lines up with its install folder)
-  wchar_t skiv_temp         [MAX_PATH + 2] = { }; // Holds the temp data folder for SKIV (images downloaded from the web; cleared out on every launch): %APPDATA%\TEMP\SKIV
+  wchar_t skiv_temp         [MAX_PATH + 2] = { }; // Holds the temp data folder for SKIV (images downloaded from the web; cleared out on every launch): "%APPDATA%\TEMP\SKIV\"
   wchar_t skiv_screenshots  [MAX_PATH + 2] = { }; // Holds the screenshot folder for SKIV
    char   skiv_screenshotsA [MAX_PATH + 2] = { }; // UTF-8
 
diff --git a/include/utility/image.h b/include/utility/image.h
index 06f5c98..cebeece 100644
--- a/include/utility/image.h
+++ b/include/utility/image.h
@@ -4,6 +4,7 @@
 #include <imgui/imgui_internal.h>
 #include <ImGuiNotify.hpp>
 #include <atlbase.h>
+#include "utility.h"
 
 #pragma warning( push )
 #pragma warning( disable : 4305 )
@@ -134,14 +135,30 @@ static const ParamsPQ PQ =
 
 #pragma warning( pop )
 
-struct SKIV_Region {
-  ImRect        _rect;
-  std::wstring  _title;
-
-  SKIV_Region (ImRect r_ = ImRect(), std::wstring t_ = L"")
+struct SKIV_CaptureData {
+  ImRect         _rect;
+  struct Application {
+    std::wstring custom;     // #1 - SK/SKIF profiles name
+    std::wstring product;    // #2 - Product name from executable
+    std::wstring executable; // #3 - Executable filename
+    std::wstring window;     // -optional-
+  }              _names;
+  CaptureMode    _mode;
+  bool           _select = false;
+  HWND           _hwnd = NULL;
+
+  SKIV_CaptureData (ImRect r_, Application n_, CaptureMode m_)
   {
     _rect  = r_;
-    _title = t_;
+    _names = n_;
+    _mode  = m_;
+  }
+
+  SKIV_CaptureData (ImRect r_, std::wstring t_, CaptureMode m_)
+  {
+    _rect = r_;
+    _mode = m_;
+    _names.custom = t_;
   }
 };
 
@@ -152,11 +169,11 @@ float             SKIV_Image_LinearToPQY   (float N);
 DirectX::XMVECTOR SKIV_Image_Rec709toICtCp (DirectX::XMVECTOR N);
 DirectX::XMVECTOR SKIV_Image_ICtCptoRec709 (DirectX::XMVECTOR N);
 
-bool    SKIV_Image_CopyToClipboard (const DirectX::Image* pImage, bool isHDR, bool isTemp, const wchar_t* wszFileName);
+bool    SKIV_Image_CopyToClipboard (const DirectX::Image* pImage, bool isHDR, SKIV_CaptureData capture_data);
 HRESULT SKIV_Image_SaveToDisk_HDR  (const DirectX::Image& image, const wchar_t* wszFileName);
 HRESULT SKIV_Image_SaveToDisk_SDR  (const DirectX::Image& image, const wchar_t* wszFileName, bool force_sRGB);
 HRESULT SKIV_Image_CaptureDesktop  (DirectX::ScratchImage& image, POINT pos, int flags = 0x0);
-void    SKIV_Image_CaptureRegion   (SKIV_Region capture_area);
+void    SKIV_Image_CaptureRegion   (SKIV_CaptureData capture_data);
 HRESULT SKIV_Image_TonemapToSDR    (const DirectX::Image& image, DirectX::ScratchImage& final_sdr, float mastering_max_nits, float mastering_sdr_nits);
 
 bool    SKIV_Image_IsUltraHDR      (const wchar_t* wszFileName);
@@ -277,4 +294,135 @@ struct skiv_image_desktop_s {
     _max_display_nits = 1000.0f;
     _rotation         = DXGI_MODE_ROTATION_UNSPECIFIED;
   }
+};
+
+// Image Directory
+
+#include <shobjidl_core.h>
+
+struct skiv_image_directory_s {
+
+  class FileSystemBindData : public IFileSystemBindData
+  {
+  public:
+    FileSystemBindData() : _ref(1)
+    {
+      ZeroMemory(&_fd, sizeof(_fd));
+    }
+
+    // IUnknown
+    IFACEMETHODIMP QueryInterface(REFIID riid, void** ppv) override
+    {
+      if (riid == IID_IUnknown || riid == IID_IFileSystemBindData)
+      {
+        *ppv = static_cast<IFileSystemBindData*>(this);
+        AddRef();
+        return S_OK;
+      }
+      *ppv = nullptr;
+      return E_NOINTERFACE;
+    }
+
+    IFACEMETHODIMP_(ULONG) AddRef() override
+    {
+      return InterlockedIncrement(&_ref);
+    }
+
+    IFACEMETHODIMP_(ULONG) Release() override
+    {
+      ULONG r = InterlockedDecrement(&_ref);
+      if (r == 0) delete this;
+      return r;
+    }
+
+    // IFileSystemBindData
+    IFACEMETHODIMP SetFindData (const WIN32_FIND_DATAW* pfd) override
+    {
+      _fd = *pfd;
+      return S_OK;
+    }
+
+    IFACEMETHODIMP GetFindData (WIN32_FIND_DATAW* pfd) override
+    {
+      *pfd = _fd;
+      return S_OK;
+    }
+
+  private:
+    ~FileSystemBindData() = default;
+
+    LONG _ref;
+    WIN32_FIND_DATAW _fd;
+  };
+
+  struct fd_s {
+    std::wstring     filename;    // Image filename
+  //std::wstring     folder_path; // Parent folder path
+    std::wstring     path;        // Image path (full)
+    WIN32_FIND_DATA  ffd;
+  };
+
+  struct fl_s {
+    fd_s* getActiveFile (void)
+    {
+      return (_ptr != nullptr) ? _ptr : nullptr;
+    }
+
+    std::vector<fd_s> getList (void)
+    {
+      return _list;
+    }
+
+    void setList (std::vector<fd_s> list)
+    {
+      _list = std::move(list);
+      _it   = _list.end();
+      _ptr  = _it._Ptr;
+    }
+
+    void clear (void)
+    {
+      _list.clear();
+      _it  = _list.end();
+      _ptr = nullptr;
+    }
+
+    bool empty (void)
+    {
+      return _list.empty();
+    }
+
+    void         setImage    (const std::wstring& path);
+    std::wstring nextImage   (void);
+    std::wstring prevImage   (void);
+    std::wstring deleteImage (void);
+    void         updateFileIterator (const std::wstring& path); // Find the position of the image in the current folder
+
+    bool fileDeleted = false;
+
+  private:
+    std::vector<fd_s>           _list;
+    std::vector<fd_s>::iterator _it;
+                fd_s*           _ptr;
+  } fileList;
+
+//std::wstring                orig_path;   // Holds a cached copy of cover.path
+//std::wstring                filename;    // Image filename
+  std::wstring                folder_path; // Parent folder path
+  SKIF_DirectoryWatch         watch;
+  
+
+  std::vector<SORTCOLUMN>     sortColumns; // File Explorer
+
+  void         reset       (void);
+
+  // Retrieve all files in the folder, and identify our current place among them...
+  int         workerThread  (bool runThread); // 0 = Not done, 1 = No change in sort order (i.e. same files as before) , 2 = Change in the sort order (i.e. new files/folder)
+
+  // Win32 File Explorer based sorting
+private:
+  static bool updateFolderData (std::vector<fd_s>& list, std::vector<SORTCOLUMN>& sortColumns, const std::wstring& path);
+  static void updateSortOrder  (std::vector<fd_s>& list, std::vector<SORTCOLUMN>& sortColumns, const std::wstring& path);
+  static void sortByColumns    (std::vector<fd_s>& list, const std::vector<SORTCOLUMN>& sortColumns);
+  static void sortByFilename   (std::vector<fd_s>& list);
 };
\ No newline at end of file
diff --git a/include/utility/registry.h b/include/utility/registry.h
index 00b3d7f..be405cb 100644
--- a/include/utility/registry.h
+++ b/include/utility/registry.h
@@ -4,7 +4,7 @@
 #include <typeindex>
 #include <sstream>
 #include <vector>
-#include "sk_utility.h"
+#include "utility.h"
 
 #ifndef RRF_SUBKEY_WOW6464KEY
 #define RRF_SUBKEY_WOW6464KEY  0x00010000
@@ -265,10 +265,6 @@ struct SKIF_RegistrySettings {
     SKIF_MakeRegKeyB ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
                          LR"(99th Percentile MaxCLL)" );
 
-  KeyValue <bool> regKVSaveScreenshots =
-    SKIF_MakeRegKeyB ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
-                         LR"(Save Screenshots)" );
-
   // Integers (DWORDs)
 
   KeyValue <int> regKVImageScaling =
@@ -311,6 +307,22 @@ struct SKIF_RegistrySettings {
     SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
                          LR"(UI Mode)" );
 
+  KeyValue <int> regKVUIWidth =
+    SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
+                         LR"(UI Width)" );
+
+  KeyValue <int> regKVUIHeight =
+    SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
+                         LR"(UI Height)" );
+
+  KeyValue <int> regKVUIPositionX =
+    SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
+                         LR"(UI Position X)" );
+
+  KeyValue <int> regKVUIPositionY =
+    SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
+                         LR"(UI Position Y)" );
+
   KeyValue <int> regKVDiagnostics =
     SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
                          LR"(Diagnostics)" );
@@ -347,6 +359,14 @@ struct SKIF_RegistrySettings {
     SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\PNG\)",
                          LR"(HDR BitDepth)" );
 
+  KeyValue <int> regKVScreenshotsAutosave =
+    SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
+                         LR"(Screenshots Autosave)" );
+
+  KeyValue <int> regKVScreenshotsHotkeys =
+    SKIF_MakeRegKeyI ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
+                         LR"(Screenshots Hotkeys)" );
+
   // Wide Strings
 
   KeyValue <std::wstring> regKVIgnoreUpdate =
@@ -365,6 +385,10 @@ struct SKIF_RegistrySettings {
     SKIF_MakeRegKeyWS ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
                          LR"(Screenshots)" );
 
+  KeyValue <std::wstring> regKVScreenshotsPattern =
+    SKIF_MakeRegKeyWS ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
+                         LR"(Screenshots Pattern)" );
+
   KeyValue <std::wstring> regKVAutoUpdateVersion =
     SKIF_MakeRegKeyWS ( LR"(SOFTWARE\Kaldaien\Special K\Viewer\)",
                          LR"(Auto-Update Version)" );
@@ -419,18 +443,24 @@ struct SKIF_RegistrySettings {
                          LR"(AppsUseLightTheme)" );
 
   // Default settings (multiple options)
-//int iImageScaling            = 2;   // 0 = None,                        1 = Fill,                   2 = Fit (default),               3 = Stretch
-  int iStyle                   = 0;   // 0 = Dynamic,                     1 = SKIF Dark,              2 = SKIF Light,                  3 = ImGui Classic,                  4 = ImGui Dark
-  int iStyleTemp               = 0;   // Used to temporary hold changes in the style during the current session
-  int iDarkenImages            = 0;   // 0 = Never,                       1 = Always,                 2 = On mouse hover
-  int iCheckForUpdates         = 1;   // 0 = Never,                       1 = Weekly,                 2 = On each launch
-  int iLogging                 = 4;   // 0 = None,                        1 = Fatal,                  2 = Error,                       3 = Warning,                        4 = Info,       5 = Debug,       6 = Verbose
-  int iSDRMode                 = 0;   // 0 = 8 bpc,                       1 = 10 bpc,                 2 = 16 bpc
-  int iHDRMode                 = 2;   // 0 = Disabled,                    1 = HDR10 (10 bpc),         2 = scRGB (16 bpc)
+//int iImageScaling            =   2;   // 0 = None,                        1 = Fill,                   2 = Fit (default),               3 = Stretch
+  int iStyle                   =   0;   // 0 = Dynamic,                     1 = SKIF Dark,              2 = SKIF Light,                  3 = ImGui Classic,                  4 = ImGui Dark
+  int iStyleTemp               =   0;   // Used to temporary hold changes in the style during the current session
+  int iDarkenImages            =   0;   // 0 = Never,                       1 = Always,                 2 = On mouse hover
+  int iCheckForUpdates         =   1;   // 0 = Never,                       1 = Weekly,                 2 = On each launch
+  int iLogging                 =   4;   // 0 = None,                        1 = Fatal,                  2 = Error,                       3 = Warning,                        4 = Info,       5 = Debug,       6 = Verbose
+  int iSDRMode                 =   0;   // 0 = 8 bpc,                       1 = 10 bpc,                 2 = 16 bpc
+  int iHDRMode                 =   2;   // 0 = Disabled,                    1 = HDR10 (10 bpc),         2 = scRGB (16 bpc)
   int iHDRBrightness           = 203; // HDR reference white for BT.2408
-  int iHDRToneMapType          = 8;   // 0 = Do Nothing,                  1 = Clip Luminance,         8 = Map to Display
-  int iUIMode                  = 1;   // 0 = Safe Mode (BitBlt),          1 = Normal,                 2 = VRR Compatibility
-  int iDiagnostics             = 1;   // 0 = None,                        1 = Normal,                 2 = Enhanced (not actually used yet)
+  int iHDRToneMapType          =   8;   // 0 = Do Nothing,                  1 = Clip Luminance,         8 = Map to Display
+  int iUIMode                  =   1;   // 0 = Safe Mode (BitBlt),          1 = Normal,                 2 = VRR Compatibility
+  int iDiagnostics             =   1;   // 0 = None,                        1 = Normal,                 2 = Enhanced (not actually used yet)
+  int iUIWidth                 =   0; //  0 = None (default)
+  int iUIHeight                =   0; //  0 = None (default)
+  int iUIPositionX             =  -1; // -1 = None (default)
+  int iUIPositionY             =  -1; // -1 = None (default)
+  CaptureMode eScreenshotsAutosave = CaptureMode_ALL, // Default to saving all types of screen captures
+              eScreenshotsHotkeys  = CaptureMode_ALL; // Default to enabling all hotkeys
 
   // Default settings (booleans)
   bool bAdjustWindow            = false; // Adjust window size based on the image size?
@@ -459,14 +489,14 @@ struct SKIF_RegistrySettings {
   bool bFadeCovers              =  true;
   bool bControllers             =  true; // Should SKIF support controller input ?
   bool bLoggingDeveloper        = false; // This is a log level "above" verbose logging that also includes stuff like window messages. Only useable for SKIF developers
-  bool bSaveScreenshots         =  true;
 
   // Wide strings
   std::wstring wsUpdateChannel  = L"Website"; // Default to stable channel
   std::wstring wsIgnoreUpdate;
   std::wstring wsPathViewer;
-  std::wstring wsPathScreenshots;
   std::wstring wsPathSpecialK;
+  std::wstring wsPathScreenshots;
+  std::wstring wsScreenshotsPattern = L"<app>_<date>_<time>";
   std::wstring wsAutoUpdateVersion; // Holds the version the auto-updater is trying to install
   std::wstring wsDefaultHDRExt = L".png";
   std::wstring wsDefaultSDRExt = L".png";
@@ -511,6 +541,7 @@ struct SKIF_RegistrySettings {
   bool _RendererHDREnabled          = false; // HDR Enabled
   bool _TouchDevice                 = false;
   bool _SnippingMode                = false;
+  bool _SnippingModeInit            =  true;
   bool _SnippingModeExit            = false;
   bool _SnippingModeTempHDR         = false;
   int  _SnippingTonemapsHDR         = 2;
diff --git a/include/utility/sk_utility.h b/include/utility/sk_utility.h
index 517751d..91ed429 100644
--- a/include/utility/sk_utility.h
+++ b/include/utility/sk_utility.h
@@ -806,15 +806,16 @@ struct SK_KeybindMultiState
   const char*  bind_name = nullptr;
   bool         assigning = false,
                state     = false;
-  SK_Keybind   saved, pending;
+  SK_Keybind   default, pending, saved;
 
   // This empty object is used during assignment to disable hotkeys temporarily
   static constexpr SK_Keybind disabled = { };
 
   SK_KeybindMultiState (const char* _n, std::wstring _h) {
     bind_name                   = _n;
-    pending.human_readable      = _h;
-    pending.human_readable_utf8 = SK_WideCharToUTF8 (pending.human_readable);
+    default.human_readable      = _h;
+    default.human_readable_utf8 = SK_WideCharToUTF8 (default.human_readable);
+    pending = default;
   };
 
               bool  applyChanges (void); // This applies the pending changes
diff --git a/include/utility/skif_imgui.h b/include/utility/skif_imgui.h
index 05c3966..25512fd 100644
--- a/include/utility/skif_imgui.h
+++ b/include/utility/skif_imgui.h
@@ -90,4 +90,4 @@ static ImVec4 SKIF_ImGui_ImDerp       (const ImVec4& a, const ImVec4& b, float t
 extern PopupState  PopupMessageInfo;  // App Mode: show an informational message box with text set through SKIF_ImGui_InfoMessage
 
 // Fonts
-extern ImFont* fontConsolas;
+extern ImFont* fontConsolas;
\ No newline at end of file
diff --git a/include/utility/utility.h b/include/utility/utility.h
index 2bbea2a..3695809 100644
--- a/include/utility/utility.h
+++ b/include/utility/utility.h
@@ -57,12 +57,21 @@ enum UITab {
   UITab_ALL      // Total number of elements in enum (technically against Microsoft's enum design guidelines, but whatever)
 };
 
-enum CaptureMode {
-  CaptureMode_Window,
-  CaptureMode_Region,
-  CaptureMode_Screen
+typedef unsigned int CaptureMode;  // -> enum CaptureMode_
+enum CaptureMode_ {
+  CaptureMode_None   = 0,
+
+  CaptureMode_Window = 1 << 0,
+  CaptureMode_Region = 1 << 1,
+  CaptureMode_Screen = 1 << 2,
+
+  CaptureMode_ALL    =
+    CaptureMode_Window | CaptureMode_Region | CaptureMode_Screen
 };
 
+// Workaround for SKIF_ImGui_IsAnyPopupOpen() not detecting keybind popups
+extern bool g_activeKeybindPopup;
+
 struct FileSignature {
   std::wstring               mime_type       = L"";
   std::vector <std::wstring> file_extensions = { };
@@ -140,6 +149,7 @@ bool            SKIF_Util_HasFileSignature            (const std::vector<char>&
 bool            SKIF_Util_HasFileExtension            (const std::wstring extension,    const FileSignature& signature);
 
 // Usernames
+
 std:: string    SKIF_Util_StripPersonalData           (std:: string input);
 std::wstring    SKIF_Util_StripPersonalData           (std::wstring input);
 void            SKIF_Util_Debug_LogUserNames          (void);
@@ -216,7 +226,12 @@ std::wstring    SKIF_Util_GetClipboardHDROP           (void);
 DirectX::Image  SKIF_Util_GetClipboardBitmapData      (void);
 std::wstring    SKIF_Util_AddEnvironmentBlock         (const void* pEnvBlock, const std::wstring& varName, const std::wstring& varValue);
 void            SKIF_Util_FileExplorer_SelectFile     (PCWSTR filePath);
-std::wstring    SKIF_Util_FileExplorer_BrowseFolder   (PCWSTR defaultPath);
+bool            SKIF_Util_FileExplorer_DeleteFile     (PCWSTR filePath, bool hideWarning);
+void            SKIF_Util_FileExplorer_ContextMenuFile(PCWSTR filePath, HWND hWndOwner);
+std::wstring    SKIF_Util_FileExplorer_BrowseForFolderXP(PCWSTR defaultPath);
+std::wstring    SKIF_Util_FileExplorer_BrowseForFolder(PCWSTR defaultPath);
+bool            SKIF_Util_Files_PruneOlderThan        (std::wstring path, ULONGLONG secondsSince);
+bool            SKIF_Util_Files_PruneToLatestN        (std::wstring path, int filesToRetain);
 std::string     SKIF_Util_GetWindowMessageAsStr       (UINT msg);
 
 
diff --git a/src/SKIV.cpp b/src/SKIV.cpp
index 1b28938..b323693 100644
--- a/src/SKIV.cpp
+++ b/src/SKIV.cpp
@@ -55,6 +55,7 @@
 #include <unordered_set>
 #include <oleidl.h>
 #include <utility/droptarget.hpp>
+#include <pathcch.h>
 
 #include <d3d11.h>
 #define DIRECTINPUT_VERSION 0x0800
@@ -129,6 +130,7 @@ ImVec2 SKIF_vecRegularMode          = ImVec2 (0.0f, 0.0f);
 ImVec2 SKIF_vecRegularModeDefault   = ImVec2 (1000.0f, 944.0f);   // Does not include the status bar
 ImVec2 SKIF_vecRegularModeAdjusted  = SKIF_vecRegularModeDefault; // Adjusted for status bar and tooltips (NO DPI scaling!)
 // --- Variables
+ImVec2 SKIF_vecCurrentPosition      = ImVec2 (0.0f, 0.0f); // Gets updated after ImGui::EndFrame()
 ImVec2 SKIF_vecCurrentMode          = ImVec2 (0.0f, 0.0f); // Gets updated after ImGui::EndFrame()
 ImVec2 SKIF_vecCurrentModeNext      = ImVec2 (0.0f, 0.0f); // Holds the new expected size
 ImVec2 SKIF_vecAlteredSize          = ImVec2 (0.0f, 0.0f);
@@ -942,52 +944,7 @@ void SKIF_Initialize (LPWSTR lpCmdLine)
     std::filesystem::create_directories (_path_cache.skiv_temp, ec);
 
   // Clear out any temp files older than a day
-  auto _isDayOld = [&](FILETIME ftLastWriteTime) -> bool
-  {
-    FILETIME ftSystemTime{}, ftAdjustedFileTime{};
-    SYSTEMTIME systemTime{};
-    GetSystemTime (&systemTime);
-
-    if (SystemTimeToFileTime(&systemTime, &ftSystemTime))
-    {
-      ULARGE_INTEGER uintLastWriteTime{};
-
-      // Copy to ULARGE_INTEGER union to perform 64-bit arithmetic
-      uintLastWriteTime.HighPart        = ftLastWriteTime.dwHighDateTime;
-      uintLastWriteTime.LowPart         = ftLastWriteTime.dwLowDateTime;
-
-      // Perform 64-bit arithmetic to add 1 day to last modified timestamp
-      uintLastWriteTime.QuadPart        = uintLastWriteTime.QuadPart + ULONGLONG(1 * 24 * 60 * 60 * 1.0e+7);
-
-      // Copy the results to an FILETIME struct
-      ftAdjustedFileTime.dwHighDateTime = uintLastWriteTime.HighPart;
-      ftAdjustedFileTime.dwLowDateTime  = uintLastWriteTime.LowPart;
-
-      // Compare with system time, and if system time is later (1), then return true
-      if (CompareFileTime (&ftSystemTime, &ftAdjustedFileTime) == 1)
-        return true;
-    }
-
-    return false;
-  };
-
-  HANDLE hFind        = INVALID_HANDLE_VALUE;
-  WIN32_FIND_DATA ffd = { };
-
-  hFind = 
-    FindFirstFileExW ((tempDir + L"*").c_str(), FindExInfoBasic, &ffd, FindExSearchNameMatch, NULL, NULL);
-
-  if (INVALID_HANDLE_VALUE != hFind)
-  {
-    if (_isDayOld  (ffd.ftLastWriteTime))
-      DeleteFile  ((tempDir + ffd.cFileName).c_str());
-
-    while (FindNextFile (hFind, &ffd))
-      if (_isDayOld  (ffd.ftLastWriteTime))
-        DeleteFile  ((tempDir + ffd.cFileName).c_str());
-
-    FindClose (hFind);
-  }
+  SKIF_Util_Files_PruneOlderThan (tempDir, 24 * 60 * 60);
 
   // Populate SKIV's default screenshot folder
   const std::wstring screenshotsDir =
@@ -1000,42 +957,77 @@ void SKIF_Initialize (LPWSTR lpCmdLine)
 }
 
 static
-std::wstring
-SKIV_GetBaseFilename (HWND hWnd)
+SKIV_CaptureData::Application
+SKIV_GetApplicationNames (HWND hWnd)
 {
   // Limit window title / process name to 60 characters
   const size_t len = MAX_PATH + 2;
-  wchar_t wszFilename [len] = { };
+  wchar_t buffer [len] = { };
+  SKIV_CaptureData::Application names = { };
+
+  // Window title
+  if (GetWindowTextW (hWnd, buffer, len))
+    names.window = std::wstring(buffer);
 
-  // Window title, if retrievable, else process name
-  if (GetWindowTextW (hWnd, wszFilename, len) == 0)
+  // Process name
+  DWORD dwProcessId = 0;
+  if (GetWindowThreadProcessId (hWnd, &dwProcessId))
   {
-    // Process name
-    DWORD dwProcessId = 0;
-    if (GetWindowThreadProcessId (hWnd, &dwProcessId))
+    HANDLE hProcess = OpenProcess (PROCESS_QUERY_LIMITED_INFORMATION, FALSE, dwProcessId);
+
+    if (hProcess != NULL)
     {
-      HANDLE hProcess = OpenProcess (PROCESS_QUERY_LIMITED_INFORMATION, FALSE, dwProcessId);
+      DWORD lenPath = len;
 
-      if (hProcess != NULL)
+      if (QueryFullProcessImageNameW (hProcess, NULL, buffer, &lenPath))
       {
-        GetProcessImageFileNameW (hProcess, wszFilename, MAX_PATH);
-        PathStripPathW                     (wszFilename);
-        PathRemoveExtensionW               (wszFilename);
+        std::filesystem::path path = std::wstring (buffer);
+
+        // Product name
+        PLOG_DEBUG << "Parent path: " << path.parent_path();
+        names.product = SKIF_Util_GetProductName (path.c_str());
+
+        // Executable
+        PathStripPathW         (buffer);
+        PathCchRemoveExtension (buffer, lenPath);
+        names.executable = std::wstring(buffer);
+
+        // Custom name
+        HKEY     hKey;
+        if (ERROR_SUCCESS == RegCreateKeyExW (HKEY_CURRENT_USER, LR"(SOFTWARE\Kaldaien\Special K\Profiles)", NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_QUERY_VALUE, NULL, &hKey, NULL))
+        {
+          DWORD size = len * sizeof(wchar_t);
+          if (ERROR_SUCCESS == RegGetValueW (hKey, NULL, path.parent_path().c_str(), RRF_RT_REG_SZ, NULL, buffer, &size))
+            names.custom = std::wstring(buffer);
+
+          RegCloseKey (hKey);
+        }
       }
     }
   }
 
-  std::wstring wsFilename = std::wstring (wszFilename);
+  // Strip all null terminator \0 characters from the strings
+  names.executable.erase (std::find(names.executable.begin(), names.executable.end(), '\0'), names.executable.end());
+  names.product.erase    (std::find(names.product.begin(),    names.product.end(),    '\0'), names.product.end());
+  names.window.erase     (std::find(names.window.begin(),     names.window.end(),     '\0'), names.window.end());
+  names.custom.erase     (std::find(names.custom.begin(),     names.custom.end(),     '\0'), names.custom.end());
 
-  // Strip all null terminator \0 characters from the string
-  wsFilename.erase (std::find(wsFilename.begin(), wsFilename.end(), '\0'), wsFilename.end());
+  if (names.executable.size() > 30)
+    names.executable = names.executable.substr(0, 30);
 
-  if (wsFilename.size() > 60)
-    wsFilename = wsFilename.substr(0, 60);
-  else if (wsFilename.empty())
-    wsFilename = L"explorer";
+  if (names.product.size() > 30)
+    names.product = names.product.substr(0, 30);
 
-  return wsFilename;
+  if (names.window.size() > 30)
+    names.window = names.window.substr(0, 30);
+
+  PLOG_DEBUG << "Application names:";
+  PLOG_DEBUG << "Executable: " << names.executable;
+  PLOG_DEBUG << "   Product: " << names.product;
+  PLOG_DEBUG << "    Window: " << names.window;
+  PLOG_DEBUG << "    Custom: " << names.custom;
+
+  return names;
 }
 
 bool bKeepWindowAlive  = true,
@@ -1438,9 +1430,12 @@ wWinMain ( _In_     HINSTANCE hInstance,
   SKIF_Util_RegisterHotKeyHDRToggle (_registry.kbToggleHDRDisplay.getKeybind());
 
   // Register snipping hotkey
-  SKIF_Util_RegisterHotKeyCapture (CaptureMode_Window, _registry.kbCaptureWindow.getKeybind());
-  SKIF_Util_RegisterHotKeyCapture (CaptureMode_Region, _registry.kbCaptureRegion.getKeybind());
-  SKIF_Util_RegisterHotKeyCapture (CaptureMode_Screen, _registry.kbCaptureScreen.getKeybind());
+  if ((_registry.eScreenshotsHotkeys & CaptureMode_Window) == CaptureMode_Window)
+      SKIF_Util_RegisterHotKeyCapture (CaptureMode_Window, _registry.kbCaptureWindow.getKeybind());
+  if ((_registry.eScreenshotsHotkeys & CaptureMode_Region) == CaptureMode_Region)
+      SKIF_Util_RegisterHotKeyCapture (CaptureMode_Region, _registry.kbCaptureRegion.getKeybind());
+  if ((_registry.eScreenshotsHotkeys & CaptureMode_Screen) == CaptureMode_Screen)
+      SKIF_Util_RegisterHotKeyCapture (CaptureMode_Screen, _registry.kbCaptureScreen.getKeybind());
 
   // Register the HTML Format for the clipboard
   CF_HTML = RegisterClipboardFormatW (L"HTML Format");
@@ -1501,9 +1496,10 @@ wWinMain ( _In_     HINSTANCE hInstance,
                 hotkeyCtrlF = false, // Toggle Fullscreen Mode
                 hotkeyCtrlV = false, // Paste data through the clipboard
                 hotkeyCtrlN = false, // Minimize app
-                hotkeyCtrlS = false,
-                hotkeyCtrlX = false,
-                hotkeyCtrlB = false; // Encoder Config
+                hotkeyCtrlS = false, // Viewer: Save Current Image (in same Dynamic Range), Snipping Mode: Toggle save to Disk, Settings: Save Screenshots Pattern
+                hotkeyCtrlX = false, // Export Current Image (HDR -> SDR)
+                hotkeyCtrlB = false, // Encoder Config
+                hotkeyCtrlE = false; // Snipping Mode: Toggle browse to folder
 
     // Handled in viewer.cpp
        //hotkeyCtrl1 = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_1     )->DownDuration == 0.0f), // Viewer -> Image Scaling: View actual size (1:1 / None)
@@ -1566,6 +1562,41 @@ wWinMain ( _In_     HINSTANCE hInstance,
       return ! SKIF_Shutdown.load(); // return false on exit or system shutdown
     };
 
+    // Window stuff
+
+    ImRect rectCursorMonitor; // RepositionSKIF
+
+    // RepositionSKIF -- Step 1: Retrieve monitor of cursor
+    if (RepositionSKIF)
+    {
+      ImRect t;
+      for (int monitor_n = 0; monitor_n < ImGui::GetPlatformIO().Monitors.Size; monitor_n++)
+      {
+        const ImGuiPlatformMonitor& tmpMonitor = ImGui::GetPlatformIO().Monitors[monitor_n];
+        t = ImRect(tmpMonitor.MainPos, (tmpMonitor.MainPos + tmpMonitor.MainSize));
+
+        POINT               mouse_screen_pos = { };
+        if (::GetCursorPos (&mouse_screen_pos))
+        {
+          ImVec2 os_pos = ImVec2( (float)mouse_screen_pos.x,
+                                  (float)mouse_screen_pos.y );
+          if (t.Contains (os_pos))
+          {
+            rectCursorMonitor = t;
+          //SKIF_ImGui_GlobalDPIScale = (_registry.bDPIScaling) ? tmpMonitor.DpiScale : 1.0f;
+          }
+        }
+      }
+    }
+      
+    SKIF_vecRegularMode     = SKIF_vecRegularModeAdjusted * SKIF_ImGui_GlobalDPIScale;
+      
+  //SKIF_vecRegularMode.y  -= SKIF_vecAlteredSize.y; // Replaced with SKIF_vecCurrentModeNext
+
+    SKIF_vecRegularMode     = ImFloor (SKIF_vecRegularMode);
+
+  //SKIF_vecCurrentMode     = SKIF_vecRegularMode ;
+
     // Apply any changes to the ImGui style
     // Do it at the beginning of frames to prevent ImGui::Push... from affecting the styling
     // Note that Win11 rounded border color won't be applied until after a restart
@@ -1640,6 +1671,50 @@ wWinMain ( _In_     HINSTANCE hInstance,
         RespectMonBoundaries = true;
     }
 
+    // Restore the last remembered window size on launch,
+    //   but only if we are not running in service mode!
+    static bool
+        applySizeOnLaunch = true;
+    if (applySizeOnLaunch)
+    {   applySizeOnLaunch = false;
+
+      if (_registry.iUIWidth > 0 && _registry.iUIHeight > 0)
+        SKIF_vecCurrentModeNext =
+                        ImVec2 (static_cast<float> (_registry.iUIWidth),
+                                static_cast<float> (_registry.iUIHeight));
+      else
+      {
+        SKIF_vecCurrentModeNext = SKIF_vecRegularMode;
+      }
+    }
+
+    // SKIF_vecCurrentModeNext 1/2
+    if (SKIF_vecCurrentModeNext.x != 0.0f)
+    {
+      // Shrink the window on low-res displays (will be applied on the next frame)
+      // Emulates auto-horizon mode
+      if (ImGui::GetFrameCount() > 2 &&
+         (SKIF_vecCurrentModeNext.x > monitor_extent.GetWidth () ||
+          SKIF_vecCurrentModeNext.y > monitor_extent.GetHeight()))
+      {
+        float arWindow = SKIF_vecCurrentModeNext.x / SKIF_vecCurrentModeNext.y;
+
+        if (monitor_extent.GetWidth() < SKIF_vecCurrentModeNext.x)
+        {
+          SKIF_vecCurrentModeNext.x = monitor_extent.GetWidth();
+          SKIF_vecCurrentModeNext.y = SKIF_vecCurrentModeNext.x / arWindow;
+        }
+
+        if (monitor_extent.GetHeight() < SKIF_vecCurrentModeNext.y)
+        {
+          SKIF_vecCurrentModeNext.y = monitor_extent.GetHeight();
+          SKIF_vecCurrentModeNext.x = SKIF_vecCurrentModeNext.y * arWindow;
+        }
+      }
+
+      SKIF_vecCurrentMode = SKIF_vecCurrentModeNext;
+    }
+
     // F8 to toggle UI borders
     if (hotkeyF8)
     {
@@ -1731,6 +1806,9 @@ wWinMain ( _In_     HINSTANCE hInstance,
     {
       SKIF_FrameCount.store(ImGui::GetFrameCount());
 
+      // Reset every frame
+      g_activeKeybindPopup = false;
+
       // Update hotkey variables
       hotkeyF1    = (              ImGui::GetKeyData (ImGuiKey_F1    )->DownDuration == 0.0f); // Switch to Viewer
       hotkeyF2    = (              ImGui::GetKeyData (ImGuiKey_F2    )->DownDuration == 0.0f); // Switch to Settings
@@ -1750,9 +1828,10 @@ wWinMain ( _In_     HINSTANCE hInstance,
       hotkeyCtrlF = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_F     )->DownDuration == 0.0f); // Toggle Fullscreen Mode
       hotkeyCtrlV = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_V     )->DownDuration == 0.0f); // Paste data through the clipboard
       hotkeyCtrlN = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_N     )->DownDuration == 0.0f); // Minimize app
-      hotkeyCtrlS = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_S     )->DownDuration == 0.0f); // Save Current Image (in same Dynamic Range)
+      hotkeyCtrlS = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_S     )->DownDuration == 0.0f); // Viewer: Save Current Image (in same Dynamic Range), Snipping Mode: Toggle save to Disk
       hotkeyCtrlX = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_X     )->DownDuration == 0.0f); // Export Current Image (HDR -> SDR)
-      hotkeyCtrlB = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_E     )->DownDuration == 0.0f); // Configure Image Encoders
+      hotkeyCtrlB = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_B     )->DownDuration == 0.0f); // Configure Image Encoders
+      hotkeyCtrlE = (io.KeyCtrl && ImGui::GetKeyData (ImGuiKey_E     )->DownDuration == 0.0f); // Snipping Toolbar: Toggle browse to folder
 
       const bool hotkeyCycleScaling       = ImGui::IsKeyPressed (ImGuiKey_GamepadL3);
       const bool hotkeyCycleVisualization = ImGui::IsKeyPressed (ImGuiKey_GamepadR3);
@@ -1771,44 +1850,67 @@ wWinMain ( _In_     HINSTANCE hInstance,
         addAdditionalFrames += 3; // Force a re-paint to change visualization
       }
 
+      if (SKIF_vecCurrentModeNext.x != 0.0f &&
+          SKIF_vecCurrentModeNext   != SKIF_vecCurrentMode)
+      {
+        SKIF_vecCurrentModeNext.x = 0.0f;
 
-      ImRect rectCursorMonitor; // RepositionSKIF
+        SKIF_vecCurrentMode = SKIF_vecCurrentModeNext;
+      }
 
-      // RepositionSKIF -- Step 1: Retrieve monitor of cursor
-      if (RepositionSKIF)
+      static const ImVec2 wnd_minimum_size = ImVec2 (200.0f, 200.0f) * SKIF_ImGui_GlobalDPIScale;
+
+      // SKIF_vecCurrentModeNext 2/2
+      if (SKIF_vecCurrentModeNext.x != 0.0f)
+      {   SKIF_vecCurrentModeNext.x  = 0.0f;
+        ImGui::SetNextWindowSizeConstraints (SKIF_vecCurrentMode, SKIF_vecCurrentMode);
+      }
+
+      // The first time SKIF is being launched, or repositioned on launch, use a higher minimum size
+      else if (ImGui::GetFrameCount() == 1 || RepositionSKIF)
+        ImGui::SetNextWindowSizeConstraints (wnd_minimum_size * 2.0f, ImVec2 (FLT_MAX, FLT_MAX));
+
+      // On the second frame, limit the initial window size to only 80% of the monitor size
+      /*
+      else if (resizeAppWindow || ImGui::GetFrameCount() == 2)
       {
-        ImRect t;
-        for (int monitor_n = 0; monitor_n < ImGui::GetPlatformIO().Monitors.Size; monitor_n++)
-        {
-          const ImGuiPlatformMonitor& tmpMonitor = ImGui::GetPlatformIO().Monitors[monitor_n];
-          t = ImRect(tmpMonitor.MainPos, (tmpMonitor.MainPos + tmpMonitor.MainSize));
+        ImVec2 size_current = windowRect.GetSize();
+        ImVec2 size_maximum = monitor_extent.GetSize() * 0.8f;
 
-          POINT               mouse_screen_pos = { };
-          if (::GetCursorPos (&mouse_screen_pos))
-          {
-            ImVec2 os_pos = ImVec2( (float)mouse_screen_pos.x,
-                                    (float)mouse_screen_pos.y );
-            if (t.Contains (os_pos))
-            {
-              rectCursorMonitor = t;
-              SKIF_ImGui_GlobalDPIScale = (_registry.bDPIScaling) ? tmpMonitor.DpiScale : 1.0f;
-            }
-          }
-        }
+        ImGui::SetNextWindowSizeConstraints (wnd_minimum_size, size_maximum);
+
+        // If the window size was too large, we need to reposition the window to the center as well
+        // This is handled on the next frame by the code above us
+        if (size_current.x > size_maximum.x || size_current.y > size_maximum.y)
+          repositionToCenter = true;
       }
-      
-      SKIF_vecRegularMode     = SKIF_vecRegularModeAdjusted * SKIF_ImGui_GlobalDPIScale;
-      
-      SKIF_vecRegularMode.y  -= SKIF_vecAlteredSize.y;
+      */
 
-      SKIF_vecCurrentMode     = SKIF_vecRegularMode ;
+      // The rest of the frames are uncapped
+      else
+        ImGui::SetNextWindowSizeConstraints (wnd_minimum_size, ImVec2 (FLT_MAX, FLT_MAX));
 
       ImGui::SetNextWindowClass (&SKIF_AppWindow);
 
+      // Restore the last remembered window position on launch
+      static bool
+          applyPositionOnLaunch = true;
+      if (applyPositionOnLaunch)
+      {   applyPositionOnLaunch = false;
+
+        if (_registry.iUIPositionX != -1 &&
+            _registry.iUIPositionY != -1)
+          ImGui::SetNextWindowPos (ImVec2 (static_cast<float> (_registry.iUIPositionX),
+                                           static_cast<float> (_registry.iUIPositionY)));
+        else
+          RepositionSKIF = true;
+      }
+
       // RepositionSKIF -- Step 2: Repositon the window
       // Repositions the window in the center of the monitor the cursor is currently on
       if (RepositionSKIF)
-        ImGui::SetNextWindowPos (ImVec2(rectCursorMonitor.GetCenter().x - (SKIF_vecCurrentMode.x / 2.0f), rectCursorMonitor.GetCenter().y - (SKIF_vecCurrentMode.y / 2.0f)));
+        ImGui::SetNextWindowPos (ImVec2 (rectCursorMonitor.GetCenter().x - (SKIF_vecCurrentMode.x / 2.0f),
+                                         rectCursorMonitor.GetCenter().y - (SKIF_vecCurrentMode.y / 2.0f)));
 
       // Calculate new window boundaries and changes to fit within the workspace if it doesn't fit
       //   Delay running the code to on the third frame to allow other required parts to have already executed...
@@ -1903,32 +2005,6 @@ wWinMain ( _In_     HINSTANCE hInstance,
         SKIV_ResizeApp = ImVec2 (0.0f, 0.0f);
       }
 
-      static const ImVec2 wnd_minimum_size = ImVec2 (200.0f, 200.0f) * SKIF_ImGui_GlobalDPIScale;
-
-      // The first time SKIF is being launched, or repositioned on launch, use a higher minimum size
-      if (ImGui::GetFrameCount() == 1 && RepositionSKIF)
-        ImGui::SetNextWindowSizeConstraints (wnd_minimum_size * 2.0f, ImVec2 (FLT_MAX, FLT_MAX));
-
-      // On the second frame, limit the initial window size to only 80% of the monitor size
-      /*
-      else if (resizeAppWindow || ImGui::GetFrameCount() == 2)
-      {
-        ImVec2 size_current = windowRect.GetSize();
-        ImVec2 size_maximum = monitor_extent.GetSize() * 0.8f;
-
-        ImGui::SetNextWindowSizeConstraints (wnd_minimum_size, size_maximum);
-
-        // If the window size was too large, we need to reposition the window to the center as well
-        // This is handled on the next frame by the code above us
-        if (size_current.x > size_maximum.x || size_current.y > size_maximum.y)
-          repositionToCenter = true;
-      }
-      */
-
-      // The rest of the frames are uncapped
-      else
-        ImGui::SetNextWindowSizeConstraints (wnd_minimum_size, ImVec2 (FLT_MAX, FLT_MAX));
-
       const bool bNoMove =
         (io.KeyCtrl || ! SKIF_MouseDragMoveAllowed);
 
@@ -1941,11 +2017,11 @@ wWinMain ( _In_     HINSTANCE hInstance,
                          ImGuiWindowFlags_NoTitleBar        |
                          ImGuiWindowFlags_NoScrollbar       | // Hide the scrollbar for the main window
                          ImGuiWindowFlags_NoScrollWithMouse | // Prevent scrolling with the mouse as well
+                         ImGuiWindowFlags_NoSavedSettings   | // We handle size/position persistently on our own
               (bNoMove ? ImGuiWindowFlags_NoMove       |
                          ImGuiWindowFlags_NoResize     |
                          ImGuiWindowFlags_NoDecoration :
                          ImGuiWindowFlags_None)
-                      // The only comment is that it was DPI related? This prevents Ctrl+Tab from moving the window so must not be used
       );
       ImGui::PopStyleVar (2);
 
@@ -1989,11 +2065,11 @@ wWinMain ( _In_     HINSTANCE hInstance,
       }
 
       // RepositionSKIF -- Step 3: The Final Step -- Prevent the global DPI scale from potentially being set to outdated values
-      if (RepositionSKIF)
+      if (RepositionSKIF && ImGui::GetFrameCount() > 2)
         RepositionSKIF = false;
 
       // Only allow navigational hotkeys when in Large Mode and as long as no popups are opened
-      if (! SKIF_ImGui_IsAnyPopupOpen ( ))
+      if (! SKIF_ImGui_IsAnyPopupOpen ( ) && ! _registry._SnippingMode)
       {
         if (hotkeyF1)
         {
@@ -2013,31 +2089,16 @@ wWinMain ( _In_     HINSTANCE hInstance,
               SKIF_Tab_ChangeTo  = UITab_About;
         }
 
-        if (allowShortcutCtrlA && (hotkeyCtrlA || hotkeyCtrlO))
+        if (SKIF_Tab_Selected == UITab_Viewer && allowShortcutCtrlA)
         {
-          if (SKIF_Tab_Selected != UITab_Viewer)
-              SKIF_Tab_ChangeTo  = UITab_Viewer;
-
-          OpenFileDialog = PopupState_Open;
-        }
-
-        if (allowShortcutCtrlA && (hotkeyCtrlX || hotkeyCtrlS))
-        {
-          if (SKIF_Tab_Selected != UITab_Viewer)
-              SKIF_Tab_ChangeTo  = UITab_Viewer;
-
+          if (hotkeyCtrlA || hotkeyCtrlO)
+            OpenFileDialog = PopupState_Open;
           if (hotkeyCtrlX)
             ExportSDRDialog = PopupState_Open;
           if (hotkeyCtrlS)
             SaveFileDialog = PopupState_Open;
-        }
-
-        if (allowShortcutCtrlA && hotkeyCtrlB)
-        {
-          if (SKIF_Tab_Selected != UITab_Viewer)
-              SKIF_Tab_ChangeTo  = UITab_Viewer;
-
-          ConfigEncoders = PopupState_Open;
+          if (hotkeyCtrlB)
+            ConfigEncoders = PopupState_Open;
         }
       }
 
@@ -2063,6 +2124,7 @@ wWinMain ( _In_     HINSTANCE hInstance,
       {
         _registry._SnippingMode       = false;
         _registry._SnippingModeExit   = false;
+        _registry._SnippingModeInit   =  true;
 
         extern HWND hwndBeforeSnip;
         extern HWND hwndTopBeforeSnip;
@@ -2167,7 +2229,7 @@ wWinMain ( _In_     HINSTANCE hInstance,
 
         ImRect allowable (SKIV_DesktopImage._desktop_pos,
                           SKIV_DesktopImage._desktop_pos + resolution);
-        SKIV_Region capture_area;
+        SKIV_CaptureData capture_data = SKIV_CaptureData (ImRect(), L"", CaptureMode_None);
 
         bool HDR_Image = SKIV_DesktopImage._hdr_image;
         bool SKIV_HDR  = (HDR_Image ? SKIF_ImGui_IsViewportHDR (SKIF_ImGui_hWnd) : false);
@@ -2200,8 +2262,8 @@ wWinMain ( _In_     HINSTANCE hInstance,
           draw_list->AddRectFilled (allowable.Min, allowable.Max, ImGui::GetColorU32 (IM_COL32 (0, 0, 0, 20)));
         }
 
-        static SKIV_Region selection      = SKIV_Region (ImRect(), L"Desktop_Region");
-        static SKIV_Region selection_auto = SKIV_Region (ImRect(), L"Desktop_Auto");
+        static SKIV_CaptureData selection      = SKIV_CaptureData (ImRect(), L"Desktop_Region", CaptureMode_Region);
+        static SKIV_CaptureData selection_auto = SKIV_CaptureData (ImRect(), L"Desktop_Auto",   CaptureMode_Region);
 
         if (GetForegroundWindow () != SKIF_ImGui_hWnd)
             SetForegroundWindow (     SKIF_ImGui_hWnd);
@@ -2242,7 +2304,7 @@ wWinMain ( _In_     HINSTANCE hInstance,
           return false;
         };
 
-        auto _GetRectBelowCursor = [&](SKIV_Region* _region, bool isAutoSelection) -> void
+        auto _GetRectBelowCursor = [&](SKIV_CaptureData* _data, bool isAutoSelection) -> void
         {
           // This feature is unsupported on rotated displays
           //
@@ -2251,8 +2313,8 @@ wWinMain ( _In_     HINSTANCE hInstance,
           {
             if (isAutoSelection)
             {
-              _region->_rect.Min = ImVec2 (0.0f, 0.0f);
-              _region->_rect.Max = ImVec2 (0.0f, 0.0f);
+              _data->_rect.Min = ImVec2 (0.0f, 0.0f);
+              _data->_rect.Max = ImVec2 (0.0f, 0.0f);
             }
             return;
           }
@@ -2318,13 +2380,13 @@ wWinMain ( _In_     HINSTANCE hInstance,
                     
                     if (isAutoSelection)
                     {
-                      _region->_rect.Min.x = static_cast<float> (rect.left);
-                      _region->_rect.Min.y = static_cast<float> (rect.top);
-                      _region->_rect.Max.x = static_cast<float> (rect.right);
-                      _region->_rect.Max.y = static_cast<float> (rect.bottom);
+                      _data->_rect.Min.x = static_cast<float> (rect.left);
+                      _data->_rect.Min.y = static_cast<float> (rect.top);
+                      _data->_rect.Max.x = static_cast<float> (rect.right);
+                      _data->_rect.Max.y = static_cast<float> (rect.bottom);
                     }
 
-                    _region->_title = SKIV_GetBaseFilename (hWnd);
+                    _data->_hwnd = hWnd;
 
                     /*
                     PLOG_VERBOSE << "----------------------";
@@ -2333,8 +2395,8 @@ wWinMain ( _In_     HINSTANCE hInstance,
                     if (RealGetWindowClassW (top_most,  wszRealWindowClass, 64))
                     PLOG_VERBOSE << "Class: " << wszRealWindowClass;
                     PLOG_VERBOSE << "Pos:   " << point.x << "," << point.y;
-                    PLOG_VERBOSE << "Min:   " << _region.Min.x << "," << _region.Min.y;
-                    PLOG_VERBOSE << "Max:   " << _region.Max.x << "," << _region.Max.y;
+                    PLOG_VERBOSE << "Min:   " << _data.Min.x << "," << _data.Min.y;
+                    PLOG_VERBOSE << "Max:   " << _data.Max.x << "," << _data.Max.y;
                     */
 
                     breakLoop = true;
@@ -2348,9 +2410,18 @@ wWinMain ( _In_     HINSTANCE hInstance,
           }
         };
 
-        static bool clicked = false;
+        static bool clicked      = false;
+        static bool _saveToDisk  = false;
+        static bool _selectFile  = false;
+        if (_registry._SnippingModeInit)
+        {
+          _registry._SnippingModeInit = false;
+          _saveToDisk = (_registry.eScreenshotsAutosave & CaptureMode_Region);
+          _selectFile = false; // Reset on each capture (for now)
+        }
 
-        if (HDR_Image && SKIV_HDR)
+        static bool toolbar = true; // HDR_Image && SKIV_HDR
+        if (toolbar)
         {
           static ImVec2 vSnippingToolbarSize = ImVec2 (128.0f, 32.0f);
 
@@ -2379,38 +2450,125 @@ wWinMain ( _In_     HINSTANCE hInstance,
           ImGui::TextUnformatted   (ICON_FA_SCISSORS " Snipping Tool");
           ImGui::Separator         ();
           ImGui::PopStyleColor     ();
-          ImGui::TreePush          ("");
-          ImGui::RadioButton       ("Keep HDR",       &_registry._SnippingTonemapsHDR, 0);
+
+          ImGui::Spacing           ();
+          ImGui::SameLine          ();
+
+          // Save To Disk
+          if (hotkeyCtrlS)
+            _saveToDisk = ! _saveToDisk;
+
+          ImGui::PushStyleColor    (ImGuiCol_Text, ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_Info));
+          ImGui::Checkbox          (" " ICON_FA_FLOPPY_DISK "###ToolbarSaveToDisk", &_saveToDisk);
+          ImGui::PopStyleColor     ();
           if (ImGui::IsItemHovered ())
           {
             ImGui::BeginTooltip    ();
-            ImGui::TextUnformatted ("HDR PNG may have Compatibility Issues");
+            ImGui::TextUnformatted ("Save captured screenshot?");
+            ImGui::SameLine        ();
+            ImGui::TextColored     (ImGui::GetStyleColorVec4 (ImGuiCol_TextDisabled), "Ctrl+S");
             ImGui::Separator       ();
-            ImGui::BulletText      ("Generally the clipboard contents can only be pasted into browser-derived software (i.e. built using Chromium, Electron) and SKIV.");
-            ImGui::BulletText      ("Some browsers cannot interpret HDR10 PNG correctly and the image will not render in HDR when pasted.");
+            ImGui::TextUnformatted ("Folder:");
+            ImGui::SameLine        ();
+            ImGui::TextUnformatted (_path_cache.skiv_screenshotsA);
             ImGui::EndTooltip      ();
           }
+
           ImGui::SameLine          ();
-          ImGui::RadioButton       ("Tone-map to SDR", &_registry._SnippingTonemapsHDR, 1);
+
+          // Show File In Explorer
+          if (! _saveToDisk)
+            SKIF_ImGui_PushDisableState ();
+          else if (hotkeyCtrlE)
+            _selectFile = ! _selectFile;
+
+          static bool _tOpenFolderDisabled = false;
+          ImGui::PushStyleColor    (ImGuiCol_Text, ImColor(255, 207, 72).Value);
+          ImGui::Checkbox          (" " ICON_FA_FOLDER_OPEN "###ToolbarOpenFolder", &_selectFile);
+          ImGui::PopStyleColor     ();
           if (ImGui::IsItemHovered ())
           {
             ImGui::BeginTooltip    ();
-            ImGui::TextUnformatted ("High Quality HDR to SDR Tone Map");
-            ImGui::Separator       ();
-            ImGui::BulletText      ("Stored in the clipboard as a Bitmap for maximum compatibility with SDR software.");
+            ImGui::TextUnformatted ("Open folder after capture?");
+            ImGui::SameLine        ();
+            ImGui::TextColored     (ImGui::GetStyleColorVec4 (ImGuiCol_TextDisabled), "Ctrl+E");
             ImGui::EndTooltip      ();
           }
+
+          if (! _saveToDisk)
+            SKIF_ImGui_PopDisableState ();
+
+          // HDR Tonemapping
+          if (HDR_Image && SKIV_HDR)
+          {
+            ImGui::SameLine          ();
+            ImGui::SeparatorEx       (ImGuiSeparatorFlags_Vertical);
+            ImGui::SameLine          ();
+            ImGui::BeginGroup        ();
+            ImGui::TextColored       (ImGui::GetStyleColorVec4 (ImGuiCol_TextDisabled), "HDR:");
+            ImGui::SameLine          ();
+            ImGui::RadioButton       ("Keep HDR",       &_registry._SnippingTonemapsHDR, 0);
+            if (ImGui::IsItemHovered ())
+            {
+              ImGui::BeginTooltip    ();
+              ImGui::TextUnformatted ("HDR PNG may have Compatibility Issues");
+              ImGui::Separator       ();
+              ImGui::BulletText      ("Generally the clipboard contents can only be pasted into browser-derived software (i.e. built using Chromium, Electron) and SKIV.");
+              ImGui::BulletText      ("Some browsers cannot interpret HDR10 PNG correctly and the image will not render in HDR when pasted.");
+              ImGui::EndTooltip      ();
+            }
+            ImGui::SameLine          ();
+            ImGui::RadioButton       ("Tone-map to SDR", &_registry._SnippingTonemapsHDR, 1);
+            if (ImGui::IsItemHovered ())
+            {
+              ImGui::BeginTooltip    ();
+              ImGui::TextUnformatted ("High Quality HDR to SDR Tone Map");
+              ImGui::Separator       ();
+              ImGui::BulletText      ("Stored in the clipboard as a Bitmap for maximum compatibility with SDR software.");
+              ImGui::EndTooltip      ();
+            }
+            ImGui::SameLine          ();
+            ImGui::RadioButton       ("Auto",           &_registry._SnippingTonemapsHDR, 2);
+            if (ImGui::IsItemHovered ())
+            {
+              ImGui::BeginTooltip    ();
+              ImGui::TextUnformatted ("Use SDR for Snips at or Below Windows SDR Desktop Luminance");
+              ImGui::Separator       ();
+              ImGui::BulletText      ("For HDR range content, captures an unaltered HDR image");
+              ImGui::EndTooltip      ();
+            }
+            ImGui::EndGroup          ();
+          }
+
           ImGui::SameLine          ();
-          ImGui::RadioButton       ("Auto",           &_registry._SnippingTonemapsHDR, 2);
-          if (ImGui::IsItemHovered ())
+          ImGui::SeparatorEx       (ImGuiSeparatorFlags_Vertical);
+          ImGui::SameLine          ();
+
+          // X (Close) Button
+          ImGui::BeginGroup        ();
+          ImGui::PushStyleColor   (ImGuiCol_ButtonHovered, ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_Failure));
+          ImGui::PushStyleColor   (ImGuiCol_ButtonActive,  ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_Failure) * ImVec4(1.2f, 1.2f, 1.2f, 1.0f));
+
+          static bool closeButtonHoverActive = false;
+
+          if (_registry._StyleLightMode && closeButtonHoverActive)
+            ImGui::PushStyleColor (ImGuiCol_Text, ImGui::GetStyleColorVec4 (ImGuiCol_WindowBg)); //ImVec4 (0.9F, 0.9F, 0.9F, 1.0f));
+
+          if (ImGui::Button (ICON_FA_XMARK, ImVec2 ( 30.0f * SKIF_ImGui_GlobalDPIScale, 0.0f ) )) // HotkeyEsc is situational
+            _registry._SnippingModeExit = true;
+      
+          if (_registry._StyleLightMode)
           {
-            ImGui::BeginTooltip    ();
-            ImGui::TextUnformatted ("Use SDR for Snips at or Below Windows SDR Desktop Luminance");
-            ImGui::Separator       ();
-            ImGui::BulletText      ("For HDR range content, captures an unaltered HDR image");
-            ImGui::EndTooltip      ();
+            if (closeButtonHoverActive)
+              ImGui::PopStyleColor ( );
+          
+            closeButtonHoverActive = (ImGui::IsItemHovered () || ImGui::IsItemActivated ());
           }
-          ImGui::TreePop           ();
+
+          ImGui::PopStyleColor     (2);
+          ImGui::EndGroup          ();
+          // End of X (Close) Button
+
           ImGui::EndGroup          ();
           if ( ImGui::IsWindowHovered () ||
                ImGui::IsItemActive    () )
@@ -2428,8 +2586,8 @@ wWinMain ( _In_     HINSTANCE hInstance,
           if (! clicked && SKIF_ImGui_SelectionRect (&selection._rect, allowable, 0, SelectionFlag_Filled))
           {
             _registry._SnippingModeExit = true;
-            _GetRectBelowCursor (&selection, false);
-            capture_area = selection;
+            _GetRectBelowCursor  (&selection, false);
+            capture_data         = selection;
           }
 
           else if (! ImGui::IsMouseDragging (ImGuiMouseButton_Left))
@@ -2446,7 +2604,7 @@ wWinMain ( _In_     HINSTANCE hInstance,
             {
               clicked = false;
               _registry._SnippingModeExit = true;
-              capture_area = selection_auto;
+              capture_data = selection_auto;
             }
 
             else if (selection_auto._rect.Min != selection_auto._rect.Max)
@@ -2462,13 +2620,16 @@ wWinMain ( _In_     HINSTANCE hInstance,
           else
             clicked = false;
 
-          if (capture_area._rect.GetArea() != 0)
+          if (capture_data._rect.GetArea() != 0)
           {
+            capture_data._mode   = _saveToDisk;
+            capture_data._select = _selectFile;
+            capture_data._names = SKIV_GetApplicationNames (capture_data._hwnd);
             ignoredWindows.clear();
 
             PLOG_VERBOSE << "Attempting to capture region...";
 
-            SKIV_Image_CaptureRegion (capture_area);
+            SKIV_Image_CaptureRegion (capture_data);
           }
         }
 #pragma endregion
@@ -2753,7 +2914,8 @@ wWinMain ( _In_     HINSTANCE hInstance,
               bKeepProcessAlive = false;
             break;
           case UITab_Settings:
-            SKIF_Tab_ChangeTo = UITab_Viewer;
+            if (! g_activeKeybindPopup)
+              SKIF_Tab_ChangeTo = UITab_Viewer;
             break;
           case UITab_About:
             break;
@@ -3374,7 +3536,7 @@ wWinMain ( _In_     HINSTANCE hInstance,
 
             SKIF_Util_GetClipboardBitmapData ( );
 
-            ImGui::InsertNotification({ ImGuiToastType::Info, 3000, "Received a bitmap paste" });
+            ImGui::InsertNotification({ ImGuiToastType::Info, 3000, "Received a bitmap paste", "" });
           }
 
           else if ((cbd & ClipboardData_HDROP))
@@ -3400,6 +3562,9 @@ wWinMain ( _In_     HINSTANCE hInstance,
       // Main rendering function
       ImGui::RenderNotifications ( );
 
+      SKIF_vecCurrentMode     = ImGui::GetWindowSize ( );
+      SKIF_vecCurrentPosition = ImGui::GetWindowPos  ( );
+
       // End the main ImGui window
       ImGui::End ( );
     }
@@ -3802,6 +3967,50 @@ wWinMain ( _In_     HINSTANCE hInstance,
   //SKIF_Util_UnregisterHotKeySVCTemp   ( );
   //SKIF_Util_UnregisterHotKeyHDRToggle ( );
 
+  // TODO: Make an exception for scenarios where remembering the size and pos makes sense,
+  //         e.g. when size / DPI <= regular size * 1.5x or something like that!!!
+  // 
+  // Only store window size and position to the registry if we are not in a maximized state
+  ImVec2 vecCurrentModeDPIUnaware = ImFloor (SKIF_vecCurrentMode / SKIF_ImGui_GlobalDPIScale);
+
+  if ((! IsZoomed (SKIF_ImGui_hWnd) && ! SKIF_ImGui_IsFullscreen (SKIF_ImGui_hWnd)) ||
+     (vecCurrentModeDPIUnaware.x <= SKIF_vecRegularModeDefault.x * 1.5f &&
+      vecCurrentModeDPIUnaware.y <= SKIF_vecRegularModeDefault.y * 1.5f))
+  {
+    // Only store the window size if we are not in service mode
+    if (! _registry._SnippingMode  &&
+        vecCurrentModeDPIUnaware.x > 0 &&
+        vecCurrentModeDPIUnaware.y > 0)
+    {
+      // Store a DPI-unaware size, so SKIF can automatically adjust it to the proper DPI on launch
+      _registry.iUIWidth  = static_cast<int> (vecCurrentModeDPIUnaware.x);
+      _registry.iUIHeight = static_cast<int> (vecCurrentModeDPIUnaware.y);
+    
+      _registry.regKVUIWidth .putData (_registry.iUIWidth);
+      _registry.regKVUIHeight.putData (_registry.iUIHeight);
+
+      PLOG_INFO << "Wrote the window size to the registry: " << _registry.iUIWidth << "x" << _registry.iUIHeight;
+    }
+
+    // Note that negative window positions are valid!
+    if (SKIF_vecCurrentPosition.x != -1.0f &&
+        SKIF_vecCurrentPosition.y != -1.0f)
+    {
+      // Doesn't seem to be needed
+      //RECT dwmBorder = { };
+      //if (S_OK == DwmGetWindowAttribute (SKIF_ImGui_hWnd, DWMWA_EXTENDED_FRAME_BOUNDS, &dwmBorder, sizeof(dwmBorder)))
+      //{ }
+
+      _registry.iUIPositionX = static_cast<int> (SKIF_vecCurrentPosition.x);
+      _registry.iUIPositionY = static_cast<int> (SKIF_vecCurrentPosition.y);
+    
+      _registry.regKVUIPositionX.putData (_registry.iUIPositionX);
+      _registry.regKVUIPositionY.putData (_registry.iUIPositionY);
+
+      PLOG_INFO << "Wrote the window position to the registry: " << _registry.iUIPositionX << ", " << _registry.iUIPositionY;
+    }
+  }
+
   PLOG_INFO << "Killing timers...";
   KillTimer (SKIF_Notify_hWnd, IDT_REFRESH_TOOLTIP);
   KillTimer (SKIF_Notify_hWnd, IDT_REFRESH_UPDATER);
@@ -4125,7 +4334,7 @@ SKIF_WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
       POINT capture_point        = { };
       RECT  capture_rect         = { };
-      std::wstring filename = L"Display";
+      SKIV_CaptureData::Application app_names = { L"Display"};
 
       if (mode == CaptureMode_Window)
       {
@@ -4151,7 +4360,7 @@ SKIF_WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
           capture_rect.right  = std::min (capture_rect.right,  minfo.rcMonitor.right);
           capture_rect.bottom = std::min (capture_rect.bottom, minfo.rcMonitor.bottom);
 
-          filename = SKIV_GetBaseFilename (hwndBeforeSnip);
+          app_names = SKIV_GetApplicationNames (hwndBeforeSnip);
         }
       }
 
@@ -4159,7 +4368,7 @@ SKIF_WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
       {
         GetCursorPos (&capture_point);
         HWND hWndBelowCursor = WindowFromPoint (capture_point);
-        filename = SKIV_GetBaseFilename (hWndBelowCursor);
+        app_names = SKIV_GetApplicationNames (hWndBelowCursor);
       }
 
       DirectX::ScratchImage captured_img;
@@ -4178,13 +4387,14 @@ SKIF_WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
         if (mode == CaptureMode_Window)
         {
-          const SKIV_Region region =
-                SKIV_Region (
+          const SKIV_CaptureData region =
+                SKIV_CaptureData (
                   ImRect (static_cast<float> (capture_rect.left  ),
                           static_cast<float> (capture_rect.top   ),
                           static_cast<float> (capture_rect.right ),
                           static_cast<float> (capture_rect.bottom)),
-                  filename
+                  app_names,
+                  ((_registry.eScreenshotsAutosave & mode) == CaptureMode_Window) ? CaptureMode_Window : CaptureMode_None
           );
 
           //PLOG_VERBOSE << "capture_rect.left  : " << capture_rect.left;
@@ -4199,11 +4409,12 @@ SKIF_WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
         else if (mode == CaptureMode_Screen)
         {
           extern skiv_image_desktop_s SKIV_DesktopImage;
-          const SKIV_Region region =
-                SKIV_Region (
+          const SKIV_CaptureData region =
+                SKIV_CaptureData (
                   ImRect (ImVec2 (0, 0),
                           SKIV_DesktopImage._resolution),
-                  filename
+                  app_names,
+                  ((_registry.eScreenshotsAutosave & mode) == CaptureMode_Screen) ? CaptureMode_Screen : CaptureMode_None
           );
 
           SKIV_Image_CaptureRegion (region);
diff --git a/src/tabs/settings.cpp b/src/tabs/settings.cpp
index a01e419..15ca03d 100644
--- a/src/tabs/settings.cpp
+++ b/src/tabs/settings.cpp
@@ -16,16 +16,47 @@
 #include <utility/gamepad.h>
 #include "../../version.h"
 #include <tabs/common_ui.h>
+#include <ImGuiNotify.hpp>
 #include <set>
 
 extern bool allowShortcutCtrlA;
 
+struct kb_kv_s
+{
+  SK_KeybindMultiState*                           _key;
+  SKIF_RegistrySettings::KeyValue <std::wstring>* _reg;
+  std::function <void (SK_KeybindMultiState*)>    _callback;
+  std::function <bool (void)>                     _show;
+};
+
+struct m_s
+{
+  CaptureMode                  _type;
+  char*                        _label;
+  char*                        _main_id;
+  char*                        _disk_id;
+  bool                         _main_value;
+  bool                         _disk_value;
+  kb_kv_s*                     _keybind;
+};
+
+PopupState ContextMenuSettings = PopupState_Closed;
+
 void
 SKIF_UI_Tab_DrawSettings (void)
 {
   static SKIF_CommonPathsCache& _path_cache = SKIF_CommonPathsCache::GetInstance ( );
   static SKIF_RegistrySettings& _registry   = SKIF_RegistrySettings::GetInstance ( );
-  
+
+  static kb_kv_s kbToggleHDRDisplay =
+    { &_registry.kbToggleHDRDisplay, &_registry.regKVHotkeyToggleHDRDisplay, { [](SK_KeybindMultiState* ptr) { SKIF_Util_RegisterHotKeyHDRToggle (ptr->getKeybind()                    ); } }, { []() { return (SKIF_Util_IsWindows10v1709OrGreater ( ) && SKIF_Util_IsHDRSupported (NULL)); } } };
+  static kb_kv_s kbCaptureWindow    =
+    { &_registry.kbCaptureWindow,    &_registry.regKVHotkeyCaptureWindow,    { [](SK_KeybindMultiState* ptr) { SKIF_Util_RegisterHotKeyCapture   (CaptureMode_Window, ptr->getKeybind()); } }, { []() { return true; } } };
+  static kb_kv_s kbCaptureRegion    =
+    { &_registry.kbCaptureRegion,    &_registry.regKVHotkeyCaptureRegion,    { [](SK_KeybindMultiState* ptr) { SKIF_Util_RegisterHotKeyCapture   (CaptureMode_Region, ptr->getKeybind()); } }, { []() { return true; } } };
+  static kb_kv_s kbCaptureScreen    =
+    { &_registry.kbCaptureScreen,    &_registry.regKVHotkeyCaptureScreen,    { [](SK_KeybindMultiState* ptr) { SKIF_Util_RegisterHotKeyCapture   (CaptureMode_Screen, ptr->getKeybind()); } }, { []() { return true; } } };
+
   if (ImGui::Button (ICON_FA_LEFT_LONG " Go back###GoBackBtn1", ImVec2 (150.0f * SKIF_ImGui_GlobalDPIScale, 30.0f * SKIF_ImGui_GlobalDPIScale)))
     SKIF_Tab_ChangeTo = UITab_Viewer;
 
@@ -69,21 +100,100 @@ SKIF_UI_Tab_DrawSettings (void)
     ImGui::PushStyleColor   (
       ImGuiCol_Text, ImGui::GetStyleColorVec4(ImGuiCol_SKIF_TextBase)
                               );
-
     SKIF_ImGui_Spacing      ( );
+
+    static float folderPosX = 0.0f;
+
+    ImGui::TextColored (
+      ImGui::GetStyleColorVec4(ImGuiCol_SKIF_TextCaption),
+        "Name Pattern: "
+    );
+
+    constexpr int       maxChars  = 50;
+    static char pattern[maxChars] = {};
+    static bool warnNonUnique = false;
+           bool savePattern   = false;
+
+    SK_RunOnce (strncpy_s (pattern, maxChars, SK_WideCharToUTF8 (_registry.wsScreenshotsPattern).data(), _TRUNCATE));
     
+    ImGui::SameLine ( );
+    ImGui::SetCursorPosX(folderPosX);
 
-    if ( ImGui::Checkbox ( "Save screenshots", &_registry.bSaveScreenshots ) )
-      _registry.regKVSaveScreenshots.putData (  _registry.bSaveScreenshots);
+    if (ImGui::InputTextEx ("###PatternInput", "<app>_<date>_<time>", pattern, maxChars, ImVec2(250.0f * SKIF_ImGui_GlobalDPIScale, 0.0f), ImGuiInputTextFlags_EnterReturnsTrue))
+      savePattern = true;
 
-    ImGui::TreePush ("ScreenshotsFolder");
+    if (ImGui::IsItemHovered ())
+    {
+      ImGui::BeginTooltip    ();
+      ImGui::TextUnformatted ("How to use:");
+      ImGui::Separator       ();
+      ImGui::BulletText      ("<app> = Uses Special K profile name, executable product name, or filename, in that order.");
+      ImGui::BulletText      ("<pro> = Uses product name.");
+      ImGui::BulletText      ("<exe> = Uses executable name.");
+      ImGui::BulletText      ("<wnd> = Uses window title.");
+      ImGui::BulletText      ("<date> = Uses local-aware date format.");
+      ImGui::BulletText      ("<time> = Uses local-aware time format.");
+      ImGui::TextUnformatted ("Hint: Folder separators (\\) are also supported! ;)");
+      ImGui::EndTooltip      ();
+    }
 
-    if (! _registry.bSaveScreenshots)
-      SKIF_ImGui_PushDisableState ( );
+    if (! ImGui::IsItemActive ())
+    {
+      if (pattern[0] == '\0')
+        strncpy (pattern, "<app>_<date>_<time>", maxChars);
+    }
+    else if (ImGui::GetIO().KeyCtrl && ImGui::GetKeyData(ImGuiKey_S)->DownDuration == 0.0f)
+    {
+      savePattern = true;
+
+      if (pattern[0] == '\0')
+        ImGui::SetWindowFocus (NULL);
+    }
+
+    ImGui::SameLine ( );
+
+    ImGui::PushStyleColor (ImGuiCol_Text, ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_Success));
+    if (ImGui::Button (ICON_FA_FLOPPY_DISK))
+      savePattern = true;
+    ImGui::PopStyleColor ();
 
-    if (ImGui::Button ("Browse"))
+    if (savePattern)
     {
-      std::wstring newPath = SKIF_Util_FileExplorer_BrowseFolder (_path_cache.skiv_screenshots);
+      savePattern = false;
+
+      if (pattern[0] == '\0')
+        strncpy (pattern, "<app>_<date>_<time>", maxChars);
+
+      StrTrimA (pattern, " \t\r\n");
+      _registry.wsScreenshotsPattern = SK_UTF8ToWideChar (pattern);
+      _registry.regKVScreenshotsPattern.putData (_registry.wsScreenshotsPattern);
+      
+      ImGui::InsertNotification ({ ImGuiToastType::Success, 1000, "Saved", ""});
+    }
+
+    if (StrStrA (pattern, "<app>")  == NULL &&
+        StrStrA (pattern, "<pro>")  == NULL &&
+        StrStrA (pattern, "<exe>")  == NULL &&
+        StrStrA (pattern, "<wnd>")  == NULL &&
+        StrStrA (pattern, "<date>") == NULL &&
+        StrStrA (pattern, "<time>") == NULL)
+    {
+      ImGui::TextColored (ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_Yellow), ICON_FA_TRIANGLE_EXCLAMATION);
+      ImGui::SameLine    ( );
+      ImGui::Text        ("Missing variables. Any captured shot will overwrite the existing file!");
+    }
+
+    ImGui::Spacing ();
+
+    ImGui::TextColored (
+      ImGui::GetStyleColorVec4(ImGuiCol_SKIF_TextCaption),
+        "Screenshots Folder: "
+    );
+    ImGui::SameLine ( );
+    folderPosX = ImGui::GetCursorPosX();
+    if (ImGui::Selectable(_path_cache.skiv_screenshotsA))
+    {
+      std::wstring newPath = SKIF_Util_FileExplorer_BrowseForFolder (_path_cache.skiv_screenshots);
 
       if (PathFileExistsW (newPath.c_str()))
       {
@@ -101,75 +211,98 @@ SKIF_UI_Tab_DrawSettings (void)
       }
     }
 
+    ImGui::Spacing ();
+
+    static std::vector <m_s>
+      modes = {
+        { CaptureMode_Window, "Window", "###ModeToggle-Window", "###DiskToggle-Window", ((_registry.eScreenshotsHotkeys & CaptureMode_Window) == CaptureMode_Window), ((_registry.eScreenshotsAutosave & CaptureMode_Window) == CaptureMode_Window), &kbCaptureWindow },
+        { CaptureMode_Region, "Region", "###ModeToggle-Region", "###DiskToggle-Region", ((_registry.eScreenshotsHotkeys & CaptureMode_Region) == CaptureMode_Region), ((_registry.eScreenshotsAutosave & CaptureMode_Region) == CaptureMode_Region), &kbCaptureRegion },
+        { CaptureMode_Screen, "Screen", "###ModeToggle-Screen", "###DiskToggle-Screen", ((_registry.eScreenshotsHotkeys & CaptureMode_Screen) == CaptureMode_Screen), ((_registry.eScreenshotsAutosave & CaptureMode_Screen) == CaptureMode_Screen), &kbCaptureScreen }
+    };
+    
+    ImGui::TextColored (
+      ImGui::GetStyleColorVec4(ImGuiCol_SKIF_TextCaption),
+        "Capture Mode:"
+    );
     ImGui::SameLine ( );
-    ImGui::Spacing  ( );
+    ImGui::ItemSize (ImVec2 (ImGui::GetFrameHeight (), ImGui::GetFrameHeight ()), ImGui::GetStyle().FramePadding.y);
     ImGui::SameLine ( );
 
-    ImGui::Text ("%s", _path_cache.skiv_screenshotsA);
+    float col2 = ImGui::GetCursorPosX ();
+    ImGui::TextColored (ImGui::GetStyleColorVec4(ImGuiCol_SKIF_Info), " " ICON_FA_FLOPPY_DISK);
+    SKIF_ImGui_SetHoverTip ("Save screenshot on disk");
+    ImGui::SameLine ( );
+    ImGui::ItemSize (ImVec2 (ImGui::GetFrameHeight (), ImGui::GetFrameHeight ()), ImGui::GetStyle().FramePadding.y);
+    ImGui::SameLine ( );
 
-    if (! _registry.bSaveScreenshots)
-      SKIF_ImGui_PopDisableState ( );
+    float col3 = ImGui::GetCursorPosX ();
 
-    ImGui::TreePop  ( );
-  }
+    ImGui::TextColored (
+      ImGui::GetStyleColorVec4(ImGuiCol_SKIF_TextCaption),
+       "Keybinding: " ICON_FA_KEYBOARD
+    );
 
-  ImGui::Spacing ();
-  ImGui::Spacing ();
+    ImGui::TreePush ("CaptureModes");
+    
+    ImGui::BeginGroup ();
+    for (auto& mode : modes)
+    {
+      //ImGui::ItemSize (ImVec2 (0.0f, ImGui::GetFrameHeight ()), ImGui::GetStyle().FramePadding.y);
+      if (ImGui::Checkbox (mode._main_id, &mode._main_value))
+      {
+        if (mode._main_value)
+        {
+          _registry.eScreenshotsHotkeys |=  mode._type;
+          mode._keybind->_callback (mode._keybind->_key);
+        }
+        else {
+          _registry.eScreenshotsHotkeys &= ~mode._type;
+          SKIF_Util_UnregisterHotKeyCapture(mode._type);
+        }
 
-#pragma endregion
+        _registry.regKVScreenshotsHotkeys.putData (_registry.eScreenshotsHotkeys);
+      }
 
-#pragma region Section: Keybindings
+      if (! mode._main_value)
+        SKIF_ImGui_PushDisableState();
 
-  if (ImGui::CollapsingHeader ("Keybindings###SKIF_SettingsHeader-1", ImGuiTreeNodeFlags_DefaultOpen))
-  {
-    SKIF_ImGui_Spacing      ( );
+      ImGui::SameLine      ();
+      ImGui::Text          ( "%s",
+                            mode._label);
 
-    struct kb_kv_s
-    {
-      SK_KeybindMultiState*                           _key;
-      SKIF_RegistrySettings::KeyValue <std::wstring>* _reg;
-      std::function <void (SK_KeybindMultiState*)>    _callback;
-      std::function <bool (void)>                     _show;
-    };
+      ImGui::SameLine      ();
+      ImGui::SetCursorPosX (col2);
 
-    static std::vector <kb_kv_s>
-      keybinds = {
-      { &_registry.kbCaptureWindow,    &_registry.regKVHotkeyCaptureWindow,    { [](SK_KeybindMultiState* ptr) { SKIF_Util_RegisterHotKeyCapture   (CaptureMode_Window, ptr->getKeybind()); } }, { []() { return true; } } },
-      { &_registry.kbCaptureRegion,    &_registry.regKVHotkeyCaptureRegion,    { [](SK_KeybindMultiState* ptr) { SKIF_Util_RegisterHotKeyCapture   (CaptureMode_Region, ptr->getKeybind()); } }, { []() { return true; } } },
-      { &_registry.kbCaptureScreen,    &_registry.regKVHotkeyCaptureScreen,    { [](SK_KeybindMultiState* ptr) { SKIF_Util_RegisterHotKeyCapture   (CaptureMode_Screen, ptr->getKeybind()); } }, { []() { return true; } } },
-      { &_registry.kbToggleHDRDisplay, &_registry.regKVHotkeyToggleHDRDisplay, { [](SK_KeybindMultiState* ptr) { SKIF_Util_RegisterHotKeyHDRToggle (ptr->getKeybind()                    ); } }, { []() { return (SKIF_Util_IsWindows10v1709OrGreater ( ) && SKIF_Util_IsHDRSupported (NULL)); } } }
-    };
+      if (ImGui::Checkbox (mode._disk_id, &mode._disk_value))
+      {
+        if (mode._disk_value)
+          _registry.eScreenshotsAutosave |=  mode._type;
+        else
+          _registry.eScreenshotsAutosave &= ~mode._type;
 
-    ImGui::BeginGroup ();
-    for (auto& keybind : keybinds)
-    {
-      if (! keybind._show())
-        continue;
+        _registry.regKVScreenshotsAutosave.putData (_registry.eScreenshotsAutosave);
+      }
 
-      ImGui::Text          ( "%s:  ",
-                            keybind._key->bind_name );
-      ImGui::Spacing ();
-    }
-    ImGui::EndGroup   ();
-    ImGui::SameLine   ();
-    ImGui::BeginGroup ();
-    for (auto& keybind : keybinds)
-    {
-      if (! keybind._show())
-        continue;
+      ImGui::SameLine      ();
+      ImGui::SetCursorPosX (col3);
 
-      if (SK_ImGui_Keybinding (keybind._key))
+      if (SK_ImGui_Keybinding (mode._keybind->_key))
       {
         // Only update the registry if we are done assigning
-        if (! keybind._key->assigning)
-          keybind._reg->putData (keybind._key->saved.human_readable);
+        if (! mode._keybind->_key->assigning)
+          mode._keybind->_reg->putData (mode._keybind->_key->saved.human_readable);
 
-        keybind._callback (keybind._key);
+        mode._keybind->_callback (mode._keybind->_key);
       }
 
-      ImGui::Spacing ();
+      if (! mode._main_value)
+        SKIF_ImGui_PopDisableState();
     }
     ImGui::EndGroup   ();
+
+    ImGui::TreePop  ( );
+    
+    ImGui::PopStyleColor ();
   }
 
   ImGui::Spacing ();
@@ -179,12 +312,8 @@ SKIF_UI_Tab_DrawSettings (void)
 
 #pragma region Section: Image
 
-  if (ImGui::CollapsingHeader ("Images###SKIF_SettingsHeader-2", ImGuiTreeNodeFlags_DefaultOpen))
+  if (ImGui::CollapsingHeader ("Images###SKIF_SettingsHeader-1"))
   {
-    ImGui::PushStyleColor   (
-      ImGuiCol_Text, ImGui::GetStyleColorVec4(ImGuiCol_SKIF_TextBase)
-                              );
-
     SKIF_ImGui_Spacing      ( );
 
 #if 0
@@ -300,7 +429,7 @@ SKIF_UI_Tab_DrawSettings (void)
 
 
 #pragma region Section: Appearances
-  if (ImGui::CollapsingHeader ("Appearance###SKIF_SettingsHeader-3", ImGuiTreeNodeFlags_DefaultOpen))
+  if (ImGui::CollapsingHeader ("Appearance###SKIF_SettingsHeader-2"))
   {
     ImGui::PushStyleColor   (
       ImGuiCol_Text, ImGui::GetStyleColorVec4(ImGuiCol_SKIF_TextBase)
@@ -684,6 +813,62 @@ SKIF_UI_Tab_DrawSettings (void)
   ImGui::Spacing ();
 #pragma endregion
 
+#pragma region Section: Keybindings
+
+  if (ImGui::CollapsingHeader ("Keybindings###SKIF_SettingsHeader-3", ImGuiTreeNodeFlags_DefaultOpen))
+  {
+    ImGui::PushStyleColor   (
+      ImGuiCol_Text, ImGui::GetStyleColorVec4(ImGuiCol_SKIF_TextBase)
+                              );
+    SKIF_ImGui_Spacing      ( );
+
+    static std::vector <kb_kv_s*>
+      keybinds = {
+        &kbToggleHDRDisplay,
+        &kbCaptureWindow,
+        &kbCaptureRegion,
+        &kbCaptureScreen
+    };
+
+    ImGui::BeginGroup ();
+    for (auto& keybind : keybinds)
+    {
+      if (! keybind->_show())
+        continue;
+
+      ImGui::Text          ( "%s:  ",
+                            keybind->_key->bind_name );
+      ImGui::Spacing ();
+    }
+    ImGui::EndGroup   ();
+    ImGui::SameLine   ();
+    ImGui::BeginGroup ();
+    for (auto& keybind : keybinds)
+    {
+      if (! keybind->_show())
+        continue;
+
+      // TODO: Fix bug that causes the hotkey to remain unregistered if SKIV loses focus while the keybind dialog is visible
+      if (SK_ImGui_Keybinding (keybind->_key))
+      {
+        // Only update the registry if we are done assigning
+        if (! keybind->_key->assigning)
+          keybind->_reg->putData (keybind->_key->saved.human_readable);
+
+        keybind->_callback (keybind->_key);
+      }
+
+      ImGui::Spacing ();
+    }
+    ImGui::EndGroup   ();
+    ImGui::PopStyleColor ();
+  }
+
+  ImGui::Spacing ();
+  ImGui::Spacing ();
+
+#pragma endregion
+
 #pragma region Section: Advanced
   if (ImGui::CollapsingHeader ("Advanced###SKIF_SettingsHeader-4", ImGuiTreeNodeFlags_DefaultOpen))
   {
@@ -746,7 +931,7 @@ SKIF_UI_Tab_DrawSettings (void)
     if ( ImGui::Checkbox ( "Close to the notification area", &_registry.bCloseToTray ) )
       _registry.regKVCloseToTray.putData (                    _registry.bCloseToTray );
 
-    if ( ImGui::Checkbox ( "Always open this app on the same monitor as the mouse", &_registry.bOpenAtCursorPosition ) )
+    if ( ImGui::Checkbox ( "Open this app on the same monitor as the  " ICON_FA_ARROW_POINTER, &_registry.bOpenAtCursorPosition ) )
       _registry.regKVOpenAtCursorPosition.putData (                                  _registry.bOpenAtCursorPosition );
 
 #ifdef HAS_AUTO_UPDATE
@@ -1128,4 +1313,94 @@ SKIF_UI_Tab_DrawSettings (void)
 
 #pragma endregion
 
+#pragma region ContextMenuSettings
+
+  auto _IsRightClicked = [&](void) -> bool
+  {
+    if (ImGui::IsMouseClicked (ImGuiMouseButton_Right))
+    {
+      return true;
+    }
+
+    // Activate button held for >= .4 seconds -> right-click
+    if (ImGui::GetKeyData (ImGuiKey_GamepadFaceDown)->DownDuration > 0.4f &&
+        ImGui::GetKeyData (ImGuiKey_GamepadFaceDown)->DownDuration < 5.0f)
+    {
+      ImGui::GetKeyData (ImGuiKey_GamepadFaceDown)->DownDuration     = 5.0f;
+      ImGui::GetKeyData (ImGuiKey_GamepadFaceDown)->DownDurationPrev = 0.0f;
+
+      ImGui::ClearActiveID ( );
+
+      return true;
+    }
+
+    // Start button = Menu
+    if (ImGui::IsKeyPressed (ImGuiKey_GamepadStart))
+    {
+      ImGui::GetKeyData (ImGuiKey_GamepadStart)->DownDuration     =  0.01f;
+      ImGui::GetKeyData (ImGuiKey_GamepadStart)->DownDurationPrev =  0.00f;
+
+      ImGui::ClearActiveID ( );
+
+      return true;
+    }
+
+    return false;
+  };
+
+  // Act on all right clicks, because why not? :D
+  if (! SKIF_ImGui_IsAnyPopupOpen ( ) && _IsRightClicked ())
+    ContextMenuSettings = PopupState_Open;
+
+  // Open the Empty Space Menu
+  if (ContextMenuSettings == PopupState_Open)
+    ImGui::OpenPopup    ("ContextMenuSettings");
+
+
+  if (ImGui::BeginPopup   ("ContextMenuSettings", ImGuiWindowFlags_NoMove))
+  {
+    ContextMenuSettings = PopupState_Opened;
+
+    ImGui::PushStyleColor (ImGuiCol_NavHighlight, ImVec4(0,0,0,0));
+
+    if (SKIF_ImGui_MenuItemEx2 ("Go back###GoBackCM", ICON_FA_LEFT_LONG)) // ICON_FA_LIST_CHECK
+      SKIF_Tab_ChangeTo = UITab_Viewer;
+
+    ImGui::Separator ( );
+
+    if (SKIF_ImGui_MenuItemEx2 ("Fullscreen", SKIF_ImGui_IsFullscreen (SKIF_ImGui_hWnd) ? ICON_FA_DOWN_LEFT_AND_UP_RIGHT_TO_CENTER : ICON_FA_UP_RIGHT_AND_DOWN_LEFT_FROM_CENTER, ImGui::GetStyleColorVec4 (ImGuiCol_Text), "Ctrl+F"))
+    {
+      SKIF_ImGui_SetFullscreen (SKIF_ImGui_hWnd, ! SKIF_ImGui_IsFullscreen (SKIF_ImGui_hWnd));
+    }
+
+    ImGui::Separator ( );
+
+    if (_registry.bCloseToTray)
+    {
+      if (SKIF_ImGui_MenuItemEx2 ("Close app", 0, ImGui::GetStyleColorVec4(ImGuiCol_SKIF_Info), "Esc"))
+        PostMessage (SKIF_Notify_hWnd, WM_SKIF_MINIMIZE, 0x0, 0x0);
+    }
+
+    else
+    {
+      if (SKIF_ImGui_MenuItemEx2 ("Minimize", 0, ImGui::GetStyleColorVec4(ImGuiCol_SKIF_Info), "Ctrl+N"))
+        PostMessage (SKIF_Notify_hWnd, WM_SKIF_MINIMIZE, 0x0, 0x0);
+    }
+
+    if (SKIF_ImGui_MenuItemEx2 ("Exit", 0, ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_Info), "Ctrl+Q"))
+    {
+      extern bool bKeepWindowAlive;
+      bKeepWindowAlive = false;
+    }
+
+
+    ImGui::PopStyleColor  ( );
+    ImGui::EndPopup       ( );
+  }
+
+  else
+    ContextMenuSettings = PopupState_Closed;
+
+#pragma endregion
+
 }
diff --git a/src/tabs/viewer.cpp b/src/tabs/viewer.cpp
index 0ddb5b7..1db02e2 100644
--- a/src/tabs/viewer.cpp
+++ b/src/tabs/viewer.cpp
@@ -45,7 +45,6 @@
 #include <locale>
 #include <codecvt>
 #include <fstream>
-#include <filesystem>
 #include <string>
 #include <sstream>
 #include <concurrent_queue.h>
@@ -89,7 +88,6 @@
 
 #pragma comment (lib, "dxguid.lib")
 
-
 ImRect copyRect = { 0,0,0,0 };
 bool wantCopyToClipboard = false;
 
@@ -178,6 +176,7 @@ const std::initializer_list<FileSignature> supported_hdr_encode_formats =
 //FileSignature { L"image/vnd-ms.dds",          { L".dds"  },          { 0x44, 0x44, 0x53, 0x20 } },
 };
 
+
 bool isJXLDecoderAvailable (void)
 {
   static HMODULE hModBrotliCommon = nullptr;
@@ -2684,6 +2683,9 @@ SKIF_UI_Tab_DrawViewer (void)
 {
   extern bool imageFadeActive;
 
+  // Used to monitor the current image folder
+  static skiv_image_directory_s _current_folder;
+
   // ** Move this code somewhere more sensible
   //
   // User is requesting to copy the loaded image to clipboard,
@@ -2725,11 +2727,12 @@ SKIF_UI_Tab_DrawViewer (void)
                   SUCCEEDED (DirectX::CopyRectangle (*captured_img.GetImages   (), src_rect,
                                                                                    *subrect.GetImages (), DirectX::TEX_FILTER_DEFAULT, 0, 0)))
               {
-                if (SKIV_Image_CopyToClipboard (subrect.GetImages (), cover.is_hdr, true, L"cp_rect"))
+
+                if (SKIV_Image_CopyToClipboard (subrect.GetImages (), cover.is_hdr, { ImRect(), L"cp_rect", CaptureMode_None } ))
                 {
                   ImGui::InsertNotification (
                     {
-                      ImGuiToastType::Info,
+                      ImGuiToastType::Success,
                       3000,
                       "Copied area to clipboard", "%.fx%.f -> %.fx%.f",
                       copyRect.Min.x,
@@ -2760,11 +2763,11 @@ SKIF_UI_Tab_DrawViewer (void)
 
             else
             {
-              if (SKIV_Image_CopyToClipboard (captured_img.GetImages (), cover.is_hdr, true, L"cp_full"))
+              if (SKIV_Image_CopyToClipboard (captured_img.GetImages (), cover.is_hdr, { ImRect(), L"cp_full", CaptureMode_None } ))
               {
                 ImGui::InsertNotification (
                   {
-                    ImGuiToastType::Info,
+                    ImGuiToastType::Success,
                     3000,
                     "Copied image to clipboard", ""
                   }
@@ -2787,7 +2790,6 @@ SKIF_UI_Tab_DrawViewer (void)
     }
   }
 
-
   auto _SwapOutCover = [&](void) -> void
   {
     // Hide the current cover and set it up to be unloaded
@@ -2828,6 +2830,23 @@ SKIF_UI_Tab_DrawViewer (void)
     }
   };
 
+  auto _DeleteImage = [&](void) -> void
+  {
+    if (_current_folder.fileList.getActiveFile() == nullptr)
+      return;
+
+    //DeleteFile (_current_folder.activeFile->path.c_str());
+
+    // TODO: Fix focus loss bug when a warning is shown...
+    if (SKIF_Util_FileExplorer_DeleteFile (_current_folder.fileList.getActiveFile()->path.c_str(), true))
+    {
+      dragDroppedFilePath = _current_folder.fileList.deleteImage ( );
+
+      if (dragDroppedFilePath.empty())
+        _SwapOutCover ();
+    }
+  };
+
 #pragma region Initialization
 
   SK_RunOnce (fAlpha = (_registry.bFadeCovers) ? 0.0f : 1.0f);
@@ -2901,115 +2920,6 @@ SKIF_UI_Tab_DrawViewer (void)
       ::SetWindowText (SKIF_ImGui_hWnd, (cover.file_info.filename + L" - " + SKIV_WINDOW_TITLE_SHORT_W).c_str());
   }
 
-  // Monitor the current image folder
-  struct {
-    std::wstring              orig_path; // Holds a cached copy of cover.path
-    std::wstring              filename;  // Image filename
-    std::wstring              path;      // Parent folder path
-    std:: string              path_utf8;
-    SKIF_DirectoryWatch       watch;
-    std::vector<std::wstring> fileList;
-    unsigned int              fileListIndex = 0;
-
-    void reset (void)
-    {
-      PLOG_VERBOSE << "reset _current_folder!";
-
-      orig_path.clear();
-      filename.clear();
-      path.clear();
-      path_utf8.clear();
-      fileList.clear();
-      fileListIndex = 0;
-      watch.reset();
-    }
-
-    std::wstring nextImage (void)
-    {
-      if (fileList.size() == 0 || fileListIndex == fileList.size() - 1)
-        return L"";
-
-      fileListIndex++;
-      fileListIndex %= fileList.size();
-      return (path + LR"(\)" + fileList[fileListIndex]);
-    }
-
-    std::wstring prevImage (void)
-    {
-      if (fileList.size() == 0 || fileListIndex == 0)
-        return L"";
-
-      fileListIndex--;
-      fileListIndex %= fileList.size();
-      return (path + LR"(\)" + fileList[fileListIndex]);
-    }
-
-    // Find the position of the image in the current folder
-    void findFileIndex (void)
-    {
-      // Set the index to the proper position
-      fileListIndex = 0;
-      for (auto& file : fileList)
-      {
-        if (filename != file)
-          fileListIndex++;
-        else
-          break;
-      }
-    }
-
-    // Retrieve all files in the folder, and identify our current place among them...
-    void updateFolderData (void)
-    {
-      HANDLE hFind        = INVALID_HANDLE_VALUE;
-      WIN32_FIND_DATA ffd = { };
-      fileList.clear();
-
-      PLOG_DEBUG << "Discovering ... " << (path + LR"(\*.*)");
-
-      hFind = 
-        FindFirstFileExW ((path + LR"(\*.*)").c_str(), FindExInfoBasic, &ffd, FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH);
-
-      if (INVALID_HANDLE_VALUE != hFind)
-      {
-        fileList.push_back (ffd.cFileName);
-
-        while (FindNextFile (hFind, &ffd))
-          fileList.push_back (ffd.cFileName);
-
-        FindClose (hFind);
-      }
-
-      if (! fileList.empty())
-      {
-        std::vector<std::wstring> filtered;
-
-        // Filter out unsupported file formats using their file extension
-        for (auto& file : fileList)
-          if (isExtensionSupported (std::filesystem::path(file).extension().wstring()))
-            filtered.push_back (file);
-
-        fileList = filtered;
-
-        if (! fileList.empty())
-        {
-          std::sort (fileList.begin(),
-                     fileList.end  (), 
-            []( const std::wstring& a,
-                const std::wstring& b ) -> int
-            {
-              return StrCmpLogicalW (a.c_str(), b.c_str()) < 0;
-            }
-          );
-
-          findFileIndex ( );
-        }
-      }
-
-      PLOG_DEBUG << "Found " << fileList.size() << " supported images in the folder.";
-    }
-  } static _current_folder;
-
   // Do not clear when we are loading an image (so as to not process the same folder constantly)
   if (! loadImage && ! tryingToLoadImage)
   {
@@ -3018,53 +2928,82 @@ SKIF_UI_Tab_DrawViewer (void)
     // Identify when an image has been closed
     if (cover.file_info.path.empty())
     {
-      if (! _current_folder.path.empty())
+      if (! _current_folder.folder_path.empty())
+      {
+        PLOG_VERBOSE << "cover.file_info.folder_path: " << cover.file_info.folder_path;
+        PLOG_VERBOSE << "_current_folder.folder_path: " << _current_folder.folder_path;
         _current_folder.reset();
+      }
+
+      PLOG_VERBOSE << "cover.file_info.path: " << cover.file_info.path;
     }
 
     // Identify when we're dealing with a whole new folder
-    if (cover.file_info.folder_path != _current_folder.path)
+    if (cover.file_info.folder_path != _current_folder.folder_path)
     {
+      PLOG_VERBOSE << "cover.file_info.folder_path: " << cover.file_info.folder_path;
+      PLOG_VERBOSE << "_current_folder.folder_path: " << _current_folder.folder_path;
       _current_folder.reset();
       
-      _current_folder.orig_path  = cover.file_info.path;
-      std::filesystem::path path = SKIF_Util_NormalizeFullPath (cover.file_info.path);
-      _current_folder.filename   = path.filename().wstring();
-      _current_folder.path       = path.parent_path().wstring();
-      _current_folder.path_utf8  = SK_WideCharToUTF8 (_current_folder.path);
+      std::filesystem::path path  = SKIF_Util_NormalizeFullPath (cover.file_info.path);
+      _current_folder.folder_path = path.parent_path().wstring();
 
-      PLOG_VERBOSE << "Watching the folder... " << _current_folder.path;
+      PLOG_VERBOSE << "Watching the folder... " << _current_folder.folder_path;
 
       // This triggers a new updateFolderData() run below
       dwLastSignaled = 1;
     }
 
     // Identify when a new file from the same folder has been dropped
-    if (cover.file_info.path != _current_folder.orig_path)
+    if (! _current_folder.fileList.empty() && _current_folder.fileList.getActiveFile() != nullptr &&
+      cover.file_info.filename != _current_folder.fileList.getActiveFile()->filename)
     {
-      _current_folder.orig_path  = cover.file_info.path;
-      std::filesystem::path path = SKIF_Util_NormalizeFullPath (cover.file_info.path);
-      _current_folder.filename   = path.filename().wstring();
-      _current_folder.findFileIndex ( );
+      //PLOG_DEBUG << "            cover.file_info.filename: " << cover.file_info.filename;
+      //PLOG_DEBUG << "_current_folder.activeFile->filename: " << _current_folder.activeFile->filename;
+
+      _current_folder.workerThread (true);
     }
 
     // Identify when the folder was changed outside of the app
-    if (_current_folder.watch.isSignaled (_current_folder.path))
-    {
+    //PLOG_VERBOSE << "_current_folder.watch was signaled! Delay checking the folder for another 5000 ms...";
+    if (_current_folder.watch.isSignaled (_current_folder.folder_path))
       dwLastSignaled = SKIF_Util_timeGetTime();
-      PLOG_VERBOSE << "_current_folder.watch was signaled! Delay checking the folder for another 500ms...";
-    }
 
-    if (dwLastSignaled != 0 && dwLastSignaled + 500 < SKIF_Util_timeGetTime())
+    if (dwLastSignaled != 0 && dwLastSignaled + 5000 < SKIF_Util_timeGetTime())
     {
-      _current_folder.updateFolderData();
+      if (! _current_folder.fileList.fileDeleted)
+        _current_folder.workerThread (true);
+      else
+        _current_folder.fileList.fileDeleted = false;
+
       dwLastSignaled = 0;
     }
+
+    int results = _current_folder.workerThread (false);
+    if (results > 0)
+    {
+      _current_folder.fileList.updateFileIterator (cover.file_info.path);
+
+      PLOG_VERBOSE << "cover.file_info.path: " << cover.file_info.path;
+      PLOG_VERBOSE << "_current_folder.fileList.getActiveFile(): " << _current_folder.fileList.getActiveFile()->path;
+
+      // If the selected file was changed from within _current_folder, also update dragDroppedFilePath
+      if (_current_folder.fileList.getActiveFile() != nullptr &&
+          cover.file_info.filename != _current_folder.fileList.getActiveFile()->filename)
+               dragDroppedFilePath  = _current_folder.fileList.getActiveFile()->path;
+
+      if (results == 2)
+        ImGui::InsertNotification ({ ImGuiToastType::Info, 5000, "Refreshed nearby images.", "" });
+    }
   }
 
   // Only apply changes to the scaling method if we actually have an image loaded
   if (cover.pRawTexSRV.p != nullptr)
   {
+    if (_current_folder.fileList.getActiveFile() != nullptr && ! _current_folder.fileList.getActiveFile()->path.empty() &&
+        ImGui::GetKeyData (ImGuiKey_Delete)->DownDuration == 0.0f) // Delete - Delete the opened image
+      _DeleteImage ();
+
     // These keybindings requires Ctrl to be held down
     if (ImGui::GetIO().KeyCtrl)
     {
@@ -4072,15 +4011,16 @@ SKIF_UI_Tab_DrawViewer (void)
       if (cover.is_hdr &&
           SKIF_ImGui_MenuItemEx2 ("Export to SDR", ICON_FA_FILE_EXPORT, ImGui::GetStyleColorVec4(ImGuiCol_Text),      "Ctrl+X"))
         ExportSDRDialog = PopupState_Open;
-      if (SKIF_ImGui_MenuItemEx2 ("Encoder Setup", ICON_FA_GEARS,       ImGui::GetStyleColorVec4(ImGuiCol_Text),      "Ctrl+B"))
-        ConfigEncoders = PopupState_Open;
-      if (//cover.is_hdr &&
-          SKIF_ImGui_MenuItemEx2 ("Copy",          ICON_FA_CLIPBOARD,   ImGui::GetStyleColorVec4(ImGuiCol_Text),      "Ctrl+C"))
-      {
+
+      ImGui::Separator ( );
+
+      if (SKIF_ImGui_MenuItemEx2 ("Copy",         ICON_FA_CLIPBOARD,    ImGui::GetStyleColorVec4(ImGuiCol_Text),      "Ctrl+C"))
         wantCopyToClipboard = true;
-      }
-      //if (SKIF_ImGui_MenuItemEx2 ("Close", 0,                           ImGui::GetStyleColorVec4(ImGuiCol_SKIF_Info), "Ctrl+W"))
-      //  _SwapOutCover ();
+      if (SKIF_ImGui_MenuItemEx2 ("Close", 0,                           ImGui::GetStyleColorVec4(ImGuiCol_SKIF_Info), "Ctrl+W"))
+        _SwapOutCover ();
+      if (_current_folder.fileList.getActiveFile() != nullptr && ! _current_folder.fileList.getActiveFile()->path.empty() &&
+          SKIF_ImGui_MenuItemEx2 ("Delete", ICON_FA_TRASH_CAN,          ImGui::GetStyleColorVec4(ImGuiCol_SKIF_Failure), "Delete"))
+        _DeleteImage ();
 
       // Image scaling
 
@@ -4088,7 +4028,7 @@ SKIF_UI_Tab_DrawViewer (void)
 
       ImGui::PushID ("#ImageScaling");
 
-      if (SKIF_ImGui_BeginMenuEx2 ("Scaling", ICON_FA_PANORAMA))
+      if (SKIF_ImGui_BeginMenuEx2 ("Scaling", 0)) // ICON_FA_PANORAMA
       {
         auto _CreateMenuItem = [&](ImageScaling image_scaling, const char* label, const char* shortcut) {
           bool bEnabled = (cover.scaling == image_scaling);
@@ -4169,18 +4109,27 @@ SKIF_UI_Tab_DrawViewer (void)
         ImGui::PopID ( ); // #HDRVisualization
       }
       
-      if (SKIF_ImGui_MenuItemEx2 ("Details", ICON_FA_BARCODE, ImGui::GetStyleColorVec4 (ImGuiCol_Text), "Ctrl+D", &_registry.bImageDetails))
+      if (SKIF_ImGui_MenuItemEx2 ("Details", 0, ImGui::GetStyleColorVec4 (ImGuiCol_Text), "Ctrl+D", &_registry.bImageDetails)) // ICON_FA_BARCODE
         _registry.regKVImageDetails.putData (_registry.bImageDetails);
 
+      if (SKIF_ImGui_MenuItemEx2 ("Encoder Setup", 0,                   ImGui::GetStyleColorVec4(ImGuiCol_Text),      "Ctrl+B")) // ICON_FA_GEARS
+        ConfigEncoders = PopupState_Open;
+
       ImGui::Separator       ( );
 
-      if (! cover.file_info.path.empty() && SKIF_ImGui_MenuItemEx2 ("Browse Folder", ICON_FA_FOLDER_OPEN, ImColor(255, 207, 72), "Ctrl+E"))
-        SKIF_Util_FileExplorer_SelectFile (cover.file_info.path.c_str());
+      if (! cover.file_info.path.empty())
+      {
+        if (SKIF_ImGui_MenuItemEx2 ("Browse Folder", ICON_FA_FOLDER_OPEN, ImColor(255, 207, 72), "Ctrl+E"))
+          SKIF_Util_FileExplorer_SelectFile (cover.file_info.path.c_str());
+
+        if (SKIF_ImGui_MenuItemEx2 ("Context Menu", ICON_FA_WINDOWS,      ImGui::GetStyleColorVec4(ImGuiCol_SKIF_Info)))
+          SKIF_Util_FileExplorer_ContextMenuFile (cover.file_info.path.c_str(), SKIF_Notify_hWnd);
+      }
     }
 
     ImGui::Separator       ( );
 
-    if (SKIF_ImGui_MenuItemEx2 ("Settings", ICON_FA_LIST_CHECK))
+    if (SKIF_ImGui_MenuItemEx2 ("Settings", 0)) // ICON_FA_LIST_CHECK
       SKIF_Tab_ChangeTo = UITab_Settings;
 
     ImGui::Separator ( );
@@ -4559,13 +4508,13 @@ SKIF_UI_Tab_DrawViewer (void)
     if (ImGui::IsKeyPressed (ImGuiKey_RightArrow) ||
         ImGui::IsKeyPressed (ImGuiKey_GamepadR1))
     {
-      dragDroppedFilePath = _current_folder.nextImage ( );
+      dragDroppedFilePath = _current_folder.fileList.nextImage ( );
     }
 
     else if (ImGui::IsKeyPressed (ImGuiKey_LeftArrow) ||
              ImGui::IsKeyPressed (ImGuiKey_GamepadL1))
     {
-      dragDroppedFilePath = _current_folder.prevImage ( );
+      dragDroppedFilePath = _current_folder.fileList.prevImage ( );
     }
   }
 
diff --git a/src/utility/image.cpp b/src/utility/image.cpp
index 088eaac..28ca93b 100644
--- a/src/utility/image.cpp
+++ b/src/utility/image.cpp
@@ -3,6 +3,8 @@
 #include <cstdint>
 #include <string_view>
 #include <filesystem>
+#include <pathcch.h>
+#include <unordered_set>
 #include <plog/Log.h>
 #include <strsafe.h>
 #include <wincodec.h>
@@ -1078,7 +1080,7 @@ SKIV_PNG_CopyToClipboard (const DirectX::Image& image, const void *pData, size_t
   return false;
 }
 
-bool SKIV_Image_CopyToClipboard (const DirectX::Image* pImage, bool isHDR, bool isTemp, const wchar_t* wszFileName)
+bool SKIV_Image_CopyToClipboard (const DirectX::Image* pImage, bool isHDR, SKIV_CaptureData capture_data)
 {
 using namespace DirectX;
 
@@ -1086,38 +1088,103 @@ using namespace DirectX;
     return false;
 
   static SKIF_CommonPathsCache& _path_cache = SKIF_CommonPathsCache::GetInstance ( );
+  static SKIF_RegistrySettings& _registry   = SKIF_RegistrySettings::GetInstance ( );
 
-  std::wstring wsPNGPath  = (isTemp) ? _path_cache.skiv_temp : _path_cache.skiv_screenshots;
-  std::wstring wsFilename = std::wstring (wszFileName);
+  // Retrieve local time first
+  SYSTEMTIME st;
+  GetLocalTime (&st);
+
+  bool isPersistent = (capture_data._mode != CaptureMode_None);
+  std::wstring wsPNGPath  = (isPersistent) ? _path_cache.skiv_screenshots : _path_cache.skiv_temp;
+  std::wstring wsFilename = _registry.wsScreenshotsPattern;
+  size_t pos = std::wstring::npos;
+  static const std::wstring
+    pApp  = L"<app>",
+    pExe  = L"<exe>",
+    pPro  = L"<pro>",
+    pWnd  = L"<win>",
+    pDate = L"<date>",
+    pTime = L"<time>";
+
+  if (! isPersistent)
+    SKIF_Util_Files_PruneToLatestN (_path_cache.skiv_temp, 10);
+
+  // Process path
+
+  // Automatic app name population...
+  pos = wsFilename.find (pApp);
+  if (pos != std::wstring::npos)
+  {
+    if (! capture_data._names.custom.empty())
+      wsFilename.replace (pos, pApp.length(), capture_data._names.custom);
+    else if (! capture_data._names.product.empty())
+      wsFilename.replace (pos, pApp.length(), capture_data._names.product);
+    else if (! capture_data._names.executable.empty())
+      wsFilename.replace (pos, pApp.length(), capture_data._names.executable);
+    else
+      wsFilename.replace (pos, pApp.length(), L"unknown");
+  }
 
-  wsFilename += L"_";
+  // Product name
+  pos = wsFilename.find (pPro);
+  if (pos != std::wstring::npos)
+    wsFilename.replace (pos, pPro.length(), (capture_data._names.product.empty()) ? L"unknown" : capture_data._names.product);
 
-  // DateTime
-  SYSTEMTIME st;
-  GetLocalTime(&st);
+  // Executable name
+  pos = wsFilename.find (pExe);
+  if (pos != std::wstring::npos)
+    wsFilename.replace (pos, pExe.length(), (capture_data._names.executable.empty()) ? L"unknown" : capture_data._names.executable);
 
-  // Buffers for formatted output
-  wchar_t dateBuffer[100];
-  wchar_t timeBuffer[100];
+  // Window title
+  pos = wsFilename.find (pWnd);
+  if (pos != std::wstring::npos)
+    wsFilename.replace (pos, pWnd.length(), (capture_data._names.window.empty()) ? L"unknown" : capture_data._names.window);
 
-  // Get locale-aware date
-  if (GetDateFormatEx (LOCALE_NAME_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, dateBuffer, 100, NULL))
-    wsFilename += std::wstring(dateBuffer);
+  // Locale-aware date
+  pos = wsFilename.find (pDate);
+  if (pos != std::wstring::npos)
+  {
+    wchar_t dateBuffer[100];
+    if (GetDateFormatEx (LOCALE_NAME_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, dateBuffer, 100, NULL))
+      wsFilename.replace (pos, pDate.length(), dateBuffer);
+  }
 
-  wsFilename += L"_";
+  // Locale-aware time
+  pos = wsFilename.find (pTime);
+  if (pos != std::wstring::npos)
+  {
+    wchar_t timeBuffer[100];
+    if (GetTimeFormatEx (LOCALE_NAME_USER_DEFAULT, 0, &st, NULL, timeBuffer, 100))
+      wsFilename.replace (pos, pTime.length(), timeBuffer);
+  }
 
-  // Get locale-aware time
-  if (GetTimeFormatEx (LOCALE_NAME_USER_DEFAULT, 0, &st, NULL, timeBuffer, 100))
-    wsFilename += std::wstring(timeBuffer);
+  // Replace : with .
+  std::replace (wsFilename.begin(), wsFilename.end(), ':', '.');
 
-  wsFilename = SKIF_Util_StripInvalidFilenameChars (wsFilename);
+  // Windows-style folder separators
+  std::replace (wsFilename.begin(), wsFilename.end(), '/', '\\');
 
-  wsPNGPath += wsFilename + L".png";
+  auto _stripInvalidCharacters = [](wchar_t tval) {
+    static const std::unordered_set <wchar_t> invalid_file_char =
+    { L':', L'*',  L'?', L'\"', L'<',  L'>', L'|', };
 
-  PLOG_VERBOSE << wsPNGPath;
+    return (invalid_file_char.find(tval) != invalid_file_char.end());
+  };
+  
+  wsFilename.erase (std::remove_if (wsFilename.begin(), wsFilename.end(), _stripInvalidCharacters), wsFilename.end());
 
-  static SKIF_RegistrySettings& _registry =
-    SKIF_RegistrySettings::GetInstance ( );
+  // Strip trailing spaces from name, these are usually the result of
+  //   deleting one of the non-useable characters above.
+  for (auto it = wsFilename.rbegin (); it != wsFilename.rend (); ++it)
+    if (*it == L' ') *it = L'\0'; else break;
+
+  wsPNGPath += wsFilename + L".png";
+
+  // Create any missing folders...
+  std::error_code       ec;
+  std::filesystem::path p = wsPNGPath;
+  if (! std::filesystem::exists         (p.parent_path(), ec))
+    std::filesystem::create_directories (p.parent_path(), ec);
 
   int snipping_tonemap_mode = _registry._SnippingTonemapsHDR;
 
@@ -1161,6 +1228,9 @@ using namespace DirectX;
     {
       PLOG_VERBOSE << "SKIF_Image_SaveToDisk_HDR ( ): SUCCEEDED";
 
+      if (capture_data._select)
+        SKIF_Util_FileExplorer_SelectFile (wsPNGPath.c_str());
+
       if (SKIV_PNG_CopyToClipboard (*pImage, wsPNGPath.c_str(), 0))
       {
         PLOG_VERBOSE << "SKIV_PNG_CopyToClipboard ( ): TRUE";
@@ -1183,11 +1253,15 @@ using namespace DirectX;
         PLOG_INFO << "SKIV_Image_TonemapToSDR ( ): FAILED!";
     }
 
-    if (_registry.bSaveScreenshots)
+    if (isPersistent)
     {
       if (SUCCEEDED (SKIV_Image_SaveToDisk_SDR (*pImage, wsPNGPath.c_str(), false)))
+      {
         PLOG_VERBOSE << "SKIV_Image_SaveToDisk_SDR ( ): SUCCEEDED!";
-      else
+
+        if (capture_data._select)
+          SKIF_Util_FileExplorer_SelectFile (wsPNGPath.c_str());
+      } else
         PLOG_VERBOSE << "SKIF_Image_SaveToDisk_HDR ( ): FAILED";
     }
 
@@ -1618,7 +1692,7 @@ SKIV_Image_SaveToDisk_SDR (const DirectX::Image& image, const wchar_t* wszFileNa
   // For silly users who don't give us filenames...
   if (! wszExtension)
   {
-    PathAddExtension (wszImplicitFileName, defaultSDRFileExt.c_str ());
+    PathCchAddExtension (wszImplicitFileName, MAX_PATH, defaultSDRFileExt.c_str ());
     wszExtension =
       PathFindExtensionW (wszImplicitFileName);
   }
@@ -2493,7 +2567,7 @@ SKIV_Image_SaveToDisk_HDR (const DirectX::Image& image, const wchar_t* wszFileNa
   // For doofus users who don't give us filenames...
   if (! wszExtension)
   {
-    PathAddExtension (wszImplicitFileName, defaultHDRFileExt.c_str ());
+    PathCchAddExtension (wszImplicitFileName, MAX_PATH, defaultHDRFileExt.c_str ());
     wszExtension =
       PathFindExtensionW (wszImplicitFileName);
   }
@@ -3401,11 +3475,11 @@ SKIV_Image_CaptureDesktop (DirectX::ScratchImage& image, POINT point, int flags)
 }
 
 void
-SKIV_Image_CaptureRegion (SKIV_Region capture_area)
+SKIV_Image_CaptureRegion (SKIV_CaptureData capture_data)
 {
   HMONITOR hMonCaptured =
-    MonitorFromPoint ({ static_cast <long> (capture_area._rect.Min.x),
-                        static_cast <long> (capture_area._rect.Min.y) }, MONITOR_DEFAULTTONEAREST);
+    MonitorFromPoint ({ static_cast <long> (capture_data._rect.Min.x),
+                        static_cast <long> (capture_data._rect.Min.y) }, MONITOR_DEFAULTTONEAREST);
 
   MONITORINFO                    minfo = { .cbSize = sizeof (MONITORINFO) };
   GetMonitorInfo (hMonCaptured, &minfo);
@@ -3413,11 +3487,11 @@ SKIV_Image_CaptureRegion (SKIV_Region capture_area)
   // Fixes snipping rectangles on non-primary (origin != 0,0) displays
   auto _AdjustCaptureAreaRelativeToDisplayOrigin = [&](void)
   {
-    capture_area._rect.Min.x -= minfo.rcMonitor.left;
-    capture_area._rect.Max.x -= minfo.rcMonitor.left;
+    capture_data._rect.Min.x -= minfo.rcMonitor.left;
+    capture_data._rect.Max.x -= minfo.rcMonitor.left;
 
-    capture_area._rect.Min.y -= minfo.rcMonitor.top;
-    capture_area._rect.Max.y -= minfo.rcMonitor.top;
+    capture_data._rect.Min.y -= minfo.rcMonitor.top;
+    capture_data._rect.Max.y -= minfo.rcMonitor.top;
   };
 
   _AdjustCaptureAreaRelativeToDisplayOrigin ();
@@ -3430,34 +3504,34 @@ SKIV_Image_CaptureRegion (SKIV_Region capture_area)
                 width  =
       static_cast <float> (minfo.rcMonitor.bottom - minfo.rcMonitor.top);
 
-    std::swap (capture_area._rect.Min.x, capture_area._rect.Min.y);
-    std::swap (capture_area._rect.Max.x, capture_area._rect.Max.y);
+    std::swap (capture_data._rect.Min.x, capture_data._rect.Min.y);
+    std::swap (capture_data._rect.Max.x, capture_data._rect.Max.y);
 
     const float capture_height =
-      static_cast <float> (capture_area._rect.Max.y - capture_area._rect.Min.y),
+      static_cast <float> (capture_data._rect.Max.y - capture_data._rect.Min.y),
                 capture_width  =
-      static_cast <float> (capture_area._rect.Max.x - capture_area._rect.Min.x);
+      static_cast <float> (capture_data._rect.Max.x - capture_data._rect.Min.x);
 
     if (SKIV_DesktopImage._rotation == DXGI_MODE_ROTATION_ROTATE90)
     {
-      capture_area._rect.Min.y = height - capture_area._rect.Max.y;
-      capture_area._rect.Max.y = height - capture_area._rect.Max.y + capture_height;
+      capture_data._rect.Min.y = height - capture_data._rect.Max.y;
+      capture_data._rect.Max.y = height - capture_data._rect.Max.y + capture_height;
     }
 
     else
     {
       std::ignore = capture_width;
       std::ignore = width;
-      //capture_area.Min.x = width - capture_width;
-      //capture_area.Max.x = width;
+      //capture_data.Min.x = width - capture_width;
+      //capture_data.Max.x = width;
     }
   }
 
   const size_t
-    x      = static_cast <size_t> (std::max (0.0f, capture_area._rect.Min.x)),
-    y      = static_cast <size_t> (std::max (0.0f, capture_area._rect.Min.y)),
-    width  = static_cast <size_t> (std::max (0.0f, capture_area._rect.GetWidth  ())),
-    height = static_cast <size_t> (std::max (0.0f, capture_area._rect.GetHeight ()));
+    x      = static_cast <size_t> (std::max (0.0f, capture_data._rect.Min.x)),
+    y      = static_cast <size_t> (std::max (0.0f, capture_data._rect.Min.y)),
+    width  = static_cast <size_t> (std::max (0.0f, capture_data._rect.GetWidth  ())),
+    height = static_cast <size_t> (std::max (0.0f, capture_data._rect.GetHeight ()));
 
   const DirectX::Rect
     src_rect (x,y, width,height);
@@ -3516,13 +3590,13 @@ SKIV_Image_CaptureRegion (SKIV_Region capture_area)
             PLOG_VERBOSE << "DirectX::FlipRotate        ( ): FAILED";
         }
 
-        if (SKIV_Image_CopyToClipboard (final, SKIV_DesktopImage._hdr_image, false, capture_area._title.c_str()))
+        if (SKIV_Image_CopyToClipboard (final, SKIV_DesktopImage._hdr_image, capture_data))
         {
           PLOG_VERBOSE << "SKIV_Image_CopyToClipboard ( ): SUCCEEDED";
 
           ImGui::InsertNotification (
             {
-              ImGuiToastType::Info,
+              ImGuiToastType::Success,
               3000,
               "Copied image to clipboard", ""
             }
@@ -3957,4 +4031,570 @@ void sk_avif_add_icc_to_image (avifImage* img)
   SK_avifImageSetProfileICC ( img,
             RGB_D65_202_Rel_PeQ,
     sizeof (RGB_D65_202_Rel_PeQ) );
+}
+
+
+// Image Directory
+void
+skiv_image_directory_s::reset (void)
+{
+  PLOG_VERBOSE << "reset _current_folder!";
+
+  folder_path.clear();
+  fileList.clear();
+  watch.reset();
+}
+
+void
+skiv_image_directory_s::fl_s::setImage (const std::wstring& path)
+{
+  if (_list.empty())
+    return;
+
+  _it  = std::find_if (_list.begin(), _list.end(), [&](const fd_s& file) { return file.path == path; });
+  _ptr = _it._Ptr;
+}
+
+std::wstring
+skiv_image_directory_s::fl_s::nextImage (void)
+{
+  if (_list.empty() || _it == _list.end())
+    return L"";
+
+  std::advance (_it,  1);
+  _ptr = _it._Ptr;
+
+  return _it->path;
+}
+
+std::wstring
+skiv_image_directory_s::fl_s::prevImage (void)
+{
+  if (_list.empty() || _it == _list.begin())
+    return L"";
+
+  std::advance (_it, -1);
+  _ptr = _it._Ptr;
+
+  return _it->path;
+}
+
+std::wstring
+skiv_image_directory_s::fl_s::deleteImage (void)
+{
+  if (_list.empty())
+    return L"";
+
+  fileDeleted = true;
+
+  _it = _list.erase (_it);
+
+  // Apparently erase() does not select the new populated end() ? Odd...
+  if (_it->path.empty() && ! _list.empty())
+    prevImage();
+
+  _ptr = _it._Ptr;
+
+  return _it->path;
+}
+
+// Find the position of the image in the current folder
+void
+skiv_image_directory_s::fl_s::updateFileIterator (const std::wstring& path)
+{
+  _it = std::find_if (_list.begin(), _list.end(), [&](const fd_s& file) { return file.path == path; });
+
+  // If the file was removed from File Explorer, reset to first item
+  // TODO: Fix proper file tracking so we can detect removed files and just go to one of the nearby ones
+  if (_it->path.empty() && ! _list.empty())
+    _it = _list.begin();
+
+  _ptr = _it._Ptr;
+}
+
+int
+skiv_image_directory_s::workerThread (bool runThread)
+{
+  struct worker_thread_s {
+    bool                    _changed = false;
+    std::wstring            _path;
+    std::vector<fd_s>       _fileList;
+    std::vector<SORTCOLUMN> _sortColumns;
+    HANDLE        hWorker    = NULL;
+    unsigned int  sWorker    = 0;
+  };
+
+  static worker_thread_s* pthread_data = nullptr;
+  static std::wstring pending;
+
+  // Only run one worker at once
+  if (runThread || ! pending.empty())
+  {
+    // Add new stuff to the pending cache.
+    pending = folder_path;
+
+    if (pthread_data == nullptr)
+    {
+      pthread_data = new worker_thread_s;
+
+      // Swap over the pending path, with copies of our existing data...
+      pthread_data->_path        = pending;
+      pthread_data->_fileList    = fileList.getList();
+      pthread_data->_sortColumns = sortColumns;
+
+      HANDLE hWorkerThread = (HANDLE)
+      _beginthreadex (nullptr, 0x0, [](void* _input) -> unsigned
+      {
+        SKIF_Util_SetThreadDescription (GetCurrentThread (), L"SKIV_FolderWorker");
+
+        // Is this combo really appropriate for this thread?
+        //SKIF_Util_SetThreadPowerThrottling (GetCurrentThread (), 1); // Enable EcoQoS for this thread
+        //SetThreadPriority (GetCurrentThread (), THREAD_MODE_BACKGROUND_BEGIN);
+
+        PLOG_VERBOSE << "SKIV_FolderWorker thread started!";
+      
+        DWORD start = SKIF_Util_timeGetTime1();
+
+        worker_thread_s* _data = static_cast<worker_thread_s*>(_input);
+
+        _data->_changed = updateFolderData (_data->_fileList, _data->_sortColumns, _data->_path);
+
+        PLOG_VERBOSE << "Thread [SKIF_LibraryWorker] took " << (SKIF_Util_timeGetTime1() - start) << " ms to complete!";
+
+        PLOG_VERBOSE << "SKIF_LibraryWorker thread stopped!";
+
+        //SetThreadPriority (GetCurrentThread (), THREAD_MODE_BACKGROUND_END);
+
+        return 0;
+      }, pthread_data, 0x0, nullptr);
+
+      bool threadCreated = (hWorkerThread != NULL);
+
+      if (threadCreated)
+      {
+        pthread_data->hWorker = hWorkerThread;
+        pthread_data->sWorker = 1;
+      }
+      else // Someting went wrong during thread creation, so free up the memory we allocated earlier
+      {
+        delete pthread_data;
+        pthread_data = nullptr;
+      }
+    }
+  }
+
+  // Only check our work if processNewWork is unset
+  if (! runThread && pthread_data != nullptr && pthread_data->sWorker == 1 && WaitForSingleObject (pthread_data->hWorker, 0) == WAIT_OBJECT_0)
+  {
+    int state = 1;
+
+    // Only swap in the data if it is fresh
+    if (pending == pthread_data->_path)
+    {
+      if (pthread_data->_changed)
+      {
+        state       = 2;
+        fileList.setList(pthread_data->_fileList);
+        sortColumns = pthread_data->_sortColumns;
+
+        PLOG_VERBOSE << "Swapped in the new folder data!";
+      }
+
+      pending.clear();
+    }
+
+    CloseHandle (pthread_data->hWorker);
+    pthread_data->hWorker = NULL;
+    pthread_data->sWorker = 2;
+    pthread_data->_path.clear();
+    pthread_data->_fileList.clear();
+
+    delete pthread_data;
+    pthread_data = nullptr;
+
+    return state;
+  }
+
+  return 0;
+}
+
+// Retrieve all files in the folder, and identify our current place among them...
+bool
+skiv_image_directory_s::updateFolderData (std::vector<fd_s>& list, std::vector<SORTCOLUMN>& sortColumns, const std::wstring& path)
+{
+  HANDLE        hFind = INVALID_HANDLE_VALUE;
+  WIN32_FIND_DATA ffd = { };
+  
+  std::vector<fd_s> newList;
+  std::vector<fd_s> oldList = list;
+  list.clear();
+
+  PLOG_DEBUG << "Discovering ... " << (path + LR"(\*.*)");
+
+  DWORD temp_time = SKIF_Util_timeGetTime1();
+
+  // This excludes the . and .. items
+  auto _isValid = [](const wchar_t* str) -> bool
+  { return (! ((str[0] == '.') && ((str[1] == '\0') || (str[1] == '.' && str[2] == '\0')))); };
+
+  hFind =
+    FindFirstFileExW ((path + LR"(\*.*)").c_str(), FindExInfoBasic, &ffd, FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH);
+
+  if (INVALID_HANDLE_VALUE != hFind)
+  {
+    if (_isValid (ffd.cFileName))
+      newList.push_back ({ ffd.cFileName, path + LR"(\)" + ffd.cFileName, ffd });
+
+    while (FindNextFile (hFind, &ffd))
+      if (_isValid (ffd.cFileName))
+        newList.push_back ({ ffd.cFileName, path + LR"(\)" + ffd.cFileName, ffd });
+
+    FindClose (hFind);
+  }
+
+  PLOG_VERBOSE << "Operation [FindFirstFileExW/FindNextFile] took " << (SKIF_Util_timeGetTime1() - temp_time) << " ms.";
+
+  if (! newList.empty())
+  {
+    extern bool isExtensionSupported (const std::wstring extension);
+
+    // Filter out unsupported file formats using their file extension
+    for (auto& file : newList)
+      if (isExtensionSupported (std::filesystem::path(file.filename).extension().wstring()))
+        list.push_back (file);
+  }
+
+  bool  changed = (list.size() != oldList.size());
+  if (! changed)
+  {
+    // Normalize sort order (A-Z)
+    sortByFilename (oldList);
+    sortByFilename (list);
+
+    // Have an item changed?
+    for (int i = 0; i < list.size(); i++)
+    {
+      if (list[i].path != oldList[i].path)
+      {
+        changed = true;
+        break;
+      }
+    }
+  }
+
+  // Update sort order (SortColumns)
+  if (changed)
+  {
+    PLOG_DEBUG << "Found " << list.size() << " supported images in the folder.";
+    updateSortOrder (list, sortColumns, path);
+  }
+
+  return changed;
+}
+
+
+#pragma comment(lib, "Propsys.lib")
+
+#include <propsys.h>
+#include <propkey.h>
+#include <propvarutil.h>
+
+static std::wstring
+PropertyKeyToString (const PROPERTYKEY& key)
+{
+  PWSTR pszName = nullptr;
+
+  if (SUCCEEDED(PSGetNameFromPropertyKey(key, &pszName)))
+  {
+    std::wstring result(pszName);
+    CoTaskMemFree(pszName);
+    return result;
+  }
+
+  return L"(unknown)";
+}
+
+static bool
+GetPropertyValue (const std::wstring&  path,
+                  const PROPERTYKEY&   key,
+                        PROPVARIANT*  pVar)
+{
+  CComPtr<IPropertyStore> spStore;
+
+  HRESULT hr = SHGetPropertyStoreFromParsingName(
+      path.c_str(),
+      NULL,
+      GPS_FASTPROPERTIESONLY, // GPS_FASTPROPERTIESONLY / GPS_DEFAULT
+      IID_PPV_ARGS (&spStore));
+
+  if (FAILED(hr))
+  {
+    _com_error err(hr);
+    PLOG_ERROR << "Failed with path: " << path << ", error: " << SK_WideCharToUTF8(err.ErrorMessage());
+    return false;
+  }
+
+  return SUCCEEDED(spStore->GetValue(key, pVar));
+}
+
+static int
+ComparePropVariants (const PROPVARIANT& a, const PROPVARIANT& b)
+{
+  return PropVariantCompare(a, b);
+}
+
+static bool
+GetFolderSortColumns (std::vector<SORTCOLUMN>& sortColumns, const std::wstring& path)
+{
+  sortColumns.clear();
+
+  CComPtr<IShellWindows> spWindows;
+  if (FAILED (spWindows.CoCreateInstance (CLSID_ShellWindows)))
+    return false;
+
+  long count = 0;
+  spWindows->get_Count (&count);
+
+  struct c_s {
+    HWND                    hWnd = NULL;
+    std::vector<SORTCOLUMN> sortColumns;
+  };
+
+  std::vector<c_s> candidates;
+
+  for (long i = 0; i < count; ++i)
+  {
+    CComVariant vtIndex(i);
+    CComPtr<IDispatch> spDisp;
+
+    if (FAILED (spWindows->Item (vtIndex, &spDisp)) || !spDisp)
+      continue;
+
+    CComPtr<IWebBrowserApp> spBrowser;
+    if (FAILED (spDisp->QueryInterface (IID_PPV_ARGS(&spBrowser))))
+      continue;
+
+    // Get location URL (file:///C:/...)
+    BSTR bstrURL;
+    if (FAILED (spBrowser->get_LocationURL (&bstrURL)))
+      continue;
+
+    std::wstring url(bstrURL, SysStringLen (bstrURL));
+    SysFreeString   (bstrURL);
+
+    // Convert URL → path
+    wchar_t wszPath[MAX_PATH];
+    DWORD size = MAX_PATH;
+    if (FAILED (PathCreateFromUrlW (url.c_str(), wszPath, &size, 0)))
+      continue;
+
+    // Compare with target path
+    if (_wcsicmp (wszPath, path.c_str()) != 0)
+      continue;
+
+    // Found matching Explorer window
+    CComPtr<IServiceProvider> spSP;
+    if (FAILED (spBrowser->QueryInterface (IID_PPV_ARGS(&spSP))))
+      continue;
+
+    CComPtr<IShellBrowser> spShellBrowser;
+    if (FAILED (spSP->QueryService (SID_STopLevelBrowser, IID_PPV_ARGS(&spShellBrowser))))
+      continue;
+
+    CComPtr<IShellView> spView;
+    if (FAILED (spShellBrowser->QueryActiveShellView (&spView)))
+      continue;
+
+    CComPtr<IFolderView2> spFV2;
+    if (FAILED (spView->QueryInterface (IID_PPV_ARGS(&spFV2))))
+      continue;
+
+    // We have a candidate
+    c_s item;
+
+    // Retrieve the window HWND
+    spBrowser->get_HWND ((SHANDLE_PTR*)& item.hWnd);
+
+    // Get sort columns
+    int sortColumnCount = 0;
+    if (SUCCEEDED (spFV2->GetSortColumnCount (&sortColumnCount)))
+    {
+      item.sortColumns = std::vector<SORTCOLUMN> (sortColumnCount);
+
+      if (SUCCEEDED (spFV2->GetSortColumns (item.sortColumns.data(), sortColumnCount)))
+      {
+        for (int col = 0; col < sortColumnCount; ++col)
+        {
+          PROPERTYKEY key         = item.sortColumns[col].propkey;
+          SORTDIRECTION direction = item.sortColumns[col].direction;
+
+          PLOG_VERBOSE << "Column " << col << " [" << PropertyKeyToString(key) << "], direction: " << (direction == SORT_ASCENDING ? "ASC" : "DESC");
+        }
+
+        candidates.push_back (std::move (item));
+      }
+    }
+  }
+
+  if (! candidates.empty())
+  {
+    // Walk downard through the Z-order
+    for (HWND wnd = GetWindow (candidates[0].hWnd, GW_HWNDFIRST); wnd != NULL; wnd = GetNextWindow (wnd, GW_HWNDNEXT))
+    {
+      auto it = std::find_if (candidates.begin(), candidates.end(), [&](const c_s& c) { return c.hWnd == wnd; } );
+
+      if (it == candidates.end())
+        continue;
+
+      sortColumns = it->sortColumns;
+
+      //PLOG_VERBOSE << "Found sort columns!";
+
+      /*
+      for (int col = 0; col < sortColumns.size(); ++col)
+      {
+        PROPERTYKEY key         = sortColumns[col].propkey;
+        SORTDIRECTION direction = sortColumns[col].direction;
+
+        PLOG_VERBOSE << "Column " << col << " [" << PropertyKeyToString(key) << "], direction: " << (direction == SORT_ASCENDING ? "ASC" : "DESC");
+      }
+      */
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void
+skiv_image_directory_s::updateSortOrder (std::vector<fd_s>& list, std::vector<SORTCOLUMN>& sortColumns, const std::wstring& path)
+{
+  if (GetFolderSortColumns  (sortColumns, path))
+       sortByColumns  (list, sortColumns);
+  else sortByFilename (list);
+}
+
+void
+skiv_image_directory_s::sortByFilename (std::vector<fd_s>& list)
+{
+  std::sort (list.begin(),
+             list.end  (), 
+    []( const fd_s& a,
+        const fd_s& b ) -> int
+    {
+      return StrCmpLogicalW (a.filename.c_str(), b.filename.c_str()) < 0;
+    }
+  );
+}
+
+void
+skiv_image_directory_s::sortByColumns (std::vector<fd_s>& list, const std::vector<SORTCOLUMN>& sortColumns)
+{
+  if (sortColumns.empty())
+    return sortByFilename (list);
+
+  struct cf_s
+  {
+    fd_s                     file;
+    std::vector<PROPVARIANT> values;
+  };
+  std::vector<cf_s> cache;
+
+  DWORD temp_time         = SKIF_Util_timeGetTime1();
+  DWORD sum_time_parsing  = 0;
+  DWORD sum_time_getvalue = 0;
+
+  // Cache the properties of all files
+  CComPtr<IBindCtx>            bindCtx;
+  CComPtr<IPropertyStore>      spStore;
+  CComPtr<IFileSystemBindData> spFSBD = new FileSystemBindData();
+
+  HRESULT hr = CreateBindCtx (0, &bindCtx);
+
+  if (FAILED (hr))
+  {
+    _com_error err(hr);
+    PLOG_ERROR << "Operation [CreateBindCtx] failed with error: " << SK_WideCharToUTF8 (err.ErrorMessage());
+    return sortByFilename (list);
+  }
+
+  for (const auto& file : list)
+  {
+    cf_s item;
+    item.file = file;
+    item.values.resize (sortColumns.size());
+
+    DWORD tmp = SKIF_Util_timeGetTime1();
+
+    spFSBD->SetFindData(&file.ffd); // Always returns S_OK claims the docs
+    hr = bindCtx->RegisterObjectParam (STR_FILE_SYS_BIND_DATA, spFSBD);
+
+    if (FAILED (hr))
+    {
+      _com_error err(hr);
+      PLOG_ERROR << "Operation [RegisterObjectParam] failed with error: " << SK_WideCharToUTF8 (err.ErrorMessage());
+    }
+
+    // Using GPS_FASTPROPERTIESONLY speeds up the performance here a lot... but it also means that all sort methods will not be supported.
+    // For example, "System.ItemDate" (sort by Date) will not work and will instead mirror "System.ItemModified" (Date Modified)
+    hr = SHGetPropertyStoreFromParsingName (file.path.c_str(), bindCtx, GPS_FASTPROPERTIESONLY | GPS_BESTEFFORT | GPS_NO_OPLOCK, IID_PPV_ARGS(&spStore));
+    sum_time_parsing += (SKIF_Util_timeGetTime1() - tmp);
+
+    if (FAILED (hr))
+    {
+      _com_error err(hr);
+      PLOG_ERROR << "Failed to retrieve properties for path: " << file.path;
+      PLOG_ERROR << "Error: " << SK_WideCharToUTF8 (err.ErrorMessage());
+      continue;
+    }
+
+    for (size_t i = 0; i < sortColumns.size(); ++i)
+    {
+      PropVariantInit (&item.values[i]);
+      DWORD tmp2 = SKIF_Util_timeGetTime1();
+      spStore->GetValue (sortColumns[i].propkey, &item.values[i]);
+      sum_time_getvalue += (SKIF_Util_timeGetTime1() - tmp2);
+    }
+
+    cache.push_back (std::move(item));
+  }
+
+  PLOG_VERBOSE << "Operation [SHGetPropertyStoreFromParsingName] took " << sum_time_parsing << " ms.";
+  PLOG_VERBOSE << "Operation [IPropertyStore::GetValue] took " << sum_time_getvalue << " ms.";
+
+  temp_time = SKIF_Util_timeGetTime1();
+
+  std::sort (cache.begin(), cache.end(),
+    [&](const cf_s& a, const cf_s& b)
+    {
+      for (size_t i = 0; i < sortColumns.size(); ++i)
+      {
+        int cmp = PropVariantCompare(a.values[i], b.values[i]);
+
+        if (cmp != 0)
+        {
+          if (sortColumns[i].direction == SORT_DESCENDING)
+            cmp = -cmp;
+
+          return cmp < 0;
+        }
+      }
+      return false;
+    }
+  );
+
+  PLOG_VERBOSE << "Operation [SortItems] took " << (SKIF_Util_timeGetTime1() - temp_time) << " ms.";
+
+  list.clear();
+
+  for (auto& item : cache)
+  {
+    list.push_back (item.file);
+
+    for (auto& v : item.values)
+      PropVariantClear (&v);
+  }
+
+  PLOG_VERBOSE << "Operation took ~" << (sum_time_parsing + sum_time_getvalue) << " ms.";
 }
\ No newline at end of file
diff --git a/src/utility/registry.cpp b/src/utility/registry.cpp
index 7059c63..016f751 100644
--- a/src/utility/registry.cpp
+++ b/src/utility/registry.cpp
@@ -238,6 +238,18 @@ SKIF_RegistrySettings::SKIF_RegistrySettings (void)
   if (lsKey != ERROR_SUCCESS)
     hKey = nullptr;
 
+  if (regKVUIPositionX.hasData(&hKey))
+    iUIPositionX           =   regKVUIPositionX            .getData (&hKey);
+  if (regKVUIPositionY.hasData(&hKey))
+    iUIPositionY           =   regKVUIPositionY            .getData (&hKey);
+
+  // Registry keys that don't exist defaults to 0/false, so variables that has those values
+  //   as their default value don't need to be checked before we attempt to read them.
+
+  // Remembered app window size and position
+  iUIWidth                 =   regKVUIWidth                .getData (&hKey);
+  iUIHeight                =   regKVUIHeight               .getData (&hKey);
+
   // UI elements that can be toggled
 
   if (regKVUIBorders.hasData(&hKey))
@@ -369,6 +381,12 @@ SKIF_RegistrySettings::SKIF_RegistrySettings (void)
   if (regKVCheckForUpdates.hasData(&hKey))
     iCheckForUpdates       =   regKVCheckForUpdates        .getData (&hKey);
 
+  if (regKVScreenshotsAutosave.hasData(&hKey))
+    eScreenshotsAutosave   =   regKVScreenshotsAutosave    .getData (&hKey);
+
+  if (regKVScreenshotsHotkeys.hasData(&hKey))
+    eScreenshotsHotkeys    =   regKVScreenshotsHotkeys     .getData (&hKey);
+
   if (regKVIgnoreUpdate.hasData(&hKey))
     wsIgnoreUpdate         =   regKVIgnoreUpdate           .getData (&hKey);
 
@@ -381,6 +399,9 @@ SKIF_RegistrySettings::SKIF_RegistrySettings (void)
   if (regKVPathScreenshots.hasData(&hKey))
     wsPathScreenshots      =   regKVPathScreenshots        .getData (&hKey);
 
+  if (regKVScreenshotsPattern.hasData(&hKey))
+    wsScreenshotsPattern   =   regKVScreenshotsPattern     .getData (&hKey);
+
   if (regKVAutoUpdateVersion.hasData(&hKey))
     wsAutoUpdateVersion    =   regKVAutoUpdateVersion      .getData (&hKey);
 
@@ -400,9 +421,6 @@ SKIF_RegistrySettings::SKIF_RegistrySettings (void)
   if (regKV99thPercentileMaxCLL.hasData(&hKey))
     b99thPercentileMaxCLL  =   regKV99thPercentileMaxCLL   .getData (&hKey);
 
-  if (regKVSaveScreenshots.hasData(&hKey))
-    bSaveScreenshots       =   regKVSaveScreenshots        .getData (&hKey);
-
   // These defaults to false, so no need to check if the registry has another value
   //   since getData ( ) defaults to false for non-existent registry values
   bFirstLaunch             =   regKVFirstLaunch            .getData (&hKey);
@@ -419,13 +437,13 @@ SKIF_RegistrySettings::SKIF_RegistrySettings (void)
   //   then parse the human_readable data through .parse()
 
   if (regKVHotkeyCaptureWindow.hasData(&hKey))
-    kbCaptureWindow.pending.human_readable = regKVHotkeyCaptureWindow.getData (&hKey);
+    kbCaptureWindow.pending.human_readable    = regKVHotkeyCaptureWindow   .getData (&hKey);
 
   if (regKVHotkeyCaptureRegion.hasData(&hKey))
-    kbCaptureRegion.pending.human_readable = regKVHotkeyCaptureRegion.getData (&hKey);
+    kbCaptureRegion.pending.human_readable    = regKVHotkeyCaptureRegion   .getData (&hKey);
 
   if (regKVHotkeyCaptureScreen.hasData(&hKey))
-    kbCaptureScreen.pending.human_readable = regKVHotkeyCaptureScreen.getData (&hKey);
+    kbCaptureScreen.pending.human_readable    = regKVHotkeyCaptureScreen   .getData (&hKey);
 
   if (regKVHotkeyToggleHDRDisplay.hasData(&hKey))
     kbToggleHDRDisplay.pending.human_readable = regKVHotkeyToggleHDRDisplay.getData (&hKey);
diff --git a/src/utility/sk_utility.cpp b/src/utility/sk_utility.cpp
index a6e077b..094cece 100644
--- a/src/utility/sk_utility.cpp
+++ b/src/utility/sk_utility.cpp
@@ -425,6 +425,14 @@ SK_Keybind::parse (void)
   shift = false;
   super = false;
 
+  // Abort if the key is unbound
+  if (human_readable == L"<Not Bound>")
+  {
+    human_readable_utf8 = SK_WideCharToUTF8 (human_readable);
+    masked_code         = 1 << 13; // Forced invalid to apply changes on launch
+    return;
+  }
+
   wchar_t   wszKeyBind [128] = { };
   lstrcatW (wszKeyBind, human_readable.c_str ());
 
@@ -748,14 +756,14 @@ SK_ImGui_KeybindSelect (SK_Keybind* keybind)
   if (! keybind)
     return false;
 
-  ImGui::PushStyleColor (ImGuiCol_Text, ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_TextBase)); //ImVec4 (0.667f, 0.667f, 0.667f, 1.0f));
+  //ImGui::PushStyleColor (ImGuiCol_Text, ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_TextBase)); //ImVec4 (0.667f, 0.667f, 0.667f, 1.0f));
   ImGui::PushItemWidth  (ImGui::GetContentRegionAvail ().x);
 
   bool ret =
     ImGui::Selectable (keybind->human_readable_utf8.c_str(), false);
 
   ImGui::PopItemWidth  ();
-  ImGui::PopStyleColor ();
+  //ImGui::PopStyleColor ();
 
   return ret;
 }
@@ -781,6 +789,8 @@ SK_ImGui_KeybindDialog (SK_KeybindMultiState* keybind)
 
     // Render over all other windows
     //ImGui::SetNextWindowFocus ( );
+
+    g_activeKeybindPopup = true;
   }
 
   if (ImGui::BeginPopupModal (keybind->bind_name, nullptr, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove     | ImGuiWindowFlags_Tooltip | // ImGuiWindowFlags_Tooltip is required to work around a pesky z-order issue on first appearance
@@ -837,13 +847,15 @@ SK_ImGui_KeybindDialog (SK_KeybindMultiState* keybind)
     bool bEscape    =
       ImGui::IsKeyPressed (ImGuiKey_Escape,    false),
          bBackspace =
-      ImGui::IsKeyPressed (ImGuiKey_Backspace, false);
+      ImGui::IsKeyPressed (ImGuiKey_Backspace, false),
+         bDelete =
+      ImGui::IsKeyPressed (ImGuiKey_Delete,    false);
 
     ImGui::Text         ("Keybinding:"); //  %hs, keybind->pending.human_readable_utf8.c_str ()); // (0x%02X), keybind->vKey
     ImGui::SameLine     ( );
     ImGui::TextColored  (ImGui::GetStyleColorVec4 (ImGuiCol_SKIF_TextBase), keybind->pending.human_readable_utf8.c_str ());
     ImGui::Separator    ( );
-    ImGui::TextDisabled ("Press BACKSPACE to clear, or ESC to finish.");
+    ImGui::TextDisabled ("Press BACKSPACE to clear, DELETE to reset to default, or ESC to finish.");
 
     // Update the key binding after printing out the current one, to prevent a one-frame graphics glitch
     if (bBackspace)
@@ -857,6 +869,14 @@ SK_ImGui_KeybindDialog (SK_KeybindMultiState* keybind)
       keybind->pending.update   ( );
     }
 
+    else if (bDelete)
+    {
+      keybind->pending = keybind->default;
+      keybind->pending.parse    ( );
+      keybind->pending.makeMask ( );
+      keybind->pending.update   ( );
+    }
+
     else if (! bEscape && vKey != 256)
     {
       keybind->pending.vKey  = static_cast <SHORT> (vKey);
@@ -870,7 +890,7 @@ SK_ImGui_KeybindDialog (SK_KeybindMultiState* keybind)
     }
 
     // If we are done with the changes, mark it as such
-    if (bEscape || bBackspace)
+    if (bEscape || bBackspace || bDelete)
     {
       keybind->assigning = false;
       ImGui::CloseCurrentPopup ( );
@@ -892,9 +912,16 @@ SK_ImGui_Keybinding (SK_KeybindMultiState* binding)
   if (! binding)
     return false;
 
+  ImGui::PushID              (binding->bind_name);
+
   if (SK_ImGui_KeybindSelect (&binding->saved))
-    ImGui::OpenPopup (         binding->bind_name);
+    ImGui::OpenPopup         (binding->bind_name);
+
+  bool results =
+    SK_ImGui_KeybindDialog   (binding);
+
+  ImGui::PopID               ();
 
-  return SK_ImGui_KeybindDialog (binding);
+  return results;
 }
 ;
\ No newline at end of file
diff --git a/src/utility/utility.cpp b/src/utility/utility.cpp
index d272634..759ffd8 100644
--- a/src/utility/utility.cpp
+++ b/src/utility/utility.cpp
@@ -23,6 +23,9 @@
 #pragma comment(lib, "Userenv.lib")
 #pragma comment(lib, "Gdiplus.lib")
 
+#pragma comment(lib, "RuntimeObject.lib")
+#pragma comment(lib, "mincore.lib")
+
 #include <SKIV.h>
 #include <utility/fsutil.h>
 #include <utility/registry.h>
@@ -30,6 +33,8 @@
 
 UINT CF_HTML = NULL;
 
+bool g_activeKeybindPopup = false;
+
 std::vector<HANDLE> vWatchHandles[UITab_ALL];
 INT64               SKIF_TimeInMilliseconds = 0;
 
@@ -2497,6 +2502,8 @@ SKIF_Util_GetClipboardHDROP (void)
 DirectX::Image
 SKIF_Util_GetClipboardBitmapData (void)
 {
+  static SKIF_CommonPathsCache& _path_cache = SKIF_CommonPathsCache::GetInstance ( );
+
   DirectX::Image img = { };
 
   if (true) // OpenClipboard (SKIF_ImGui_hWnd)
@@ -2560,10 +2567,12 @@ SKIF_Util_GetClipboardBitmapData (void)
             {
               GlobalUnlock (hGlobal);
 
-              if (SUCCEEDED (DirectX::SaveToWICFile (*flipped.GetImage (0,0,0), DirectX::WIC_FLAGS_FORCE_SRGB, GUID_ContainerFormatTiff, L"clipboard.tiff")))
+              std::wstring path = std::wstring(_path_cache.skiv_temp) + L"paste.tiff";
+
+              if (SUCCEEDED (DirectX::SaveToWICFile (*flipped.GetImage (0,0,0), DirectX::WIC_FLAGS_FORCE_SRGB, GUID_ContainerFormatTiff, path.c_str())))
               {
                 extern std::wstring dragDroppedFilePath;
-                dragDroppedFilePath = L"clipboard.tiff";
+                dragDroppedFilePath = path;
                 PLOG_VERBOSE << "Successfully received and saved image data from the clipboard!";
               }
             }
@@ -2678,7 +2687,7 @@ SKIF_Util_FileExplorer_SelectFile (PCWSTR filePath)
         { } // Success
 
         // Use the task allocator to free to returned pidl
-        ILFree (iidlPtr);
+        CoTaskMemFree (iidlPtr);
       }
     }
 
@@ -2700,9 +2709,93 @@ SKIF_Util_FileExplorer_SelectFile (PCWSTR filePath)
     delete data;
 }
 
+bool
+SKIF_Util_FileExplorer_DeleteFile (PCWSTR filePath, bool hideWarning)
+{
+  bool ret = false;
+
+  IShellItem* psi = nullptr;
+  if (SUCCEEDED (SHCreateItemFromParsingName (filePath, nullptr, IID_PPV_ARGS(&psi))))
+  {
+    IFileOperation* pfo = nullptr;
+    if (SUCCEEDED (CoCreateInstance (CLSID_FileOperation, nullptr, CLSCTX_ALL, IID_PPV_ARGS(&pfo))))
+    {
+      // This primarily adheres to Explorer's "Display delete confirmation dialog" setting
+      //   i.e. if that setting is disabled, the confirmation won't appear regardless
+      DWORD flags  =
+        FOF_FILESONLY | FOFX_RECYCLEONDELETE | FOFX_ADDUNDORECORD | ((hideWarning) ? FOF_NOCONFIRMATION : FOF_WANTNUKEWARNING); // FOF_WANTNUKEWARNING only seems to trigger on network shares
+
+      if (SUCCEEDED (pfo->SetOperationFlags (flags)))
+      {
+        if (SUCCEEDED (pfo->DeleteItem (psi, nullptr)))
+        {
+          ret = SUCCEEDED (pfo->PerformOperations());
+        }
+      }
+
+      pfo->Release();
+    }
+
+    psi->Release();
+  }
+
+  return ret;
+}
+
+void
+SKIF_Util_FileExplorer_ContextMenuFile (PCWSTR filePath, HWND hWndOwner)
+{
+  // You should call this function from a background thread.
+  // Failure to do so could cause the UI to stop responding.
+  PIDLIST_ABSOLUTE iidlPtr = nullptr;
+  HRESULT hr = SHParseDisplayName (filePath, NULL, &iidlPtr, 0, nullptr);
+  // Let us take the risk since TrackPopupMenuEx() needs to be called from the UI thread
+
+  if (SUCCEEDED (hr))
+  {
+    CComPtr<IShellFolder> parentFolder;
+    LPCITEMIDLIST child        = nullptr;
+
+    hr = SHBindToParent (iidlPtr, IID_PPV_ARGS(&parentFolder), &child);
+
+    if (SUCCEEDED (hr))
+    {
+      CComPtr<IContextMenu> ctxMenu;
+      hr = parentFolder->GetUIObjectOf (hWndOwner, 1, &child, IID_IContextMenu, nullptr, (void**)&ctxMenu);
+
+      if (SUCCEEDED (hr))
+      {
+        HMENU hMenu = CreatePopupMenu();
+        ctxMenu->QueryContextMenu (hMenu, 0, 1, 0x7FFF, CMF_NORMAL);
+
+        POINT cur = { };
+        GetCursorPos (&cur);
+
+        int cmd = TrackPopupMenuEx (hMenu, TPM_RETURNCMD, cur.x, cur.y, hWndOwner, nullptr);
+
+        if (cmd > 0)
+        {
+          CMINVOKECOMMANDINFOEX
+            info        = { sizeof(info) };
+            info.fMask  = CMIC_MASK_UNICODE;
+            info.hwnd   = hWndOwner;
+            info.lpVerb = MAKEINTRESOURCEA(cmd - 1);
+            info.nShow  = SW_SHOWNORMAL;
+
+          ctxMenu->InvokeCommand ((LPCMINVOKECOMMANDINFO)&info);
+        }
+
+        DestroyMenu (hMenu);
+      }
+    }
+
+    CoTaskMemFree (iidlPtr);
+  }
+}
+
 static int
 CALLBACK
-SKIF_Util_FileExplorer_BrowseFolder_CallbackProc (HWND hWnd,UINT uMsg, LPARAM lParam, LPARAM lpData)
+SKIF_Util_FileExplorer_BrowseForFolder_CallbackProc (HWND hWnd,UINT uMsg, LPARAM lParam, LPARAM lpData)
 {
   UNREFERENCED_PARAMETER (lParam);
 
@@ -2713,38 +2806,177 @@ SKIF_Util_FileExplorer_BrowseFolder_CallbackProc (HWND hWnd,UINT uMsg, LPARAM lP
 }
 
 std::wstring
-SKIF_Util_FileExplorer_BrowseFolder (PCWSTR defaultPath)
+SKIF_Util_FileExplorer_BrowseForFolderXP (PCWSTR defaultPath)
 {
-  TCHAR path[MAX_PATH];
+  TCHAR path[MAX_PATH] = { };
 
   BROWSEINFO
     bi = { };
     bi.lpszTitle  = L"Select a new screenshot folder for SKIV to use:";
     bi.ulFlags    = BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;
-    bi.lpfn       = SKIF_Util_FileExplorer_BrowseFolder_CallbackProc;
+    bi.lpfn       = SKIF_Util_FileExplorer_BrowseForFolder_CallbackProc;
     bi.lParam     = (LPARAM) defaultPath;
 
   LPITEMIDLIST pidl = SHBrowseForFolder ( &bi );
 
   if ( pidl != 0 )
   {
-    // Get the name of the folder and put it in path
     SHGetPathFromIDList ( pidl, path );
+    CoTaskMemFree (pidl);
+  }
 
-    // Free memory used
-    IMalloc * imalloc = 0;
-    if ( SUCCEEDED( SHGetMalloc ( &imalloc )) )
+  return path;
+}
+
+std::wstring
+SKIF_Util_FileExplorer_BrowseForFolder (PCWSTR defaultPath)
+{
+  std::wstring path;
+
+  IFileDialog* pfd = nullptr;
+  if (SUCCEEDED (CoCreateInstance (CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd))))
+  {
+    DWORD dwFlags;
+    pfd->GetOptions(&dwFlags);
+    pfd->SetOptions (dwFlags | FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM);
+
+    // Force the dialogue to open a specific folder
+    IShellItem* psiFolder = nullptr;
+    if (SUCCEEDED (SHCreateItemFromParsingName (defaultPath, nullptr, IID_PPV_ARGS(&psiFolder))))
+      pfd->SetFolder (psiFolder);
+
+    if (SUCCEEDED (pfd->Show (SKIF_ImGui_hWnd)))
     {
-      imalloc->Free ( pidl );
-      imalloc->Release ( );
+      IShellItem* psiResult = nullptr;
+      if (SUCCEEDED (pfd->GetResult (&psiResult)))
+      {
+        PWSTR pszFolderPath = nullptr;
+        if (SUCCEEDED (psiResult->GetDisplayName (SIGDN_FILESYSPATH, &pszFolderPath)))
+        {
+          path = pszFolderPath;
+          CoTaskMemFree (pszFolderPath);
+        }
+        psiResult->Release();
+      }
     }
 
-    return path;
+    if (psiFolder != nullptr)
+      psiFolder->Release();
+
+    pfd->Release();
   }
 
-  return L"";
+  return path;
+}
+
+bool
+SKIF_Util_Files_PruneOlderThan (std::wstring path, ULONGLONG secondsSince)
+{
+  if (path.empty())
+    return false;
+
+  if (! path.ends_with (LR"(\)"))
+    path += LR"(\)";
+
+  // Clear out any temp files older than the threshold
+  auto _isLastModified = [&](FILETIME ftLastWriteTime) -> bool
+  {
+    FILETIME ftSystemTime{}, ftAdjustedFileTime{};
+    SYSTEMTIME systemTime{};
+    GetSystemTime (&systemTime);
+
+    if (SystemTimeToFileTime (&systemTime, &ftSystemTime))
+    {
+      ULARGE_INTEGER uintLastWriteTime{};
+
+      // Copy to ULARGE_INTEGER union to perform 64-bit arithmetic
+      uintLastWriteTime.HighPart        = ftLastWriteTime.dwHighDateTime;
+      uintLastWriteTime.LowPart         = ftLastWriteTime.dwLowDateTime;
+
+      // Perform 64-bit arithmetic to add the required amount of seconds to last modified timestamp
+      uintLastWriteTime.QuadPart        = uintLastWriteTime.QuadPart + ULONGLONG(1 * (secondsSince) * 1.0e+7);
+
+      // Copy the results to an FILETIME struct
+      ftAdjustedFileTime.dwHighDateTime = uintLastWriteTime.HighPart;
+      ftAdjustedFileTime.dwLowDateTime  = uintLastWriteTime.LowPart;
+
+      // Compare with system time, and if system time is later (1), then return true
+      if (CompareFileTime (&ftSystemTime, &ftAdjustedFileTime) == 1)
+        return true;
+    }
+
+    return false;
+  };
+
+  HANDLE hFind        = INVALID_HANDLE_VALUE;
+  WIN32_FIND_DATA ffd = { };
+
+  hFind = 
+    FindFirstFileExW ((path + L"*").c_str(), FindExInfoBasic, &ffd, FindExSearchNameMatch, NULL, NULL);
+
+  if (INVALID_HANDLE_VALUE != hFind)
+  {
+    if (_isLastModified   (ffd.ftLastWriteTime))
+      DeleteFile  ((path + ffd.cFileName).c_str());
+
+    while (FindNextFile (hFind, &ffd))
+      if (_isLastModified   (ffd.ftLastWriteTime))
+        DeleteFile  ((path + ffd.cFileName).c_str());
+
+    FindClose (hFind);
+  } else return false;
+
+  return true;
 }
 
+bool
+SKIF_Util_Files_PruneToLatestN (std::wstring path, int filesToRetain)
+{
+  if (path.empty())
+    return false;
+
+  if (! path.ends_with (LR"(\)"))
+    path += LR"(\)";
+
+  HANDLE hFind        = INVALID_HANDLE_VALUE;
+  WIN32_FIND_DATA ffd = { };
+  std::vector<WIN32_FIND_DATA> files;
+
+  // This excludes the . and .. items
+  auto _isValid = [](const wchar_t* str) -> bool
+  { return (! ((str[0] == '.') && ((str[1] == '\0') || (str[1] == '.' && str[2] == '\0')))); };
+
+  hFind = 
+    FindFirstFileExW ((path + L"*").c_str(), FindExInfoBasic, &ffd, FindExSearchNameMatch, NULL, NULL);
+
+  if (INVALID_HANDLE_VALUE != hFind)
+  {
+    if (_isValid (ffd.cFileName))
+      files.push_back (ffd);
+
+    while (FindNextFile (hFind, &ffd))
+      if (_isValid (ffd.cFileName))
+        files.push_back (ffd);
+
+    FindClose (hFind);
+  } else return false;
+
+  if (files.size() > filesToRetain)
+  {
+    std::sort (files.begin(), files.end(), [](const WIN32_FIND_DATA& a, const WIN32_FIND_DATA& b)
+      { return (CompareFileTime (&a.ftLastWriteTime, &b.ftLastWriteTime) == -1); } // First file time is earlier than second file time.
+    );
+
+    for (int i = 0; i < (files.size() - filesToRetain); i++)
+      DeleteFile ((path + files[i].cFileName).c_str());
+
+    return true;
+  }
+
+  return false;
+}
+
+
 #if NTDDI_VERSION < NTDDI_WIN10_RS5
 // Effective Power Mode (Windows 10 1809+)
 typedef enum EFFECTIVE_POWER_MODE {