Release v0.8.1: UX polish + WizTree-speed disk analyzer

Startup overlay:
- Replace the indeterminate spinner with a live percentage readout
  (42pt) and a determinate progress bar bound to a shared step counter.
- Each of the 11 parallel scanners ticks the overall progress as it
  finishes, so the user sees real movement instead of a spinning ring.

Disk Analyzer:
- New FastDiskAnalyzer uses WizTree's technique: open the volume with
  CreateFile(\.\C:, FILE_READ_DATA | FILE_READ_ATTRIBUTES), enumerate
  every file via FSCTL_ENUM_USN_DATA in one sequential pass, then pull
  sizes in a single FSCTL_GET_NTFS_FILE_RECORD pass that parses the
  \$STANDARD_INFORMATION + \$DATA attributes inline.
- Reconstructs absolute paths by walking the ParentFRN chain up to the
  NTFS root FRN (0x5).
- Non-NTFS and permission-failure fallback: parallel FindFirstFileExW
  with FIND_FIRST_EX_LARGE_FETCH and FindExInfoBasic. Still materially
  faster than Directory.EnumerateFiles because the large-fetch flag
  streams more entries per syscall and we skip the 8.3 short-name lookup.
- Scan time appears in the status bar.

Registry Hunter:
- Parallel fan-out across HKLM, HKLM\WOW6432Node, HKCU, and HKCR on
  independent worker tasks with a ConcurrentBag sink.
- Scope filter (Keys / Value names / Value data) — lifted from NirSoft
  RegScanner — so a CLSID hunt doesn't get drowned in install-path data
  matches and vice versa.
- Optional compiled regex pattern (RegexOptions.Compiled | IgnoreCase
  with 1s match timeout). Falls back to substring if the pattern won't
  compile.
- Live hit counter streams to the UI every 32 matches.
- Struct-based matcher avoids per-call delegate-invocation overhead in
  the hot recursion path.

Uninstall flow:
- Successful single-program uninstalls now remove the row from the
  Programs list immediately instead of leaving stale entries. A full
  registry rescan remains behind the Refresh button for cases where an
  uninstaller lies.

Version:
- 0.8.0 -> 0.8.1 synced across csproj x2, manifest, README, XAML,
  BUILD.bat, Build.ps1, CHANGELOG.

Author: SysAdminDoc

BUILD.bat

@@ -1,5 +1,5 @@
 @echo off
-title DeepPurge Builder v0.8.0
+title DeepPurge Builder v0.8.1
 echo.
 echo   ============================================
 echo     DeepPurge Builder

Build.ps1

@@ -1,6 +1,6 @@
 <#
 .SYNOPSIS
-    DeepPurge Build Script v0.8.0
+    DeepPurge Build Script v0.8.1
     Compiles the project into a single portable .exe
 
 .DESCRIPTION
@@ -29,7 +29,7 @@ $AppProject = Join-Path $ProjectRoot "src\DeepPurge.App\DeepPurge.App.csproj"
 
 Write-Host ""
 Write-Host "  ============================================" -ForegroundColor Cyan
-Write-Host "    DeepPurge Build Script v0.8.0" -ForegroundColor Cyan
+Write-Host "    DeepPurge Build Script v0.8.1" -ForegroundColor Cyan
 Write-Host "  ============================================" -ForegroundColor Cyan
 Write-Host ""
 

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to DeepPurge will be documented in this file.
 
+## [v0.8.1] — UX polish + WizTree-speed disk analyzer
+
+### Added
+- **Startup shows a real percentage** — the spinning circle on the loading screen is replaced by a big live "N%" readout plus a determinate progress bar. Each of the 11 scan phases ticks the bar as it finishes so the user can see what's happening instead of just a looping animation.
+- **Disk Analyzer now uses WizTree's MFT technique** — new `FastDiskAnalyzer` reads the raw NTFS `$MFT` via `FSCTL_ENUM_USN_DATA` in one sequential sweep, then pulls sizes in a single `FSCTL_GET_NTFS_FILE_RECORD` pass. One warm volume handle replaces millions of random-seek `FindFirstFile` calls. Non-NTFS volumes fall back to a parallel `FindFirstFileExW` walk with the `FIND_FIRST_EX_LARGE_FETCH` hint and `FindExInfoBasic` (skips the 8.3 short-name lookup) — still materially faster than `Directory.EnumerateFiles`. Scan time appears in the status bar.
+- **Registry Hunter rewritten along NirSoft RegScanner / Eric Zimmerman lines** — now scans HKLM, HKLM\\WOW6432Node, HKCU, and HKCR in parallel; adds a scope filter (Keys / Value names / Value data); adds optional compiled regex for pattern matching; streams a live hit counter to the UI every 32 matches. Same hit / depth / time caps as before so unbounded searches can't melt the process.
+
+### Fixed
+- **Uninstalled programs now disappear from the list immediately** after a successful uninstall. No need to hit Refresh to see the row go away; the underlying engine still honours the registry on rescan so broken-uninstaller cases don't pretend to succeed.
+
 ## [v0.8.0] — Competitive feature pass
 
 Research-driven feature pass inspired by BCUninstaller, Revo Uninstaller, BleachBit, PrivaZer, and Sysinternals Autoruns.

README.md

@@ -8,9 +8,9 @@
 </p>
 <!-- codex-branding:end -->
 
-# DeepPurge v0.8.0
+# DeepPurge v0.8.1
 
-![Version](https://img.shields.io/badge/version-v0.8.0-blue) ![License](https://img.shields.io/badge/license-MIT-green) ![Platform](https://img.shields.io/badge/platform-Windows%2010%2F11-lightgrey)
+![Version](https://img.shields.io/badge/version-v0.8.1-blue) ![License](https://img.shields.io/badge/license-MIT-green) ![Platform](https://img.shields.io/badge/platform-Windows%2010%2F11-lightgrey)
 
 A thorough, open-source Windows uninstaller that goes deep. Removes programs completely, hunts down every leftover, and cleans system cruft that other tools miss.
 
@@ -31,7 +31,7 @@ A thorough, open-source Windows uninstaller that goes deep. Removes programs com
 - **Junk Cleaner** - Browser caches, temp files, crash dumps, prefetch, installer cache, Windows Update leftovers
 - **Evidence Remover** - Recent documents, jump lists, thumbnail cache, clipboard, DNS cache, Explorer history, Windows logs, crash reports, error reports, font cache, delivery optimization cache
 - **Empty Folders** - Scan common locations for empty directory trees and remove them
-- **Disk Analyzer** - Folder size breakdown and large file finder (50MB+) with delete capability
+- **Disk Analyzer** - Folder size breakdown and large file finder (50MB+) with delete capability. Uses WizTree's raw-MFT technique (`FSCTL_ENUM_USN_DATA` + `FSCTL_GET_NTFS_FILE_RECORD`) on NTFS volumes; parallel `FindFirstFileExW(FIND_FIRST_EX_LARGE_FETCH)` fallback on ReFS/FAT32. Typical full-drive scan in seconds.
 - **Dry-run / Preview mode** - Every destructive pipeline can be previewed: enumerate and size items without touching them *(inspired by BleachBit)*
 - **Secure Delete** - Privacy-grade wipe (single-pass cryptographic random + opaque rename + delete — multi-pass DoD wipes are obsolete on SSDs and deliberately omitted) *(inspired by BleachBit/PrivaZer)*
 - **Live progress bars** - Every long-running delete reports item / total / bytes-freed / current path in the status bar
@@ -43,7 +43,7 @@ A thorough, open-source Windows uninstaller that goes deep. Removes programs com
 - **Context Menu Cleaner** - Find and remove orphaned shell context menu entries with broken executables or CLSIDs
 - **Services Manager** - View all Windows services, identify orphaned services pointing to deleted executables, disable or delete
 - **Scheduled Tasks** - Full task inventory with orphan detection, disable and delete capabilities
-- **Registry Hunter** - Arbitrary-substring search across HKLM / HKCU / HKCR with depth, hit, and time caps *(inspired by Revo's trace scanner)*
+- **Registry Hunter** - Parallel substring or regex search across HKLM, HKLM\\WOW6432Node, HKCU, and HKCR with scope filters (keys / names / data), live hit counter, and depth / hit / time caps *(inspired by NirSoft RegScanner and Eric Zimmerman's Registry Explorer)*
 
 ### Safety
 - **System Restore Points** - View, create, and manage restore points

src/DeepPurge.App/App.xaml.cs

@@ -7,7 +7,7 @@ namespace DeepPurge.App;
 
 public partial class App : Application
 {
-    private const string Version = "0.8.0";
+    private const string Version = "0.8.1";
     private static readonly string CrashLogDir = Path.Combine(
         Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
         "DeepPurge", "Logs");

src/DeepPurge.App/DeepPurge.App.csproj

@@ -8,7 +8,7 @@
     <Nullable>enable</Nullable>
     <RootNamespace>DeepPurge.App</RootNamespace>
     <AssemblyName>DeepPurge</AssemblyName>
-    <Version>0.8.0</Version>
+    <Version>0.8.1</Version>
     <Authors>SysAdminDoc</Authors>
     <Description>DeepPurge - Open source program uninstaller for Windows</Description>
     <ApplicationIcon>..\..\icon.ico</ApplicationIcon>

src/DeepPurge.App/ViewModels/MainViewModel.cs

@@ -136,6 +136,22 @@ public async Task RunInitialScanAsync()
 
         IsInitialScanRunning = true;
         ScanOverlayText = "DeepPurge is analyzing your system...";
+        OverlayScanProgress = 0;
+
+        // 11 phases: programs + 10 parallel scanners. Each tick moves the
+        // overlay progress a fixed fraction so the user sees real movement
+        // instead of a perpetually-spinning circle.
+        const int totalSteps = 11;
+        int completedSteps = 0;
+        void Tick(string? stepLabel = null)
+        {
+            var done = Interlocked.Increment(ref completedSteps);
+            _dispatcher.BeginInvoke(() =>
+            {
+                OverlayScanProgress = 100.0 * done / totalSteps;
+                if (!string.IsNullOrEmpty(stepLabel)) ScanOverlayText = stepLabel;
+            });
+        }
 
         try
         {
@@ -153,17 +169,19 @@ public async Task RunInitialScanAsync()
                 ProgramsScanProgress = 100;
                 _loadedPanels.Add("Programs");
             });
+            Tick($"Loaded {programs.Count} programs — scanning the rest...");
 
             StartIconBackfill(programs);
             StartPackageEnrichment(programs);
 
-            ScanOverlayText = "Scanning junk, tasks, autorun, extensions...";
-
+            // Each parallel task calls Tick() on completion so the progress
+            // bar advances as individual scanners finish, not just at the end.
             var junkTask = Task.Run(() =>
             {
                 _dispatcher.BeginInvoke(() => JunkScanProgress = 10);
                 var result = JunkFilesCleaner.ScanForJunk();
                 _dispatcher.BeginInvoke(() => JunkScanProgress = 100);
+                Tick("Junk categories discovered...");
                 return result;
             }, ct);
 
@@ -172,17 +190,18 @@ public async Task RunInitialScanAsync()
                 _dispatcher.BeginInvoke(() => TasksScanProgress = 10);
                 var result = ScheduledTaskScanner.GetAllTasks();
                 _dispatcher.BeginInvoke(() => TasksScanProgress = 100);
+                Tick("Scheduled tasks enumerated...");
                 return result;
             }, ct);
 
-            var autorunTask = Task.Run(() => AutorunScanner.GetAllAutoruns(), ct);
-            var extTask = Task.Run(() => BrowserExtensionScanner.GetAllExtensions(), ct);
-            var appsTask = WindowsAppManager.GetInstalledAppsAsync();
-            var evidenceTask = Task.Run(() => EvidenceRemover.ScanAllTraces(), ct);
-            var emptyTask = Task.Run(() => EmptyFolderScanner.ScanCommonLocations(), ct);
-            var ctxTask = Task.Run(() => ContextMenuCleaner.ScanContextMenuEntries(), ct);
-            var svcTask = Task.Run(() => ServiceScanner.GetAllServices(), ct);
-            var restoreTask = Task.Run(() => SystemRestoreManager.GetRestorePoints(), ct);
+            var autorunTask = Task.Run(() => { var r = AutorunScanner.GetAllAutoruns(); Tick("Autoruns + signatures checked..."); return r; }, ct);
+            var extTask     = Task.Run(() => { var r = BrowserExtensionScanner.GetAllExtensions(); Tick("Browser extensions scanned..."); return r; }, ct);
+            var appsTask    = WindowsAppManager.GetInstalledAppsAsync().ContinueWith(t => { Tick("Windows Apps enumerated..."); return t.Result; }, ct);
+            var evidenceTask= Task.Run(() => { var r = EvidenceRemover.ScanAllTraces(); Tick("Privacy traces scanned..."); return r; }, ct);
+            var emptyTask   = Task.Run(() => { var r = EmptyFolderScanner.ScanCommonLocations(); Tick("Empty folders scanned..."); return r; }, ct);
+            var ctxTask     = Task.Run(() => { var r = ContextMenuCleaner.ScanContextMenuEntries(); Tick("Shell context menu scanned..."); return r; }, ct);
+            var svcTask     = Task.Run(() => { var r = ServiceScanner.GetAllServices(); Tick("Services + signatures checked..."); return r; }, ct);
+            var restoreTask = Task.Run(() => { var r = SystemRestoreManager.GetRestorePoints(); Tick("Restore points loaded..."); return r; }, ct);
 
             await Task.WhenAll(junkTask, tasksTask, autorunTask, extTask, appsTask,
                                evidenceTask, emptyTask, ctxTask, svcTask, restoreTask);
@@ -199,6 +218,7 @@ await Task.WhenAll(junkTask, tasksTask, autorunTask, extTask, appsTask,
                 ApplyContextMenuResults(ctxTask.Result);
                 ApplyServiceResults(svcTask.Result);
                 ApplyRestoreResults(restoreTask.Result);
+                OverlayScanProgress = 100;
             });
 
             ScanOverlayText = "Scan complete!";
@@ -408,20 +428,28 @@ public async Task DeleteEmptyFoldersAsync(IEnumerable<EmptyFolderInfo> selected)
 
     public async Task ScanDiskAsync()
     {
-        IsBusy = true; StatusText = "Analyzing disk space...";
+        IsBusy = true;
+        StatusText = "Analyzing disk space (WizTree-style MFT scan)...";
+
+        var sw = Stopwatch.StartNew();
         try
         {
-            var folders = await Task.Run(() => DiskSpaceAnalyzer.AnalyzeFolder(@"C:\", 1));
-            var large = await Task.Run(() => DiskSpaceAnalyzer.FindLargeFiles(@"C:\", 50 * 1024 * 1024, 200));
+            // FastDiskAnalyzer tries a raw NTFS MFT scan first (single sequential
+            // read per volume) and falls back to FindFirstFileExW with the
+            // large-fetch flag — both substantially faster than the old
+            // Directory.EnumerateFiles path.
+            var folders = await Task.Run(() => FastDiskAnalyzer.AnalyzeDrive(@"C:\"));
+            var large = await Task.Run(() => FastDiskAnalyzer.FindLargeFiles(@"C:\", 50 * 1024 * 1024, 200));
 
             DiskFolders.Clear();
             foreach (var f in folders) DiskFolders.Add(f);
 
             LargeFiles.Clear();
             foreach (var f in large) LargeFiles.Add(f);
 
+            sw.Stop();
             StatusText = $"Found {folders.Count} top-level folders, {large.Count} large files " +
-                         $"({FormatSize(large.Sum(f => f.SizeBytes))})";
+                         $"({FormatSize(large.Sum(f => f.SizeBytes))}) in {sw.Elapsed.TotalSeconds:F1}s";
         }
         finally { IsBusy = false; }
     }
@@ -740,25 +768,60 @@ private void StartPackageEnrichment(IReadOnlyList<InstalledProgram> programs)
 
     public ObservableCollection<RegistryHit> RegistryHits { get; } = new();
 
+    [ObservableProperty] private bool _hunterUseRegex;
+    [ObservableProperty] private bool _hunterSearchKeys = true;
+    [ObservableProperty] private bool _hunterSearchNames = true;
+    [ObservableProperty] private bool _hunterSearchData = true;
+    [ObservableProperty] private int _hunterLiveCount;
+
     public async Task<int> HuntRegistryAsync(string needle)
     {
         RegistryHits.Clear();
+        HunterLiveCount = 0;
+
         if (string.IsNullOrWhiteSpace(needle) || needle.Length < 3)
         {
             StatusText = "Enter at least 3 characters to search the registry";
             return 0;
         }
 
+        var scope = RegistrySearchScope.All;
+        scope = (HunterSearchKeys ? scope : scope & ~RegistrySearchScope.Keys);
+        scope = (HunterSearchNames ? scope : scope & ~RegistrySearchScope.Names);
+        scope = (HunterSearchData ? scope : scope & ~RegistrySearchScope.Data);
+
+        if (scope == 0)
+        {
+            StatusText = "Pick at least one search target (keys / names / data)";
+            return 0;
+        }
+
+        var options = new RegistryHuntOptions(
+            Scope: scope,
+            UseRegex: HunterUseRegex,
+            MaxHits: 500);
+
         _cts = new CancellationTokenSource();
         IsBusy = true;
         StatusText = $"Searching registry for '{needle}'...";
+        var sw = Stopwatch.StartNew();
+
         try
         {
-            var hits = await Task.Run(() => RegistryHunter.Search(needle, ct: _cts.Token), _cts.Token);
+            var progress = new Progress<int>(count =>
+                _dispatcher.BeginInvoke(() => HunterLiveCount = count));
+
+            var hits = await Task.Run(
+                () => RegistryHunter.Search(needle, options, progress, _cts.Token),
+                _cts.Token);
+
             foreach (var h in hits) RegistryHits.Add(h);
-            StatusText = hits.Count >= 500
-                ? $"Registry hunter: found 500+ matches for '{needle}' (capped)"
-                : $"Registry hunter: {hits.Count} matches for '{needle}'";
+            HunterLiveCount = hits.Count;
+
+            sw.Stop();
+            StatusText = hits.Count >= options.MaxHits
+                ? $"Registry hunter: {options.MaxHits}+ matches for '{needle}' (capped) in {sw.Elapsed.TotalSeconds:F1}s"
+                : $"Registry hunter: {hits.Count} matches for '{needle}' in {sw.Elapsed.TotalSeconds:F1}s";
             return hits.Count;
         }
         finally
@@ -804,6 +867,21 @@ private void UpdateOperationProgress(DeleteProgress p, string verb)
         });
     }
 
+    /// <summary>
+    /// Remove a program from the visible lists without re-scanning the entire
+    /// registry. Called by the view after a successful uninstall so the user
+    /// sees the program disappear immediately instead of staring at a stale
+    /// row. A full <see cref="RefreshAsync"/> is still available behind the
+    /// Refresh button if the uninstaller lied about success.
+    /// </summary>
+    public void RemoveProgramFromList(InstalledProgram program)
+    {
+        Programs.Remove(program);
+        FilteredPrograms.Remove(program);
+        ProgramCountText = $"{Programs.Count} programs";
+        ProgramsBadge = Programs.Count.ToString();
+    }
+
     public void OpenBackupFolder()
     {
         var dir = new Core.Safety.BackupManager().BackupDirectory;