diff --git a/wv2util/HostAppList.cs b/wv2util/HostAppList.cs
index 3469922..8da56a5 100644
--- a/wv2util/HostAppList.cs
+++ b/wv2util/HostAppList.cs
@@ -50,7 +50,8 @@ public HostAppEntry(
             string runtimePath, // Path to the WebView2 client DLL
             string userDataPath, // Path to the user data folder
             string[] interestingLoadedDllPaths, // a list of full paths of DLLs that are related to WebView2 in some way
-            int browserProcessPid) // PID of the browser process
+            int browserProcessPid,
+            IntPtr[] hwnds) // PID of the browser process
         {
             Kind = kind;
             ExecutablePath = exePath == null ? "Unknown" : exePath;
@@ -61,6 +62,7 @@ public HostAppEntry(
             UserDataPath = userDataPath == null ? "Unknown" : userDataPath;
             InterestingLoadedDllPaths = interestingLoadedDllPaths;
             BrowserProcessPID = browserProcessPid;
+            Hwnds = hwnds == null ? new IntPtr[0] : hwnds;
         }
 
         public string DisplayLabel
@@ -98,6 +100,7 @@ public string DisplayLabel
         public string UserDataPath { get; private set; }
         public string[] InterestingLoadedDllPaths { get; private set; }
         public int BrowserProcessPID { get; private set; } = 0;
+        public IntPtr[] Hwnds { get; private set; }
         public string IntegrityLevel
         {
             get
@@ -401,7 +404,8 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                             msedgewebview2Process.MainModule.FileName,
                             userDataPathAndProcessType.Item1,
                             null,
-                            0);
+                            0,
+                            null);
                     }
 
                     if (parentProcess != null)
@@ -426,7 +430,8 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                         hostAppEntry.Runtime.ExePath,
                                         userDataFolder,
                                         hostAppEntry.InterestingLoadedDllPaths,
-                                        msedgewebview2Process.Id);
+                                        msedgewebview2Process.Id,
+                                        hostAppEntry.Hwnds);
                                     newHostAppEntry.Children.AddRange(hostAppEntry.Children);
                                     newHostAppEntry.Children.Add(currentProcessEntry);
 
@@ -470,7 +475,8 @@ private static IEnumerable<HostAppEntry> GetHostAppEntriesFromMachineByProcessMo
                             ClientDllPathToRuntimePath(interestingDllPaths.Item1),
                             null,
                             interestingDllPaths.Item3,
-                            0));
+                            0,
+                            null));
                 }
             }
             return results;
@@ -531,7 +537,8 @@ public static IEnumerable<HostAppEntry> GetHostAppEntriesFromMachineByPipeEnumer
                             ClientDllPathToRuntimePath(clientDllPath),
                             null,
                             interestingDllPaths,
-                            0));
+                            0,
+                            null));
                     }
                 }
             };
@@ -566,6 +573,7 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                     if (hostAppEntry.BrowserProcessPID == 0)
                     {
                         HashSet<int> runtimePids = new HashSet<int>();
+                        Dictionary<int, HashSet<IntPtr>> runtimePidToHwndMap = new Dictionary<int, HashSet<IntPtr>>();
 
                         // And find corresponding top level windows for just this PID.
                         if (pidToTopLevelHwndsMap.TryGetValue(hostAppEntry.PID, out var topLevelHwnds))
@@ -584,9 +592,17 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                     {
                                         childHwnd = PInvoke.User32.GetProp(hostAppLeafHwnd, "CrossProcessChildHWND");
                                     }
+                                    
                                     if (childHwnd != IntPtr.Zero)
                                     {
-                                        runtimePids.Add(HwndUtil.GetWindowProcessId(childHwnd));
+                                        int runtimePid = HwndUtil.GetWindowProcessId(childHwnd);
+                                        runtimePids.Add(runtimePid);
+
+                                        if (!runtimePidToHwndMap.TryGetValue(runtimePid, out HashSet<IntPtr> runtimeHwnds))
+                                        {
+                                            runtimePidToHwndMap[runtimePid] = runtimeHwnds = new HashSet<IntPtr>();
+                                        }
+                                        runtimeHwnds.Add(childHwnd);
                                     }
                                 }
                             }
@@ -602,6 +618,8 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                         var userDataPathAndProcessType = GetUserDataPathAndProcessTypeFromProcessViaCommandLine(runtimeProcess);
                                         userDataFolder = userDataPathAndProcessType.Item1;
 
+                                        runtimePidToHwndMap.TryGetValue(runtimePid, out HashSet<IntPtr> runtimeHwnds);
+
                                         var runtimeEntry = new HostAppEntry(
                                             "host",
                                             hostAppEntry.ExecutablePath,
@@ -611,7 +629,8 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                             hostAppEntry.Runtime.ExePath,
                                             userDataFolder,
                                             hostAppEntry.InterestingLoadedDllPaths,
-                                            runtimePid);
+                                            runtimePid,
+                                            runtimeHwnds?.ToArray());
                                         runtimeEntry.Children.AddRange(hostAppEntry.Children);
                                         runtimeEntry.Children.Add(new HostAppEntry(
                                             userDataPathAndProcessType.Item2,
@@ -622,7 +641,8 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                             runtimeProcess.MainModule.FileName,
                                             userDataFolder,
                                             null,
-                                            0));
+                                            0,
+                                            runtimeEntry.Hwnds));
                                         hostAppEntriesWithRuntimePID.Add(runtimeEntry);
                                         added = true;
                                     }
@@ -653,6 +673,7 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                 List<HostAppEntry> hostAppEntriesResults = new List<HostAppEntry>();
                 Dictionary<int, HashSet<int>> parentPidToChildPidsMap = new Dictionary<int, HashSet<int>>();
                 var topLevelHwnds = HwndUtil.GetTopLevelHwnds(null, true);
+                Dictionary<int, HashSet<IntPtr>> childPidToHwnd = new Dictionary<int, HashSet<IntPtr>>();
 
                 // Then find all child (and child of child of...) windows that have appropriate class name
                 foreach (var topLevelHwnd in topLevelHwnds)
@@ -681,6 +702,12 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                 }
                                 childPids.Add(childPid);
                             }
+                            
+                            if (!childPidToHwnd.TryGetValue(childPid, out HashSet<IntPtr> childHwnds))
+                            {
+                                childPidToHwnd[childPid] = childHwnds = new HashSet<IntPtr>();
+                            }
+                            childHwnds.Add(childHwnd);
                         }
                     }
                 }
@@ -702,6 +729,7 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                     {
                                         var userDataPathAndProcessType = GetUserDataPathAndProcessTypeFromProcessViaCommandLine(runtimeProcess);
                                         string userDataFolder = userDataPathAndProcessType.Item1;
+                                        childPidToHwnd.TryGetValue(childPid, out HashSet<IntPtr> runtimeHwnds);
 
                                         var runtimeEntry = new HostAppEntry(
                                             "host",
@@ -712,7 +740,8 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                             hostAppEntry.Runtime.ExePath,
                                             userDataFolder,
                                             hostAppEntry.InterestingLoadedDllPaths,
-                                            childPid);
+                                            childPid,
+                                            runtimeHwnds?.ToArray());
                                         runtimeEntry.Children.Add(new HostAppEntry(
                                             userDataPathAndProcessType.Item2,
                                             runtimeProcess.MainModule.FileName,
@@ -722,7 +751,8 @@ private static IEnumerable<HostAppEntry> AddRuntimeProcessInfoToHostAppEntriesBy
                                             runtimeProcess.MainModule.FileName,
                                             userDataFolder,
                                             null,
-                                            0));
+                                            0,
+                                            runtimeEntry.Hwnds));
                                         runtimeEntry.Children.AddRange(hostAppEntry.Children);
                                         hostAppEntriesResults.Add(runtimeEntry);
                                         added = true;
diff --git a/wv2util/HwndUtil.cs b/wv2util/HwndUtil.cs
index d22d497..b935a95 100644
--- a/wv2util/HwndUtil.cs
+++ b/wv2util/HwndUtil.cs
@@ -175,5 +175,23 @@ public static string GetClassName(IntPtr hwnd)
             }
             return className;
         }
+
+        public static System.Windows.Rect ToSystemWindowsRect(this PInvoke.RECT rectAsPInvokeRect)
+        {
+            System.Windows.Rect rectAsSystemWindowsRect = new System.Windows.Rect();
+            rectAsSystemWindowsRect.X = rectAsPInvokeRect.left;
+            rectAsSystemWindowsRect.Y = rectAsPInvokeRect.top;
+            rectAsSystemWindowsRect.Width = rectAsPInvokeRect.right - rectAsPInvokeRect.left;
+            rectAsSystemWindowsRect.Height = rectAsPInvokeRect.bottom - rectAsPInvokeRect.top;
+            return rectAsSystemWindowsRect;
+        }
+         public static System.Windows.Rect GetWindowRect(IntPtr hwnd)
+        {
+            if (!PInvoke.User32.GetWindowRect(hwnd, out var rect))
+            {
+                throw new PInvoke.Win32Exception(PInvoke.Kernel32.GetLastError());
+            }
+            return rect.ToSystemWindowsRect();
+        }
     }
 }
diff --git a/wv2util/MainWindow.xaml b/wv2util/MainWindow.xaml
index 432f1d1..63e700e 100644
--- a/wv2util/MainWindow.xaml
+++ b/wv2util/MainWindow.xaml
@@ -65,7 +65,8 @@
                         <RowDefinition Height="*"/>
                     </Grid.RowDefinitions>
                     <CheckBox Grid.Row="0" Grid.Column="0" Margin="5 5 5 5" Content="Discover more Host Apps information (slower)" IsChecked="{Binding Source={StaticResource HostAppList}, Path=ShouldDiscoverSlowly, Mode=TwoWay}" x:Name="HostAppsDiscoverSlowlyCheckbox" Checked="HostAppsDiscoverSlowlyCheckbox_Checked" Unchecked="HostAppsDiscoverSlowlyCheckbox_Checked"/>
-                    <TreeView Grid.Row="1" Grid.Column="0" Grid.RowSpan="20" Margin="5 5 5 5" x:Name="HostAppTreeView" ItemsSource="{Binding .}" SelectedValuePath="Model">
+                    <CheckBox Grid.Row="0" Grid.Column="1" Margin="5 5 5 5" Content="Highlight WebView2 (experimental)" IsChecked="False" x:Name="HostAppsVisuallyHighlightWebView2sCheckbox" Checked="HostAppsVisuallyHighlightWebView2sCheckbox_Checked" Unchecked="HostAppsVisuallyHighlightWebView2sCheckbox_Checked"/>
+                    <TreeView Grid.Row="1" Grid.Column="0" Grid.RowSpan="20" Margin="5 5 5 5" x:Name="HostAppTreeView" ItemsSource="{Binding .}" SelectedValuePath="Model" SelectedItemChanged="HostAppTreeViewSelectionChanged">
                         <TreeView.ItemContainerStyle>
                             <Style TargetType="{x:Type TreeViewItem}">
                                 <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay}" />
diff --git a/wv2util/MainWindow.xaml.cs b/wv2util/MainWindow.xaml.cs
index e2935cf..ab2973d 100644
--- a/wv2util/MainWindow.xaml.cs
+++ b/wv2util/MainWindow.xaml.cs
@@ -143,7 +143,40 @@ private void RuntimeListViewSelectionChanged(object sender, SelectionChangedEven
                 }
             }
         }
+        private List<OverlayWindow> m_openOverlayWindows = new List<OverlayWindow>();
+        private void UpdateOverlayWindows()
+        {
+            foreach (var overlayWindow in m_openOverlayWindows)
+            {
+                overlayWindow.CloseOverlay();
+            }
+            m_openOverlayWindows.Clear();
+
+            if (this.HostAppsVisuallyHighlightWebView2sCheckbox.IsChecked.GetValueOrDefault(true))
+            {
+                
+                HostAppEntry selection = HostAppTreeViewSelectedItem;
+                if (selection != null)
+                {
+                    foreach (var hwnd in selection?.Hwnds)
+                    {
+                        m_openOverlayWindows.Add(
+                            OverlayWindow.OpenOverlayForHwnd(hwnd));
+                    }
+                }
+                
+            }
+        }
+        private void HostAppTreeViewSelectionChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
+        {
+            UpdateOverlayWindows();
+        }
         
+        private void HostAppsVisuallyHighlightWebView2sCheckbox_Checked(object sender, RoutedEventArgs e)
+        {
+            UpdateOverlayWindows();
+        }
+
         private void AppOverrideRuntimePathButton_Click(object sender, RoutedEventArgs e)
         {
             FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog
@@ -427,5 +460,6 @@ private void NewsBlock_Click(object sender, MouseButtonEventArgs e)
                     : Visibility.Visible;
             }
         }
+
     }
 }
diff --git a/wv2util/OverlayWindow.xaml b/wv2util/OverlayWindow.xaml
new file mode 100644
index 0000000..f0dc3a4
--- /dev/null
+++ b/wv2util/OverlayWindow.xaml
@@ -0,0 +1,9 @@
+<Window x:Class="wv2util.OverlayWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:wv2util"
+        mc:Ignorable="d"
+        Title="Overlay" Height="450" Width="800" WindowStyle="None" AllowsTransparency="True" Opacity="0.25" ResizeMode="NoResize" ShowInTaskbar="False" Topmost="False" Focusable="False" IsHitTestVisible="False" IsTabStop="False" Background="#FF84B9FF" MouseUp="Window_MouseUp">
+</Window>
\ No newline at end of file
diff --git a/wv2util/OverlayWindow.xaml.cs b/wv2util/OverlayWindow.xaml.cs
new file mode 100644
index 0000000..e8de86b
--- /dev/null
+++ b/wv2util/OverlayWindow.xaml.cs
@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Timers;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Interop;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+using Timer = System.Timers.Timer;
+
+
+namespace wv2util
+{
+    /// <summary>
+    /// Interaction logic for Overlay.xaml
+    /// </summary>
+    public partial class OverlayWindow : Window
+    {
+        // The HWND of the target window over which we will render our overlay
+        private IntPtr m_targetHwnd;
+        private IntPtr m_thisHwnd;
+        // The timer that tracks when to check for target HWND updates
+        private Timer m_checkForUpdatesTimer;
+        private Rect m_previousRect;
+        public bool IsClosed { get; private set; } = false;
+        
+        public static OverlayWindow OpenOverlayForHwnd(IntPtr targetHwnd)
+        {
+            var overlayWindow = new OverlayWindow(targetHwnd);
+            if (!overlayWindow.IsClosed)
+            {
+                overlayWindow.Show();
+            }
+            return overlayWindow;
+        }
+        
+        protected OverlayWindow(IntPtr targetHwnd)
+        {
+            this.ShowActivated = false;
+            m_targetHwnd = targetHwnd;
+            Loaded += this.Window_Loaded;
+            InitializeComponent();
+            UpdateOverlayToMatchTarget();
+            this.ShowActivated = false;
+
+            m_checkForUpdatesTimer = new Timer(500);
+            var synchronizationContext = SynchronizationContext.Current;
+            m_checkForUpdatesTimer.Elapsed += (object o, ElapsedEventArgs e) =>
+            { 
+                synchronizationContext.Post((objectContext) => UpdateOverlayToMatchTarget(), null);
+            };
+            m_checkForUpdatesTimer.Start();
+            
+        }
+
+        protected override void OnSourceInitialized(EventArgs e)
+        {
+            base.OnSourceInitialized(e);
+
+            m_thisHwnd = new WindowInteropHelper(this).Handle;
+
+            // Change the extended window style to include WS_EX_TRANSPARENT
+            int extendedStyle = PInvoke.User32.GetWindowLong(
+                m_thisHwnd,
+                PInvoke.User32.WindowLongIndexFlags.GWL_EXSTYLE);
+            PInvoke.User32.SetWindowLong(
+                m_thisHwnd,
+                PInvoke.User32.WindowLongIndexFlags.GWL_EXSTYLE,
+                (PInvoke.User32.SetWindowLongFlags)extendedStyle | PInvoke.User32.SetWindowLongFlags.WS_EX_TRANSPARENT);
+        }
+
+        private void UpdateOverlayToMatchTarget()
+        {
+            /*
+            if (!IsClosed)
+            {
+                bool windowStillSeemsValid = true;
+                int pid = 0;
+                try
+                {
+                    pid = HwndUtil.GetWindowProcessId(m_targetHwnd);
+                }
+                catch (Exception)
+                {
+                }
+                windowStillSeemsValid = pid != 0;
+                if (!windowStillSeemsValid)
+                {
+                    CloseOverlay();
+                    Trace.WriteLine("Closing overlay. Window seems to be invalid.");
+                }
+            }
+            */
+            if (!IsClosed)
+            {
+                try
+                {
+                    var targetHwndRect = HwndUtil.GetWindowRect(m_targetHwnd);
+                    if (targetHwndRect != m_previousRect && !m_previousRect.IsEmpty)
+                    {
+                        PInvoke.User32.MoveWindow(
+                            m_thisHwnd,
+                            (int)targetHwndRect.Left,
+                            (int)targetHwndRect.Top,
+                            (int)targetHwndRect.Width,
+                            (int)targetHwndRect.Height,
+                            true);
+                    }
+                    m_previousRect = targetHwndRect;
+
+                    bool isTargetVisible = PInvoke.User32.IsWindowVisible(m_targetHwnd);
+                    var targetWindowStyle = PInvoke.User32.GetWindowLong(m_targetHwnd, PInvoke.User32.WindowLongIndexFlags.GWL_STYLE);
+                    bool isTargetMinized = (targetWindowStyle & (int)PInvoke.User32.WindowStyles.WS_MINIMIZE) != 0;
+                    bool isTargetIconic = PInvoke.User32.IsIconic(m_targetHwnd);
+                    bool showWindow = isTargetVisible && !isTargetMinized && !isTargetIconic;
+
+                    if (this.IsVisible != showWindow)
+                    {
+                        if (showWindow)
+                        {   
+                            this.Show();
+                        }
+                        else
+                        {
+                            this.Hide();
+                        }
+                    }
+
+                    IntPtr targetOwner = PInvoke.User32.GetAncestor(
+                        m_targetHwnd, PInvoke.User32.GetAncestorFlags.GA_ROOTOWNER);
+                    IntPtr prevTargetHwnd = PInvoke.User32.GetNextWindow(
+                        targetOwner, PInvoke.User32.GetNextWindowCommands.GW_HWNDPREV);
+                    if (prevTargetHwnd != null && prevTargetHwnd != m_thisHwnd)
+                    {
+                        PInvoke.User32.SetWindowPos(m_thisHwnd, prevTargetHwnd, 0, 0, 0, 0,
+                            PInvoke.User32.SetWindowPosFlags.SWP_NOSIZE |
+                            PInvoke.User32.SetWindowPosFlags.SWP_NOMOVE);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Trace.WriteLine("Error showing overlay window: " + e);
+                    //this.CloseOverlay();
+                }
+            }
+        }
+
+        private void Window_Loaded(object sender, RoutedEventArgs e)
+        {
+            this.Height = m_previousRect.Height;
+            this.Width = m_previousRect.Width;
+            this.Top = m_previousRect.Top;
+            this.Left = m_previousRect.Left;
+
+        }
+
+        private void Window_MouseUp(object sender, MouseButtonEventArgs e)
+        {
+            // Hide and shutdown the Window
+            CloseOverlay();            
+        }
+
+        public void CloseOverlay()
+        {
+            // Hide and shutdown this window.
+            IsClosed = true;
+            this.Close();
+        }
+    }
+}
\ No newline at end of file
diff --git a/wv2util/wv2util.csproj b/wv2util/wv2util.csproj
index c47bab8..ddfe5fc 100644
--- a/wv2util/wv2util.csproj
+++ b/wv2util/wv2util.csproj
@@ -138,6 +138,9 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Compile Include="OverlayWindow.xaml.cs">
+      <DependentUpon>OverlayWindow.xaml</DependentUpon>
+    </Compile>
     <Compile Include="App.xaml.cs">
       <DependentUpon>App.xaml</DependentUpon>
       <SubType>Code</SubType>
@@ -145,6 +148,10 @@
     <Compile Include="MainWindow.xaml.cs">
       <DependentUpon>MainWindow.xaml</DependentUpon>
     </Compile>
+    <Page Include="OverlayWindow.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="TraceWindow.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
diff --git a/wv2utilTests/ReportCreatorTests.cs b/wv2utilTests/ReportCreatorTests.cs
index 7200c15..9f5adb8 100644
--- a/wv2utilTests/ReportCreatorTests.cs
+++ b/wv2utilTests/ReportCreatorTests.cs
@@ -18,7 +18,7 @@ public class ReportCreatorTests
         ReportCreator CreateReportCreatorForTest()
         {
             return new ReportCreator(
-                new HostAppEntry("host", "example.exe", 1, 0, "C:\\windows\\system32\\actxprxy.dll", "C:\\windows\\system32", "C:\\windows\\system32", new string[] { }, 2),
+                new HostAppEntry("host", "example.exe", 1, 0, "C:\\windows\\system32\\actxprxy.dll", "C:\\windows\\system32", "C:\\windows\\system32", new string[] { }, 2, null),
                 new List<AppOverrideEntry>(),
                 new List<RuntimeEntry>());
         }