diff --git a/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs b/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs
new file mode 100644
index 000000000..9e3f0f39b
--- /dev/null
+++ b/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace CollapseLauncher.Extension
+{
+    /// <summary>
+    /// Provides extension methods for <see cref="ObservableCollection{T}"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the collection.</typeparam>
+    internal static class ObservableCollectionExtension<T>
+    {
+        /// <summary>
+        /// Gets the backing list of the specified collection.
+        /// </summary>
+        /// <param name="source">The collection to get the backing list from.</param>
+        /// <returns>A reference to the backing list of the collection.</returns>
+        [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "items")]
+        internal static extern ref IList<T> GetBackedCollectionList(Collection<T> source);
+
+        /// <summary>
+        /// Invokes the OnCountPropertyChanged method on the specified observable collection.
+        /// </summary>
+        /// <param name="source">The observable collection to invoke the method on.</param>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "OnCountPropertyChanged")]
+        internal static extern void OnCountPropertyChanged(ObservableCollection<T> source);
+
+        /// <summary>
+        /// Invokes the OnIndexerPropertyChanged method on the specified observable collection.
+        /// </summary>
+        /// <param name="source">The observable collection to invoke the method on.</param>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "OnIndexerPropertyChanged")]
+        internal static extern void OnIndexerPropertyChanged(ObservableCollection<T> source);
+
+        /// <summary>
+        /// Invokes the OnCollectionChanged method on the specified observable collection.
+        /// </summary>
+        /// <param name="source">The observable collection to invoke the method on.</param>
+        /// <param name="e">The event arguments for the collection changed event.</param>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "OnCollectionChanged")]
+        internal static extern void OnCollectionChanged(ObservableCollection<T> source, NotifyCollectionChangedEventArgs e);
+
+        /// <summary>
+        /// Refreshes all events for the specified observable collection.
+        /// </summary>
+        /// <param name="source">The observable collection to invoke the method on.</param>
+        internal static void RefreshAllEvents(ObservableCollection<T> source)
+        {
+            OnCountPropertyChanged(source);
+            OnIndexerPropertyChanged(source);
+            OnCollectionChanged(source, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+        }
+
+        /// <summary>
+        /// Removes a range of items from the specified observable collection quickly.
+        /// </summary>
+        /// <param name="sourceRange">The list of items to remove from the target collection.</param>
+        /// <param name="target">The observable collection from which the items will be removed.</param>
+        /// <exception cref="InvalidCastException">Thrown when the backing list of the target collection cannot be cast to a List{T}.</exception>
+        /// <remarks>
+        /// This method directly manipulates the backing list of the observable collection to remove the specified items,
+        /// and then fires the necessary property changed and collection changed events to update any bindings.
+        /// </remarks>
+        internal static void RemoveItemsFast(List<T> sourceRange, ObservableCollection<T> target)
+        {
+            // Get the backed list instance of the collection
+            List<T> targetBackedList = GetBackedCollectionList(target) as List<T> ?? throw new InvalidCastException();
+
+            // Get the count and iterate the reference of the T from the source range
+            ReadOnlySpan<T> sourceRangeSpan = CollectionsMarshal.AsSpan(sourceRange);
+            int len = sourceRangeSpan.Length - 1;
+            for (; len >= 0; len--)
+            {
+                // Remove the reference of the item T from the target backed list
+                _ = targetBackedList.Remove(sourceRangeSpan[len]);
+            }
+
+            // Fire the changes event
+            RefreshAllEvents(target);
+        }
+    }
+}
diff --git a/CollapseLauncher/Classes/Extension/UIElementExtensions.UnsafeAccessorExtensions.cs b/CollapseLauncher/Classes/Extension/UIElementExtensions.UnsafeAccessorExtensions.cs
new file mode 100644
index 000000000..55ab1f3dc
--- /dev/null
+++ b/CollapseLauncher/Classes/Extension/UIElementExtensions.UnsafeAccessorExtensions.cs
@@ -0,0 +1,32 @@
+using Microsoft.UI.Input;
+using Microsoft.UI.Xaml;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Runtime.CompilerServices;
+
+#nullable enable
+namespace CollapseLauncher.Extension
+{
+    internal static partial class UIElementExtensions
+    {
+        /// <summary>
+        /// Set the cursor for the element.
+        /// </summary>
+        /// <param name="element">The <seealso cref="UIElement"/> member of an element</param>
+        /// <param name="inputCursor">The cursor you want to set. Use <see cref="InputSystemCursor.Create"/> to choose the cursor you want to set.</param>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_ProtectedCursor")]
+        internal static extern void SetCursor(this UIElement element, InputCursor inputCursor);
+
+        /// <summary>
+        /// Set the cursor for the element.
+        /// </summary>
+        /// <param name="element">The <seealso cref="UIElement"/> member of an element</param>
+        /// <param name="inputCursor">The cursor you want to set. Use <see cref="InputSystemCursor.Create"/> to choose the cursor you want to set.</param>
+        internal static ref T WithCursor<T>(this T element, InputCursor inputCursor) where T : UIElement
+        {
+            element.SetCursor(inputCursor);
+            return ref Unsafe.AsRef(ref element);
+        }
+    }
+}
diff --git a/CollapseLauncher/Classes/Extension/UIElementExtensions.cs b/CollapseLauncher/Classes/Extension/UIElementExtensions.cs
index 3a9e860fe..7727673f7 100644
--- a/CollapseLauncher/Classes/Extension/UIElementExtensions.cs
+++ b/CollapseLauncher/Classes/Extension/UIElementExtensions.cs
@@ -18,6 +18,7 @@
 using Windows.UI;
 using Windows.UI.Text;
 using Hi3Helper.SentryHelper;
+using System.Collections.ObjectModel;
 
 namespace CollapseLauncher.Extension
 {
@@ -28,27 +29,8 @@ internal class NavigationViewItemLocaleTextProperty
         public string LocalePropertyName { get; set; }
     }
 
-    internal static class UIElementExtensions
+    internal static partial class UIElementExtensions
     {
-        /// <summary>
-        /// Set the cursor for the element.
-        /// </summary>
-        /// <param name="element">The <seealso cref="UIElement"/> member of an element</param>
-        /// <param name="inputCursor">The cursor you want to set. Use <see cref="InputSystemCursor.Create"/> to choose the cursor you want to set.</param>
-        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_ProtectedCursor")]
-        internal static extern void SetCursor(this UIElement element, InputCursor inputCursor);
-
-        /// <summary>
-        /// Set the cursor for the element.
-        /// </summary>
-        /// <param name="element">The <seealso cref="UIElement"/> member of an element</param>
-        /// <param name="inputCursor">The cursor you want to set. Use <see cref="InputSystemCursor.Create"/> to choose the cursor you want to set.</param>
-        internal static ref T WithCursor<T>(this T element, InputCursor inputCursor) where T : UIElement
-        {
-            element.SetCursor(inputCursor);
-            return ref Unsafe.AsRef(ref element);
-        }
-
 #nullable enable
         /// <summary>
         /// Set the initial navigation view item's locale binding before getting set with <seealso cref="ApplyNavigationViewItemLocaleTextBindings"/>
diff --git a/CollapseLauncher/Classes/Helper/Loading/LoadingMessageHelper.cs b/CollapseLauncher/Classes/Helper/Loading/LoadingMessageHelper.cs
index 7dd9c2aa0..7f68bceac 100644
--- a/CollapseLauncher/Classes/Helper/Loading/LoadingMessageHelper.cs
+++ b/CollapseLauncher/Classes/Helper/Loading/LoadingMessageHelper.cs
@@ -1,5 +1,6 @@
 using CollapseLauncher.Extension;
 using CollapseLauncher.Helper.Animation;
+using CommunityToolkit.WinUI;
 using CommunityToolkit.WinUI.Animations;
 using Microsoft.UI.Text;
 using Microsoft.UI.Xaml;
@@ -64,28 +65,50 @@ internal static void SetProgressBarState(double maxValue = 100d, bool isProgress
         /// Show the loading frame.
         /// </summary>
         internal static async void ShowLoadingFrame()
+        {
+            if (currentMainWindow.LoadingStatusBackgroundGrid.DispatcherQueue.HasThreadAccess)
+            {
+                await ShowLoadingFrameInner();
+                return;
+            }
+
+            await currentMainWindow.LoadingStatusBackgroundGrid.DispatcherQueue.EnqueueAsync(ShowLoadingFrameInner);
+        }
+
+        private static async Task ShowLoadingFrameInner()
         {
             if (isCurrentlyShow) return;
 
-            isCurrentlyShow = true;
-            currentMainWindow!.LoadingStatusGrid!.Visibility = Visibility.Visible;
+            isCurrentlyShow                                            = true;
+            currentMainWindow!.LoadingStatusGrid!.Visibility           = Visibility.Visible;
             currentMainWindow!.LoadingStatusBackgroundGrid!.Visibility = Visibility.Visible;
 
             TimeSpan duration = TimeSpan.FromSeconds(0.25);
 
             await Task.WhenAll(
-                AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusBackgroundGrid, duration,
-                currentMainWindow.LoadingStatusBackgroundGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 1, 0)),
-                AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusGrid, duration,
-                currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateVector3KeyFrameAnimation("Translation", new Vector3(0,0,currentMainWindow.LoadingStatusGrid.Translation.Z), new Vector3(0, (float)(currentMainWindow.LoadingStatusGrid.ActualHeight + 16), currentMainWindow.LoadingStatusGrid.Translation.Z)),
-                currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 1, 0))
-                );
+                               AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusBackgroundGrid, duration,
+                                                              currentMainWindow.LoadingStatusBackgroundGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 1, 0)),
+                               AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusGrid, duration,
+                                                              currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateVector3KeyFrameAnimation("Translation", new Vector3(0, 0, currentMainWindow.LoadingStatusGrid.Translation.Z), new Vector3(0, (float)(currentMainWindow.LoadingStatusGrid.ActualHeight + 16), currentMainWindow.LoadingStatusGrid.Translation.Z)),
+                                                              currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 1, 0))
+                              );
         }
 
         /// <summary>
         /// Hide the loading frame (also hide the action button).
         /// </summary>
         internal static async void HideLoadingFrame()
+        {
+            if (currentMainWindow.LoadingStatusBackgroundGrid.DispatcherQueue.HasThreadAccess)
+            {
+                await HideLoadingFrameInner();
+                return;
+            }
+
+            await currentMainWindow.LoadingStatusBackgroundGrid.DispatcherQueue.EnqueueAsync(HideLoadingFrameInner);
+        }
+
+        private static async Task HideLoadingFrameInner()
         {
             if (!isCurrentlyShow) return;
 
@@ -93,14 +116,14 @@ internal static async void HideLoadingFrame()
 
             TimeSpan duration = TimeSpan.FromSeconds(0.25);
             await Task.WhenAll(
-                AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusBackgroundGrid, duration,
-                currentMainWindow.LoadingStatusBackgroundGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 0, 1)),
-                AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusGrid, duration,
-                currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateVector3KeyFrameAnimation("Translation", new Vector3(0, (float)(currentMainWindow.LoadingStatusGrid.ActualHeight + 16), currentMainWindow.LoadingStatusGrid.Translation.Z), new Vector3(0,0,currentMainWindow.LoadingStatusGrid.Translation.Z)),
-                currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 0, 1))
-                );
-
-            currentMainWindow.LoadingStatusGrid.Visibility = Visibility.Collapsed;
+                               AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusBackgroundGrid, duration,
+                                                              currentMainWindow.LoadingStatusBackgroundGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 0, 1)),
+                               AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusGrid, duration,
+                                                              currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateVector3KeyFrameAnimation("Translation", new Vector3(0, (float)(currentMainWindow.LoadingStatusGrid.ActualHeight + 16), currentMainWindow.LoadingStatusGrid.Translation.Z), new Vector3(0, 0, currentMainWindow.LoadingStatusGrid.Translation.Z)),
+                                                              currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 0, 1))
+                              );
+
+            currentMainWindow.LoadingStatusGrid.Visibility            = Visibility.Collapsed;
             currentMainWindow.LoadingStatusBackgroundGrid!.Visibility = Visibility.Collapsed;
             HideActionButton();
         }
diff --git a/CollapseLauncher/Classes/Helper/StreamUtility.cs b/CollapseLauncher/Classes/Helper/StreamUtility.cs
index cae294b80..7b932743a 100644
--- a/CollapseLauncher/Classes/Helper/StreamUtility.cs
+++ b/CollapseLauncher/Classes/Helper/StreamUtility.cs
@@ -50,12 +50,14 @@ private static void EnsureFilePathExist([NotNull] string? path)
         */
 
         internal static FileInfo EnsureNoReadOnly(this FileInfo fileInfo)
+            => fileInfo.EnsureNoReadOnly(out _);
+
+        internal static FileInfo EnsureNoReadOnly(this FileInfo fileInfo, out bool isFileExist)
         {
-            if (!fileInfo.Exists)
+            if (!(isFileExist = fileInfo.Exists))
                 return fileInfo;
 
             fileInfo.IsReadOnly = false;
-            fileInfo.Refresh();
 
             return fileInfo;
         }
diff --git a/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs b/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
index 35493cd82..a32aba646 100644
--- a/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
+++ b/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
@@ -101,8 +101,8 @@ internal partial class InstallManagerBase
         public virtual async ValueTask CleanUpGameFiles(bool withDialog = true)
         {
             // Get the unused file info asynchronously
-            List<LocalFileInfo> unusedFileInfo = await GetUnusedFileInfoList(withDialog);
-
+            (List<LocalFileInfo>, long) unusedFileInfo = await GetUnusedFileInfoList(withDialog);
+            
             // Spawn dialog if used
             if (withDialog)
             {
@@ -113,11 +113,13 @@ public virtual async ValueTask CleanUpGameFiles(bool withDialog = true)
                     mainWindow.overlayFrame.Navigate(typeof(FileCleanupPage), null,
                                                      new DrillInNavigationTransitionInfo());
                 }
-
+                
                 if (FileCleanupPage.Current == null)
                     return;
-
-                FileCleanupPage.Current.InjectFileInfoSource(unusedFileInfo);
+                await FileCleanupPage.Current.InjectFileInfoSource(unusedFileInfo.Item1, unusedFileInfo.Item2);
+                
+                LoadingMessageHelper.HideLoadingFrame();
+                
                 FileCleanupPage.Current.MenuExitButton.Click   += ExitFromOverlay;
                 FileCleanupPage.Current.MenuReScanButton.Click += ExitFromOverlay;
                 FileCleanupPage.Current.MenuReScanButton.Click += async (_, _) =>
@@ -130,7 +132,7 @@ public virtual async ValueTask CleanUpGameFiles(bool withDialog = true)
             }
 
             // Delete the file straight forward if dialog is not used
-            foreach (LocalFileInfo fileInfo in unusedFileInfo)
+            foreach (LocalFileInfo fileInfo in unusedFileInfo.Item1)
             {
                 TryDeleteReadOnlyFile(fileInfo.FullPath);
             }
@@ -147,7 +149,7 @@ static void ExitFromOverlay(object? sender, RoutedEventArgs args)
             }
         }
 
-        protected virtual async Task<List<LocalFileInfo>> GetUnusedFileInfoList(bool includeZipCheck)
+        protected virtual async Task<(List<LocalFileInfo>, long)> GetUnusedFileInfoList(bool includeZipCheck)
         {
             LoadingMessageHelper.ShowLoadingFrame();
             try
@@ -170,9 +172,9 @@ protected virtual async Task<List<LocalFileInfo>> GetUnusedFileInfoList(bool inc
                 {
                     // Initialize new proxy-aware HttpClient
                     using HttpClient httpClient = new HttpClientBuilder()
-                        .UseLauncherConfig(_downloadThreadCount + _downloadThreadCountReserved)
-                        .SetAllowedDecompression(DecompressionMethods.None)
-                        .Create();
+                                                 .UseLauncherConfig(_downloadThreadCount + _downloadThreadCountReserved)
+                                                 .SetAllowedDecompression(DecompressionMethods.None)
+                                                 .Create();
 
                     // Initialize and get game state, then get the latest package info
                     LoadingMessageHelper.SetMessage(
@@ -238,9 +240,10 @@ await DownloadOtherAudioPkgVersion(_gameAudioLangListPathStatic,
                                      true);
                     }
                 }
-                
+
                 // Add pre-download zips into the ignored list 
-                RegionResourceVersion? packagePreDownloadList = _gameVersionManager.GetGamePreloadZip()?.FirstOrDefault();
+                RegionResourceVersion? packagePreDownloadList =
+                    _gameVersionManager.GetGamePreloadZip()?.FirstOrDefault();
                 if (packagePreDownloadList != null)
                 {
                     var preDownloadZips = new List<string>();
@@ -253,7 +256,7 @@ await DownloadOtherAudioPkgVersion(_gameAudioLangListPathStatic,
                         preDownloadZips.AddRange(packagePreDownloadList.voice_packs
                                                                        .Select(audioRes =>
                                                                                    new GameInstallPackage(audioRes,
-                                                                                            _gamePath)
+                                                                                       _gamePath)
                                                                                    {
                                                                                        PackageType =
                                                                                            GameInstallPackageType.Audio
@@ -268,17 +271,18 @@ await DownloadOtherAudioPkgVersion(_gameAudioLangListPathStatic,
                         ignoredFiles = ignoredFiles.Concat(preDownloadZips).ToArray();
                     }
                 }
-                
+
                 if (ignoredFiles.Length > 0)
                     LogWriteLine($"[GetUnusedFileInfoList] Final ignored file list:\r\n{string.Join(", ", ignoredFiles)}",
                                  LogType.Scheme, true);
-                
+
                 // Get the list of the local file paths
                 List<LocalFileInfo> localFileInfo = [];
                 await GetRelativeLocalFilePaths(localFileInfo, includeZipCheck, gameStateEnum, _token.Token);
 
                 // Get and filter the unused file from the pkg_versions and ignoredFiles
                 List<LocalFileInfo> unusedFileInfo = [];
+                long unusedFileSize = 0;
                 await Task.Run(() =>
                                    Parallel.ForEach(localFileInfo,
                                                     new ParallelOptions { CancellationToken = _token.Token },
@@ -290,14 +294,19 @@ await Task.Run(() =>
                                                                     ignoredFiles.ToList()))
                                                             return;
 
-                                                        lock (unusedFileInfo) unusedFileInfo.Add(asset);
+                                                        lock (unusedFileInfo)
+                                                        {
+                                                            Interlocked.Add(ref unusedFileSize, asset.FileSize);
+                                                            unusedFileInfo.Add(asset);
+                                                        }
                                                     }));
 
-                return unusedFileInfo;
+                return (unusedFileInfo, unusedFileSize);
             }
-            finally
+            catch (Exception ex)
             {
-                LoadingMessageHelper.HideLoadingFrame();
+                ErrorSender.SendException(ex);
+                return (new List<LocalFileInfo>(), 0);
             }
         }
 
@@ -465,14 +474,15 @@ protected virtual async Task GetRelativeLocalFilePaths(List<LocalFileInfo> local
         {
             await Task.Run(() =>
                            {
-                               int           count     = 0;
-                               long          totalSize = 0;
-                               string        gamePath  = _gamePath;
-                               DirectoryInfo dirInfo   = new DirectoryInfo(gamePath);
+                               int           count          = 0;
+                               long          totalSize      = 0;
+                               string        gamePath       = _gamePath;
+                               DirectoryInfo dirInfo        = new DirectoryInfo(gamePath);
+                               int           updateInterval = 100; // Update UI every 100 files
+                               int           processedCount = 0;
 
                                // Do the do in parallel since it will be a really CPU expensive task due to janky checks here and there.
-                               Parallel.ForEach(dirInfo
-                                                   .EnumerateFiles("*", SearchOption.AllDirectories),
+                               Parallel.ForEach(dirInfo.EnumerateFiles("*", SearchOption.AllDirectories),
                                                 new ParallelOptions { CancellationToken = token },
                                                 (fileInfo, _) =>
                                                 {
@@ -481,23 +491,26 @@ await Task.Run(() =>
 
                                                     // Do the check within the lambda function to possibly check the file
                                                     // condition in multithread
-                                                    if (!IsCategorizedAsGameFile(fileInfo, gamePath, includeZipCheck,
-                                                                 gameState,
-                                                                 out LocalFileInfo localFileInfo))
+                                                    if (!IsCategorizedAsGameFile(fileInfo, gamePath, includeZipCheck, gameState, out LocalFileInfo localFileInfo))
                                                         return;
 
-                                                    Interlocked.Add(ref totalSize,
-                                                                    fileInfo.Exists ? fileInfo.Length : 0);
+                                                    Interlocked.Add(ref totalSize, fileInfo.Exists ? fileInfo.Length : 0);
                                                     Interlocked.Increment(ref count);
-                                                    _parentUI.DispatcherQueue.TryEnqueue(() =>
-                                                                     LoadingMessageHelper.SetMessage(
-                                                                          Locale.Lang._FileCleanupPage.LoadingTitle,
-                                                                          string
-                                                                             .Format(Locale.Lang._FileCleanupPage.LoadingSubtitle1,
-                                                                                       count,
-                                                                                       ConverterTool
-                                                                                          .SummarizeSizeSimple(totalSize))
-                                                                         ));
+                                                    int currentCount = Interlocked.Increment(ref processedCount);
+
+                                                    if (currentCount % updateInterval == 0)
+                                                    {
+                                                        _parentUI.DispatcherQueue.TryEnqueue(() =>
+                                                        {
+                                                            LoadingMessageHelper.SetMessage(
+                                                                 Locale.Lang._FileCleanupPage.LoadingTitle,
+                                                                 string.Format(Locale.Lang._FileCleanupPage.LoadingSubtitle1,
+                                                                               count,
+                                                                               ConverterTool.SummarizeSizeSimple(totalSize))
+                                                                );
+                                                        });
+                                                    }
+
                                                     lock (localFileInfoList)
                                                     {
                                                         localFileInfoList.Add(localFileInfo);
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml
index 4a2fe1c32..42502bc10 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml
@@ -156,7 +156,7 @@
                 </Grid.ColumnDefinitions>
                 <CheckBox x:Name="ToggleCheckAllCheckBox"
                           Checked="ToggleCheckAll"
-                          IsChecked="True"
+                          IsChecked="False"
                           Unchecked="ToggleCheckAll" />
                 <Button x:Name="DeleteSelectedFiles"
                         Grid.Column="0"
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 45c4cb48b..228c8fb96 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -1,9 +1,13 @@
-using CollapseLauncher.CustomControls;
+using CollapseLauncher.CustomControls;
 using CollapseLauncher.Dialogs;
 using CollapseLauncher.Extension;
+using CollapseLauncher.Helper;
+using CollapseLauncher.Helper.Loading;
 using CollapseLauncher.InstallManager.Base;
+using CommunityToolkit.WinUI;
 using Hi3Helper;
 using Hi3Helper.Data;
+using Hi3Helper.SentryHelper;
 using Hi3Helper.Win32.Native.ManagedTools;
 using Microsoft.UI.Text;
 using Microsoft.UI.Xaml;
@@ -12,8 +16,11 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
+using System.Threading;
 using System.Threading.Tasks;
 
 // ReSharper disable CheckNamespace
@@ -25,41 +32,89 @@ namespace CollapseLauncher.Pages
     public sealed partial class FileCleanupPage
     {
         internal static FileCleanupPage?                    Current { get; set; }
-        internal        ObservableCollection<LocalFileInfo> FileInfoSource = [];
+        internal        ObservableCollection<LocalFileInfo> FileInfoSource;
 
     #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
         public FileCleanupPage()
         {
+            FileInfoSource = new ObservableCollection<LocalFileInfo>();
+
             InitializeComponent();
             Current = this;
             Loaded += (_, _) =>
                       {
-                          foreach (LocalFileInfo asset in FileInfoSource)
-                          {
-                              ListViewTable.SelectedItems.Add(asset);
-                          }
-
                           FileInfoSource.CollectionChanged += UpdateUIOnCollectionChange;
                       };
         }
     #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
 
-        private int    _selectedAssetsCount;
-        private long   _assetTotalSize;
-        private string _assetTotalSizeString = string.Empty;
-        private long   _assetSelectedSize;
+        private int  _selectedAssetsCount;
+        private long _assetSelectedSize;
+        private long _assetTotalSize;
 
-        public void InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
+        public async Task InjectFileInfoSource(List<LocalFileInfo> fileInfoList, long assetTotalSize)
         {
+            #if DEBUG
+            var s = new Stopwatch();
+            s.Start();
+            #endif
+            
+            _assetTotalSize = assetTotalSize;
             FileInfoSource.Clear();
-            foreach (LocalFileInfo fileInfo in fileInfoList)
+            List<LocalFileInfo> backedFileInfoSourceList = ObservableCollectionExtension<LocalFileInfo>
+                .GetBackedCollectionList(FileInfoSource) as List<LocalFileInfo> ?? throw new InvalidCastException();
+
+            List<LocalFileInfo> localFileCollection = [..fileInfoList];
+            int batchSize = Math.Clamp(localFileCollection.Count / Environment.ProcessorCount, 50, 5000);
+            
+            IEnumerable<List<LocalFileInfo>> batches = localFileCollection
+                                                      .Select((file, index) => new { File = file, Index = index })
+                                                      .GroupBy(x => x.Index / batchSize)
+                                                      .Select(group => group.Select(x => x.File).ToList());
+            
+            List<Task> tasks = [];
+            Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " +
+                                $"Starting to inject file info source with {localFileCollection.Count} items",
+                                LogType.Scheme);
+
+            int b = 0;
+            await Task.Run(() =>
+                           {
+                               tasks.AddRange(batches.Select(batch => 
+                                 EnqueueOnDispatcherQueueAsync(() =>
+                                        {
+                                            var sI = new Stopwatch();
+                                            s.Start();
+                                            foreach (var fileInfoInner in batch)
+                                            {
+                                                backedFileInfoSourceList.Add(fileInfoInner);
+                                                localFileCollection.Remove(fileInfoInner);
+                                            }
+
+                                            sI.Stop();
+                                            Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " + 
+                                                                $"Finished batch #{b} with {batch.Count} items after {sI.ElapsedMilliseconds} ms", LogType.Scheme);
+                                            Interlocked.Increment(ref b);
+                                        })));
+                           });
+            
+            await Task.WhenAll(tasks);
+
+            while (localFileCollection.Count != 0)
             {
-                FileInfoSource.Add(fileInfo);
-                _assetTotalSize += fileInfo.FileSize;
+                backedFileInfoSourceList.Add(localFileCollection[0]);
+                localFileCollection.RemoveAt(0);
             }
 
-            _assetTotalSizeString = ConverterTool.SummarizeSizeSimple(_assetTotalSize);
-            UpdateUIOnCollectionChange(FileInfoSource, null);
+            ObservableCollectionExtension<LocalFileInfo>.RefreshAllEvents(FileInfoSource);
+
+            await DispatcherQueue.EnqueueAsync(() => UpdateUIOnCollectionChange(FileInfoSource, null));
+            
+            # if DEBUG
+            s.Stop();
+            Logger.LogWriteLine($"InjectFileInfoSource done after {s.ElapsedMilliseconds} ms", LogType.Scheme);
+            #endif
+            await CheckAll();
         }
 
         private void UpdateUIOnCollectionChange(object? sender, NotifyCollectionChangedEventArgs? args)
@@ -80,65 +135,114 @@ private void UpdateUIOnCollectionChange(object? sender, NotifyCollectionChangedE
         }
 
 
-        private void ToggleCheckAll(object sender, RoutedEventArgs e)
+        private async void ToggleCheckAll(object sender, RoutedEventArgs e)
         {
-            if (sender is not CheckBox checkBox)
+            var s = new Stopwatch();
+            if (ListViewTable.Items.Count > 1000)
             {
-                return;
+                LoadingMessageHelper.Initialize();
+                LoadingMessageHelper.ShowLoadingFrame();
+                LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle,
+                                                Locale.Lang._FileCleanupPage.LoadingSubtitle3);
             }
+            
+            await Task.Delay(100);
+            s.Start();
+            bool toCheckCopy = false;
+            if (sender is CheckBox checkBox)
+            {
+                bool toCheck = checkBox.IsChecked ?? false;
+                await ToggleCheckAllInnerAsync(toCheck);
+                toCheckCopy = toCheck;
+            } 
+            s.Stop();
+            LoadingMessageHelper.HideLoadingFrame();
+            Logger.LogWriteLine($"[FileCleanupPage::ToggleCheckAll({toCheckCopy})] Elapsed time: {s.ElapsedMilliseconds} ms", LogType.Scheme);
+        }
 
-            bool toCheck = checkBox.IsChecked ?? false;
-            SelectAllToggle(toCheck);
+        private async Task CheckAll()
+        {
+            await ToggleCheckAllInnerAsync(true);
         }
 
-        private void SelectAllToggle(bool selectAll)
+        private async Task ToggleCheckAllInnerAsync(bool selectAll)
         {
             if (selectAll)
             {
-                foreach (LocalFileInfo asset in FileInfoSource)
-                {
-                    if (ListViewTable.SelectedItems.IndexOf(asset) < 0)
-                    {
-                        ListViewTable.SelectedItems.Add(asset);
-                    }
-                }
+                await EnqueueOnDispatcherQueueAsync(ListViewTable.SelectAllSafe);
             }
             else
             {
-                ListViewTable.SelectedItems.Clear();
+                await EnqueueOnDispatcherQueueAsync(ListViewTable.DeselectAll);
             }
         }
 
-        private void ListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        private async void ListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
         {
-            _selectedAssetsCount -= e.RemovedItems.Count;
-            _assetSelectedSize   -= e.RemovedItems.OfType<LocalFileInfo>().Sum(x => x.FileSize);
-
-            _selectedAssetsCount += e.AddedItems.Count;
-            _assetSelectedSize   += e.AddedItems.OfType<LocalFileInfo>().Sum(x => x.FileSize);
-
-            ToggleCheckAllCheckBox.Content = _selectedAssetsCount > 0
-                ? string.Format(Locale.Lang._FileCleanupPage.BottomCheckboxFilesSelected,
-                                _selectedAssetsCount, ConverterTool.SummarizeSizeSimple(_assetSelectedSize),
-                                _assetTotalSizeString)
-                : Locale.Lang._FileCleanupPage.BottomCheckboxNoFileSelected;
-            DeleteSelectedFilesText.Text =
-                string.Format(Locale.Lang._FileCleanupPage.BottomButtonDeleteSelectedFiles, _selectedAssetsCount);
-            DeleteSelectedFiles.IsEnabled = _selectedAssetsCount > 0;
-
-            if (_selectedAssetsCount != 0 && _selectedAssetsCount != FileInfoSource.Count)
-            {
-                ToggleCheckAllCheckBox.IsChecked = null;
-            }
-            else
+            var removedItems = e.RemovedItems.OfType<LocalFileInfo>().ToList();
+            var addedItems   = e.AddedItems.OfType<LocalFileInfo>().ToList();
+            
+            var removedSizeTask = Task.Run(() => removedItems.Count == 0 ? 0 : removedItems.Count < 512
+                                               ? removedItems.Sum(x => x.FileSize)
+                                               : removedItems.Select(x => x.FileSize).ToArray().Sum());
+
+            var addedSizeTask = Task.Run(() => addedItems.Count == 0 ? 0 : addedItems.Count < 512
+                                             ? addedItems.Sum(x => x.FileSize)
+                                             : addedItems.Select(x => x.FileSize).ToArray().Sum());
+
+            var results     = await Task.WhenAll(removedSizeTask, addedSizeTask);
+            var removedSize = results[0];
+            var addedSize   = results[1];
+
+            _selectedAssetsCount += addedItems.Count - removedItems.Count;
+            _assetSelectedSize   += addedSize - removedSize;
+
+            await EnqueueOnDispatcherQueueAsync(() =>
             {
-                ToggleCheckAllCheckBox.IsChecked = _selectedAssetsCount == FileInfoSource.Count;
-            }
+                if (_selectedAssetsCount > 0)
+                {
+                    ToggleCheckAllCheckBox.Content = string.Format(
+                                                                   Locale.Lang._FileCleanupPage.BottomCheckboxFilesSelected,
+                                                                    _selectedAssetsCount,
+                                                                    ConverterTool.SummarizeSizeSimple(_assetSelectedSize),
+                                                                    ConverterTool.SummarizeSizeSimple(_assetTotalSize));
+                }
+                else
+                {
+                    ToggleCheckAllCheckBox.Content = Locale.Lang._FileCleanupPage.BottomCheckboxNoFileSelected;
+                }
+
+                DeleteSelectedFilesText.Text =
+                    string.Format(Locale.Lang._FileCleanupPage.BottomButtonDeleteSelectedFiles, _selectedAssetsCount);
+                DeleteSelectedFiles.IsEnabled = _selectedAssetsCount > 0;
+
+                ToggleCheckAllCheckBox.IsChecked = _selectedAssetsCount == 0
+                    ? false
+                    : _selectedAssetsCount == FileInfoSource.Count ? true : null;
+            });
+        }
+
+        private Task EnqueueOnDispatcherQueueAsync(Action action)
+        {
+            var tcs = new TaskCompletionSource();
+            DispatcherQueue.TryEnqueue(() =>
+                                       {
+                                           try
+                                           {
+                                               action();
+                                               tcs.SetResult();
+                                           }
+                                           catch (Exception ex)
+                                           {
+                                               tcs.SetException(ex);
+                                           }
+                                       });
+            return tcs.Task;
         }
 
         private async void DeleteAllFiles_Click(object sender, RoutedEventArgs e)
         {
-            IList<LocalFileInfo> fileInfoList = FileInfoSource
+            List<LocalFileInfo> fileInfoList = FileInfoSource
                .ToList();
             long size = fileInfoList.Sum(x => x.FileSize);
             await PerformRemoval(fileInfoList, size);
@@ -146,14 +250,14 @@ private async void DeleteAllFiles_Click(object sender, RoutedEventArgs e)
 
         private async void DeleteSelectedFiles_Click(object sender, RoutedEventArgs e)
         {
-            IList<LocalFileInfo> fileInfoList = ListViewTable.SelectedItems
+            List<LocalFileInfo> fileInfoList = ListViewTable.SelectedItems
                                                              .OfType<LocalFileInfo>()
                                                              .ToList();
             long size = fileInfoList.Sum(x => x.FileSize);
             await PerformRemoval(fileInfoList, size);
         }
 
-        private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, long totalSize)
+        private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long totalSize)
         {
             if (deletionSource == null)
             {
@@ -161,17 +265,18 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
             }
 
             TextBlock textBlockMsg = new TextBlock
-                {
-                    TextAlignment = TextAlignment.Center,
-                    TextWrapping  = TextWrapping.WrapWholeWords
-                }.AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle1, true)
-                 .AddTextBlockLine(string.Format(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle2, deletionSource.Count),
-                                   true, FontWeights.Medium)
-                 .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle3, true)
-                 .AddTextBlockLine(string.Format(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle4, ConverterTool.SummarizeSizeSimple(totalSize)),
-                                   FontWeights.Medium)
-                 .AddTextBlockNewLine()
-                 .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle5);
+            {
+                TextAlignment = TextAlignment.Center,
+                TextWrapping = TextWrapping.WrapWholeWords
+            }
+            .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle1, true)
+            .AddTextBlockLine(string.Format(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle2, deletionSource.Count),
+                              true, FontWeights.Medium)
+            .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle3, true)
+            .AddTextBlockLine(string.Format(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle4, ConverterTool.SummarizeSizeSimple(totalSize)),
+                              FontWeights.Medium)
+            .AddTextBlockNewLine()
+            .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle5);
 
             ContentDialogResult dialogResult = await SimpleDialogs.SpawnDialog(
                                                                                Locale.Lang._FileCleanupPage
@@ -186,7 +291,7 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
                                                                                ContentDialogTheme.Warning);
 
             int deleteSuccess = 0;
-            int deleteFailed  = 0;
+            int deleteFailed = 0;
 
             bool isToRecycleBin = dialogResult == ContentDialogResult.Secondary;
             if (dialogResult == ContentDialogResult.None)
@@ -194,66 +299,131 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
                 return;
             }
 
-            if (isToRecycleBin)
-            {
-                IList<string> toBeDeleted = new List<string>();
+            LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle,
+                                            Locale.Lang._FileCleanupPage.DeleteSubtitle);
+            LoadingMessageHelper.ShowLoadingFrame();
 
-                foreach (LocalFileInfo fileInfo in deletionSource)
+            Stopwatch s = Stopwatch.StartNew();
+            try
+            {
+                List<LocalFileInfo> deletedItems = [];
+                if (isToRecycleBin)
                 {
+                    // Get the list of the file to be deleted and add it to the deletedItems List if it exists
+                    List<string> toBeDeleted = await Task.Run(() => deletionSource
+                                                                   .Select(x =>
+                                                                           {
+                                                                               var localFileInfo = x.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
+                                                                               if (!isFileExist)
+                                                                               {
+                                                                                   return string.Empty;
+                                                                               }
+
+                                                                               deletedItems.Add(x);
+                                                                               return localFileInfo.FullName;
+                                                                           })
+                                                                   .Where(x => !string.IsNullOrEmpty(x))
+                                                                   .ToList()).ConfigureAwait(false);
+
                     try
                     {
-                        FileInfo fileInfoN = fileInfo.ToFileInfo();
-                        if (fileInfoN.Exists)
-                        {
-                            fileInfoN.IsReadOnly = false;
-                            toBeDeleted.Add(fileInfoN.FullName);
-                        }
+
+                        // Execute the deletion process
+                        var recycleBinTask = Task.Run(() => RecycleBin.MoveFileToRecycleBin(toBeDeleted, true));
+                        await recycleBinTask.ConfigureAwait(false);
+
+                        deleteSuccess = toBeDeleted.Count;
                     }
-                    catch (Exception ex)
+                    catch (OperationCanceledException)
                     {
-                        ++deleteFailed;
-                        Logger.LogWriteLine($"Failed to remove read only attribute from this file: {fileInfo.FullPath}\r\n{ex}",
-                                            LogType.Error, true);
+                        Logger.LogWriteLine("[FileCleanupPage::PerformRemoval()] The deletion to Recycle Bin was cancelled!",
+                                            LogType.Warning, true);
+                        deletedItems.Clear();
                     }
                 }
-
-                await Task.Run(() => RecycleBin.MoveFileToRecycleBin(toBeDeleted));
-                DispatcherQueue.TryEnqueue(() =>
-                                           {
-                                               for (int i = FileInfoSource.Count - 1; i >= 0; i--)
-                                               {
-                                                   if (toBeDeleted.Contains(FileInfoSource[i].ToFileInfo().FullName))
-                                                   {
-                                                       FileInfoSource.RemoveAt(i);
-                                                   }
-                                               }
-                                           });
-                
-                deleteSuccess = toBeDeleted.Count;
-            }
-            else
-            {
-                foreach (LocalFileInfo fileInfo in deletionSource)
+                else
                 {
-                    try
+                    var threadCount = Environment.ProcessorCount * 4;
+                    ThreadPool.GetMinThreads(out var workerThreads, out var completionPortThreads);
+                    ThreadPool.SetMinThreads(Math.Max(workerThreads, threadCount),
+                                             Math.Max(completionPortThreads, threadCount));
+
+                    var options = new ParallelOptions { MaxDegreeOfParallelism = threadCount };
+                    Task deleteListTask = Task.Factory.StartNew(
+                        () => deletedItems.AddRange(CollectionsMarshal.AsSpan(deletionSource)),
+                        CancellationToken.None,
+                        TaskCreationOptions.DenyChildAttach,
+                        TaskScheduler.Default);
+
+                    List<LocalFileInfo> failedList = [];
+                    Lock failedListLock = new Lock();
+
+                    Task deleteFileTask = Parallel.ForEachAsync(deletionSource, options, async (fileInfoState, _) =>
+                    await Task.Factory.StartNew(state =>
                     {
-                        FileInfo fileInfoN = fileInfo.ToFileInfo();
-                        if (fileInfoN.Exists)
+                        LocalFileInfo fileInfo = (LocalFileInfo)state!;
+                        try
+                        {
+                            FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
+                            if (isFileExist)
+                            {
+                                fileInfoN.Delete();
+                            }
+
+                            Interlocked.Increment(ref deleteSuccess);
+                        }
+                        catch (Exception ex)
                         {
-                            fileInfoN.IsReadOnly = false;
-                            fileInfoN.Delete();
+                            Interlocked.Increment(ref deleteFailed);
+                            lock (failedListLock)
+                            {
+                                failedList.Add(fileInfo);
+                            }
+                            Logger.LogWriteLine($"[FileCleanupPage::PerformRemoval()] Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
+                                LogType.Error, true);
                         }
+                    },
+                    fileInfoState,
+                    CancellationToken.None,
+                    TaskCreationOptions.DenyChildAttach,
+                    TaskScheduler.Default));
 
-                        FileInfoSource.Remove(fileInfo);
-                        ++deleteSuccess;
-                    }
-                    catch (Exception ex)
+                    await Task.WhenAll(deleteListTask, deleteFileTask);
+
+                    if (failedList.Count > 0)
                     {
-                        ++deleteFailed;
-                        Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
-                                            LogType.Error, true);
+                        foreach (LocalFileInfo failedFileInfo in failedList)
+                        {
+                            deletedItems.Remove(failedFileInfo);
+                        }
                     }
+
+                    long totalDeleted = deletedItems.Select(x => x.FileSize).ToArray().Sum();
+                    _assetTotalSize -= totalDeleted;
+
+                    Logger.LogWriteLine($"[FileCleanupPage::PerformRemoval()] Inner deletion task was completed in: {s.ElapsedMilliseconds} ms", LogType.Scheme);
+
+                    ThreadPool.SetMinThreads(workerThreads, completionPortThreads);
                 }
+
+                // Execute the deleted items removal from the source collection with our own method (which is ridiculously faster).
+                // For god sake, MSFT. We hope a better to delete all these items in one go.
+                // The current implementation is reaaaaallllyyyy slooowwwwwww.
+                await EnqueueOnDispatcherQueueAsync(() =>
+                    ObservableCollectionExtension<LocalFileInfo>
+                        .RemoveItemsFast(deletedItems, FileInfoSource));
+            }
+            catch (Exception ex)
+            {
+                await SentryHelper.ExceptionHandlerAsync(ex);
+                Logger.LogWriteLine($"Failed while deleting to Recycle Bin: {ex}",
+                                    LogType.Error, true);
+            }
+            finally
+            {
+                LoadingMessageHelper.HideLoadingFrame();
+                s.Stop();
+                Logger.LogWriteLine($"[FileCleanupPage::PerformRemoval()] The entire deletion task was completed in: {s.ElapsedMilliseconds} ms", LogType.Scheme);
             }
 
             string diagTitle = dialogResult == ContentDialogResult.Primary
diff --git a/CollapseLauncher/packages.lock.json b/CollapseLauncher/packages.lock.json
index 44ca5c500..cf444c780 100644
--- a/CollapseLauncher/packages.lock.json
+++ b/CollapseLauncher/packages.lock.json
@@ -105,6 +105,12 @@
         "resolved": "0.38.0",
         "contentHash": "zfi6kNm5QJnsCGm5a0hMG2qw8juYbOfsS4c1OuTcqkbYQUCdkam6d6Nt7nPIrbV4D+U7sHChidSQlg+ViiMPuw=="
       },
+      "Microsoft.DotNet.ILCompiler": {
+        "type": "Direct",
+        "requested": "[9.0.0, )",
+        "resolved": "9.0.0",
+        "contentHash": "bbnlV2PbUmCQ8Ndpx0kJaicLyV28IU+4IzyctQLL57+DxrHurYr2qsJrC8+yD44Q0DyPfv2oM168c1Tk6Bxbmg=="
+      },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Direct",
         "requested": "[9.0.0, )",
@@ -516,6 +522,15 @@
         "resolved": "0.5.0",
         "contentHash": "5Tw6O9sBDAN1aV+kpOSVvqvFk6Ahk6bYz0TTx3808Dp40M45gKTtzTzI9SS1VeAkljE6BAOeKaykpPnG36oOgw=="
       },
+      "Microsoft.DotNet.ILCompiler": {
+        "type": "Direct",
+        "requested": "[9.0.0, )",
+        "resolved": "9.0.0",
+        "contentHash": "bbnlV2PbUmCQ8Ndpx0kJaicLyV28IU+4IzyctQLL57+DxrHurYr2qsJrC8+yD44Q0DyPfv2oM168c1Tk6Bxbmg==",
+        "dependencies": {
+          "runtime.win-x64.Microsoft.DotNet.ILCompiler": "9.0.0"
+        }
+      },
       "Microsoft.Graphics.Win2D": {
         "type": "Direct",
         "requested": "[1.3.0, )",
diff --git a/Hi3Helper.Core/Lang/Locale/LangFileCleanupPage.cs b/Hi3Helper.Core/Lang/Locale/LangFileCleanupPage.cs
index ee12fa153..90c334891 100644
--- a/Hi3Helper.Core/Lang/Locale/LangFileCleanupPage.cs
+++ b/Hi3Helper.Core/Lang/Locale/LangFileCleanupPage.cs
@@ -20,6 +20,8 @@ public sealed partial class LangFileCleanupPage
                 public string LoadingTitle { get; set; } = LangFallback?._FileCleanupPage.LoadingTitle;
                 public string LoadingSubtitle1 { get; set; } = LangFallback?._FileCleanupPage.LoadingSubtitle1;
                 public string LoadingSubtitle2 { get; set; } = LangFallback?._FileCleanupPage.LoadingSubtitle2;
+                public string LoadingSubtitle3 { get; set; } = LangFallback?._FileCleanupPage.LoadingSubtitle3;
+                public string DeleteSubtitle { get; set; } = LangFallback?._FileCleanupPage.DeleteSubtitle;
                 public string BottomButtonDeleteAllFiles { get; set; } = LangFallback?._FileCleanupPage.BottomButtonDeleteAllFiles;
                 public string BottomButtonDeleteSelectedFiles { get; set; } = LangFallback?._FileCleanupPage.BottomButtonDeleteSelectedFiles;
                 public string BottomCheckboxFilesSelected { get; set; } = LangFallback?._FileCleanupPage.BottomCheckboxFilesSelected;
diff --git a/Hi3Helper.Core/Lang/en_US.json b/Hi3Helper.Core/Lang/en_US.json
index f74b48ef7..831ee178a 100644
--- a/Hi3Helper.Core/Lang/en_US.json
+++ b/Hi3Helper.Core/Lang/en_US.json
@@ -1451,6 +1451,8 @@
     "LoadingTitle": "Processing",
     "LoadingSubtitle1": "Calculating Existing Files ({0} file(s) found - {1} in total)...",
     "LoadingSubtitle2": "Checking pkg_version's availability...",
+    "LoadingSubtitle3": "UI might be unresponsive during this process...",
+    "DeleteSubtitle": "Deleting files...",
     "BottomButtonDeleteAllFiles": "Delete All Files",
     "BottomButtonDeleteSelectedFiles": "Delete {0} Selected File(s)",
     "BottomCheckboxFilesSelected": "{0} File(s) Selected ({1} / {2} Total)",
diff --git a/Hi3Helper.EncTool b/Hi3Helper.EncTool
index 2205c3a9a..169d2af77 160000
--- a/Hi3Helper.EncTool
+++ b/Hi3Helper.EncTool
@@ -1 +1 @@
-Subproject commit 2205c3a9a4ca60c4256b3de80fbcd086fbaa9779
+Subproject commit 169d2af77d420595f37818f73f2c981b8975d83e
diff --git a/Hi3Helper.Win32 b/Hi3Helper.Win32
index 03bb7e91a..1131f8c12 160000
--- a/Hi3Helper.Win32
+++ b/Hi3Helper.Win32
@@ -1 +1 @@
-Subproject commit 03bb7e91ad91303e06a3141b82faaa7d44517dc9
+Subproject commit 1131f8c124637847fe0e35eddfd3cbc5b4974e31