Feature: Add disk based thumbnail caching system

src/Files.App/Data/Contracts/IGeneralSettingsService.cs

@@ -316,6 +316,15 @@ public interface IGeneralSettingsService : IBaseSettingsService, INotifyProperty
 		bool ShowFilterHeader { get; set; }
 
 		/// <summary>
+		/// Gets or sets a value indicating whether thumbnail cache should be enabled.
+		/// </summary>
+		bool EnableThumbnailCache { get; set; }
+
+		/// <summary>
+		/// Gets or sets the thumbnail cache size limit in MB.
+		/// </summary>
+		double ThumbnailCacheSizeLimit { get; set; }
+
 		/// Gets or sets a value indicating whether smooth scrolling is enabled.
 		/// </summary>
 		bool EnableSmoothScrolling { get; set; }

src/Files.App/Data/Contracts/IShellChangeNotifyService.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+namespace Files.App.Data.Contracts
+{
+	public interface IShellChangeNotifyService : IDisposable
+	{
+		event Action<string>? ItemUpdated;
+
+		event Action<string>? AttributesChanged;
+
+		void StartMonitoring(string path);
+
+		void StopMonitoring();
+	}
+}

src/Files.App/Data/Contracts/IThumbnailCache.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+namespace Files.App.Data.Contracts
+{
+	/// <summary>
+	/// Stores and retrieves cached thumbnails.
+	/// </summary>
+	public interface IThumbnailCache
+	{
+		/// <summary>
+		/// Retrieves a cached thumbnail.
+		/// </summary>
+		/// <returns>Thumbnail bytes, or null if not cached.</returns>
+		Task<byte[]?> GetAsync(string path, int size, IconOptions options, CancellationToken ct);
+
+		/// <summary>
+		/// Stores a thumbnail in the cache.
+		/// </summary>
+		Task SetAsync(string path, int size, IconOptions options, byte[] thumbnail, CancellationToken ct);
+
+		/// <summary>
+		/// Gets the current cache size in bytes.
+		/// </summary>
+		Task<long> GetSizeAsync();
+
+		/// <summary>
+		/// Reduces cache size to the specified target in bytes.
+		/// </summary>
+		Task EvictToSizeAsync(long targetSizeBytes);
+
+		/// <summary>
+		/// Removes all cached thumbnails.
+		/// </summary>
+		Task ClearAsync();
+
+		/// <summary>
+		/// Retrieves a cached icon from the in-memory icon cache.
+		/// </summary>
+		/// <returns>Icon bytes, or null if not cached.</returns>
+		byte[]? GetIcon(string extension, int size);
+
+		/// <summary>
+		/// Stores an icon in the in-memory icon cache.
+		/// </summary>
+		void SetIcon(string extension, int size, byte[] iconData);
+	}
+}

src/Files.App/Data/Contracts/IThumbnailGenerator.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+namespace Files.App.Data.Contracts
+{
+	/// <summary>
+	/// Generates thumbnails for specific file types.
+	/// </summary>
+	public interface IThumbnailGenerator
+	{
+		/// <summary>
+		/// Gets the file extensions this generator supports.
+		/// </summary>
+		IEnumerable<string> SupportedTypes { get; }
+
+		/// <summary>
+		/// Generates a thumbnail for the specified path.
+		/// </summary>
+		/// <returns>Thumbnail bytes, or null if generation fails.</returns>
+		Task<byte[]?> GenerateAsync(
+			string path,
+			int size,
+			bool isFolder,
+			IconOptions options,
+			CancellationToken ct);
+	}
+}

src/Files.App/Data/Contracts/IThumbnailService.cs

@@ -0,0 +1,53 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+namespace Files.App.Data.Contracts
+{
+	/// <summary>
+	/// Provides thumbnail retrieval and cache management.
+	/// </summary>
+	public interface IThumbnailService
+	{
+		/// <summary>
+		/// Gets a thumbnail for the specified path.
+		/// </summary>
+		/// <returns>Thumbnail bytes, or null if unavailable.</returns>
+		Task<byte[]?> GetThumbnailAsync(
+			string path,
+			int size,
+			bool isFolder,
+			IconOptions options = IconOptions.None,
+			CancellationToken ct = default);
+
+		/// <summary>
+		/// Gets a cached thumbnail without calling the Shell API.
+		/// Returns null if not found in the cache.
+		/// </summary>
+		Task<byte[]?> GetCachedThumbnailAsync(
+			string path,
+			int size,
+			bool isFolder,
+			IconOptions options,
+			CancellationToken ct = default);
+
+		/// <summary>
+		/// Registers a thumbnail generator.
+		/// </summary>
+		void RegisterGenerator(IThumbnailGenerator generator);
+
+		/// <summary>
+		/// Clears all cached thumbnails.
+		/// </summary>
+		Task ClearCacheAsync();
+
+		/// <summary>
+		/// Gets the current cache size in bytes.
+		/// </summary>
+		Task<long> GetCacheSizeAsync();
+
+		/// <summary>
+		/// Reduces cache size to the specified target in bytes.
+		/// </summary>
+		Task EvictCacheAsync(long targetSizeBytes);
+	}
+}

src/Files.App/Helpers/Application/AppLifecycleHelper.cs

@@ -3,6 +3,8 @@
 
 using Files.App.Helpers.Application;
 using Files.App.Services.SizeProvider;
+using Files.App.Services.Thumbnails;
+using Files.App.Services.Thumbnails.Generators;
 using Files.App.Utils.Logger;
 using Files.App.ViewModels.Settings;
 using Microsoft.Extensions.DependencyInjection;
@@ -263,6 +265,10 @@ public static IHost ConfigureHost()
 					.AddSingleton<IStorageArchiveService, StorageArchiveService>()
 					.AddSingleton<IStorageSecurityService, StorageSecurityService>()
 					.AddSingleton<IWindowsCompatibilityService, WindowsCompatibilityService>()
+					.AddSingleton<IShellChangeNotifyService, ShellChangeNotifyService>()
+					.AddSingleton<IThumbnailCache, ThumbnailCache>()
+					.AddSingleton<IThumbnailGenerator, ShellApiThumbnailGenerator>()
+					.AddSingleton<IThumbnailService, ThumbnailService>()
 					// ViewModels
 					.AddSingleton<MainPageViewModel>()
 					.AddSingleton<InfoPaneViewModel>()

src/Files.App/Services/Settings/GeneralSettingsService.cs

@@ -387,13 +387,24 @@ public bool ShowFilterHeader
 			set => Set(value);
 		}
 
-		/// <inheritdoc/>
+		public bool EnableThumbnailCache
+    {
+			get => Get(true);
+			set => Set(value);
+		}
+
 		public bool EnableSmoothScrolling
 		{
 			get => Get(true);
 			set => Set(value);
 		}
 
+		public double ThumbnailCacheSizeLimit
+		{
+			get => Get(512d);
+			set => Set(value);
+		}
+
 		protected override void RaiseOnSettingChangedEvent(object sender, SettingChangedEventArgs e)
 		{
 			base.RaiseOnSettingChangedEvent(sender, e);

src/Files.App/Services/ShellChangeNotifyService.cs

@@ -0,0 +1,171 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+using Microsoft.Extensions.Logging;
+using System.Runtime.InteropServices;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.UI.WindowsAndMessaging;
+
+namespace Files.App.Services
+{
+	public sealed partial class ShellChangeNotifyService : IShellChangeNotifyService
+	{
+		private readonly ILogger _logger = Ioc.Default.GetRequiredService<ILogger<ShellChangeNotifyService>>();
+		private readonly WNDPROC _windowProcedure;
+
+		private HWND _windowHandle;
+		private uint _notifyId;
+		private bool _disposed;
+
+		public event Action<string>? ItemUpdated;
+
+		public event Action<string>? AttributesChanged;
+
+		public ShellChangeNotifyService()
+		{
+			_windowProcedure = WindowProc;
+		}
+
+		public unsafe void StartMonitoring(string path)
+		{
+			StopMonitoring();
+
+			string className = "FilesShellNotify_" + Environment.TickCount64;
+
+			fixed (char* ptr = className)
+			{
+				var pWindProc = Marshal.GetFunctionPointerForDelegate(_windowProcedure);
+				var pfnWndProc = (delegate* unmanaged[Stdcall]<HWND, uint, WPARAM, LPARAM, LRESULT>)pWindProc;
+
+				WNDCLASSEXW param = new()
+				{
+					cbSize = (uint)Marshal.SizeOf(typeof(WNDCLASSEXW)),
+					lpfnWndProc = pfnWndProc,
+					hInstance = PInvoke.GetModuleHandle(default(PCWSTR)),
+					lpszClassName = ptr
+				};
+
+				PInvoke.RegisterClassEx(in param);
+			}
+
+			_windowHandle = PInvoke.CreateWindowEx(
+				WINDOW_EX_STYLE.WS_EX_LEFT,
+				className,
+				string.Empty,
+				WINDOW_STYLE.WS_OVERLAPPED,
+				0, 0, 0, 0,
+				new HWND(-3),
+				null, null, null);
+
+			if (_windowHandle == default)
+				return;
+
+			IntPtr pidl = Win32PInvoke.ILCreateFromPath(path);
+			if (pidl == IntPtr.Zero)
+				return;
+
+			try
+			{
+				var entry = new Win32PInvoke.SHChangeNotifyEntry
+				{
+					pidl = pidl,
+					fRecursive = false
+				};
+
+				_notifyId = Win32PInvoke.SHChangeNotifyRegister(
+					_windowHandle,
+					Win32PInvoke.SHCNRF_SHELLLEVEL | Win32PInvoke.SHCNRF_INTERRUPTLEVEL,
+					Win32PInvoke.SHCNE_UPDATEITEM | Win32PInvoke.SHCNE_ATTRIBUTES,
+					(uint)Win32PInvoke.WM_SHNOTIFY,
+					1,
+					ref entry);
+
+				if (_notifyId != 0)
+					_logger.LogInformation("Shell notify registered for {Path} (ID: {Id})", path, _notifyId);
+				else
+					_logger.LogWarning("Shell notify registration failed for {Path}", path);
+			}
+			finally
+			{
+				Win32PInvoke.ILFree(pidl);
+			}
+		}
+
+		public void StopMonitoring()
+		{
+			if (_notifyId != 0)
+			{
+				Win32PInvoke.SHChangeNotifyDeregister(_notifyId);
+				_notifyId = 0;
+			}
+
+			if (_windowHandle != default)
+			{
+				PInvoke.DestroyWindow(_windowHandle);
+				_windowHandle = default;
+			}
+		}
+
+		private LRESULT WindowProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam)
+		{
+			if (uMsg == (uint)Win32PInvoke.WM_SHNOTIFY)
+				ProcessNotification(wParam, lParam);
+
+			return PInvoke.DefWindowProc(hWnd, uMsg, wParam, lParam);
+		}
+
+		private void ProcessNotification(WPARAM wParam, LPARAM lParam)
+		{
+			uint eventId = (uint)lParam.Value;
+			string path = GetPathFromNotification(wParam);
+
+			if (string.IsNullOrEmpty(path))
+				return;
+
+			if (eventId == Win32PInvoke.SHCNE_UPDATEITEM)
+			{
+				_logger.LogInformation("SHCNE_UPDATEITEM: {Path}", path);
+				ItemUpdated?.Invoke(path);
+			}
+			else if (eventId == Win32PInvoke.SHCNE_ATTRIBUTES)
+			{
+				_logger.LogInformation("SHCNE_ATTRIBUTES: {Path}", path);
+				AttributesChanged?.Invoke(path);
+			}
+		}
+
+		private static string GetPathFromNotification(WPARAM wParam)
+		{
+			if (wParam.Value == 0)
+				return string.Empty;
+
+			var notifyStruct = Marshal.PtrToStructure<Win32PInvoke.SHNOTIFYSTRUCT>((nint)wParam.Value);
+			if (notifyStruct.dwItem1 == IntPtr.Zero)
+				return string.Empty;
+
+			IntPtr buffer = Marshal.AllocHGlobal(Win32PInvoke.MAX_PATH * 2);
+			try
+			{
+				if (Win32PInvoke.SHGetPathFromIDList(notifyStruct.dwItem1, buffer))
+					return Marshal.PtrToStringUni(buffer) ?? string.Empty;
+
+				return string.Empty;
+			}
+			finally
+			{
+				Marshal.FreeHGlobal(buffer);
+			}
+		}
+
+		public void Dispose()
+		{
+			if (_disposed)
+				return;
+
+			_logger.LogInformation("Shell notify service disposed");
+			StopMonitoring();
+			_disposed = true;
+		}
+	}
+}