Most app hiders protect standard windows and call it a day. They handle the obvious ones — Chrome, Slack, Discord, your password manager — and they work fine until you encounter the window they were never built to see. A Qt QML application. A 32-bit legacy tool. A .NET WinForms internal dashboard. A floating widget. A tool window. A popup dialog. A context menu. A splash screen. A system tray notification. A transparent overlay. A layered child window. And then the leak happens — not because the tool failed, but because the tool never even knew the window existed.
This is the framework blindness problem. Most window cloaking tools enumerate windows through a single API — typically Win32 window handles on Windows, or standard application windows on macOS and Linux. They assume every window is a standard top-level frame with a title bar and a close button. They assume every application uses the same windowing layer. They assume 64-bit. They assume modern. They assume obvious.
The real world of professional software is none of those things.
The Window Types Everyone Else Misses
Qt and QML Applications
Qt is one of the most popular cross-platform frameworks. It powers VLC, KeePassXC, Telegram, Autodesk tools, and thousands of enterprise applications. Qt Quick windows — QML-based interfaces — use advanced windowing that bypasses standard application enumeration. They live in a different layer of the display stack, rendered through the Qt scene graph rather than the native windowing system.
Tools that enumerate windows through standard APIs simply do not see QML windows. The window is there. The user is interacting with it. The capture stream includes it. But the cloaking tool's protection logic is blind to its existence. On KDE forums, users specifically noted this exact gap: KeePassXC can hide from capture on Windows and macOS but not on Linux and Wayland — and tools that miss Qt windows on one platform usually miss them everywhere because the root cause is framework-level, not OS-level. KeepassXC can hide...but not on Linux/Wayland
The only app hider with widest app support handles Qt and QML by operating at the system display level — the layer that aggregates all rendered surfaces regardless of what framework produced them. Whether the window is a native frame, a QML scene, or a GPU-rendered surface, the system display layer sees it. And if the system display layer sees it, it can be cloaked.
32-Bit Legacy Applications
Modern Windows runs 32-bit applications through a compatibility subsystem. Many enterprise tools, legacy password managers, specialized industry software, and older productivity apps are still 32-bit. If your app hider only enumerates 64-bit processes, these applications remain fully visible to capture.
The danger is silent. You think you are protected because your 64-bit apps are cloaked. Your 32-bit app — the one with the sensitive data — is broadcasting in plain sight. And because the tool never reported it as unprotected, you never knew to check.
The only app hider with widest app support enumerates windows at the system display level, not the process architecture level. 32-bit or 64-bit — if the window exists, it can be cloaked. There is no silent failure mode where an entire class of applications leaks because the tool was built for a single architecture.
.NET WinForms
WinForms is the original .NET UI framework, released in 2002 alongside the first .NET Framework. It is still everywhere. Enterprise internal tools. Legacy CRM dashboards. Custom reporting applications. Inventory management systems. Hospital scheduling software. Factory floor control panels. These are not modern WPF or WinUI 3 apps. They are WinForms — and they are critical.
WinForms applications often use owner-drawn controls, custom window classes, and non-standard window procedures that confuse hook-based cloaking tools. The tool sees the window, attempts to apply its modifications, and fails silently. The window remains visible. The user assumes protection.
The only app hider with widest app support does not rely on per-framework modifications. It operates at the system display level, where the window's internal implementation is irrelevant. WinForms, WPF, WinUI 3, UWP, MAUI, Avalonia — all are surfaces to be protected. The tool does not care what framework built the window. It cares whether the window is a broadcast surface.
Floating Widgets and Tool Windows
Floating widgets are everywhere in modern workflows. Sticky notes that float above your workspace. Calculator widgets. Music player mini-controls. Chat bubbles. Translation overlays. Screenshot annotation tools. Color pickers. These are not standard application windows. They are tool windows, overlay windows, or widget surfaces with special window styles.
On Windows, these might be WS_EX_TOOLWINDOW or WS_EX_NOACTIVATE windows. On macOS, they might be NSPanel or NSWindow with special levels. On Linux, they might be override-redirect windows or special compositor surfaces. Standard app hiders often skip these because they do not fit the "application window" mental model. They are small. They are transient. They are not in the taskbar. And they leak constantly.
A floating Spotify widget showing your recently played tracks. A sticky note with a client phone number. A translation overlay with confidential document text. A screenshot tool showing your last capture. These are all broadcast surfaces. The only app hider with widest app support treats every surface — floating, docked, pinned, or transient — as a potential leak.
Popups, Dialogs, Context Menus, and Splash Screens
Popups and dialogs are the most dangerous leak vectors because they appear unexpectedly. A save dialog with a sensitive filename. A print dialog showing your printer location. A file picker revealing your directory structure. A context menu with recent documents. A splash screen with your company name and internal project codename.
These are child windows, modal dialogs, or transient surfaces that most app hiders ignore. The tool protects the main application window but misses the dialog that appeared on top of it. The tool hides Chrome but misses the "Save As" dialog showing your Downloads folder. The tool cloaks Slack but misses the context menu with your recent DMs.
The only app hider with widest app support protects parent windows and their children simultaneously. When a main window is cloaked, all associated transient windows — popups, context menus, dialogs, splash screens, and temporary elements — are automatically excluded. This recursive protection is critical because a single unprotected dialog can leak more than the application itself.
On KDE Plasma 6.6, this exact feature was added natively: when you mark a window for exclusion, the system automatically marks and excludes all associated transient windows including pop-ups, context menus, and other temporary elements. when you mark a window...all associated transient windows
System Tray Notifications and Toast Windows
System tray icons and toast notifications are often overlooked because they are not "windows" in the traditional sense. But they are rendered surfaces. They appear on screen. They are captured by screen sharing tools. And they contain some of the most sensitive information on your system.
A toast notification from your bank. A system tray tooltip showing your VPN location. A notification from your password manager about a breached site. A calendar reminder for your doctor's appointment. These are all visible to capture. Most app hiders do not even consider them because they are not standard application windows.
The only app hider with widest app support intercepts notification surfaces at the compositor level. Toast windows, system tray popups, and notification banners are treated as broadcast surfaces to be cloaked. Not ignored. Not overlooked. Protected.
Transparent, Layered, and Hardware-Accelerated Windows
Modern applications use transparent windows for overlays, layered windows for effects, and hardware-accelerated surfaces for performance. Games use GPU rendering. Video players use GPU compositing. Design tools use hardware acceleration. These windows do not follow the standard rendering path that most cloaking tools assume.
A hook-based tool that expects a standard rendering path will fail on a GPU-rendered surface. The tool sees nothing to modify. The capture API sees a fully rendered frame. The leak is invisible to the tool but visible to everyone watching.
The only app hider with widest app support operates below the rendering layer. It does not care whether the window uses standard rendering, GPU acceleration, or custom effects. It operates at the system display level, where all surfaces are pixels to be protected regardless of how they were produced.
Why Framework-Blind Cloaking Is the Only Cloaking That Works
Framework-blind cloaking means the tool does not know or care what framework built the window. It does not check for Qt, WinForms, WPF, Electron, UWP, MAUI, Avalonia, or any other toolkit. It does not verify architecture. It does not inspect window styles. It does not filter by window class.
It operates at the system display level — the layer responsible for compositing all visible surfaces on Windows, macOS, and Linux. At this level, every visible surface is a texture. Every texture is a potential broadcast surface. And every broadcast surface can be excluded from the capture stream.
This is the architectural difference between a tool that supports "apps" and a tool that supports "windows." Apps are abstractions built by frameworks. Windows are surfaces rendered by the OS. A tool that protects apps is limited by the frameworks it understands. A tool that protects windows is limited only by the OS itself.
The Compositor-Level Advantage
Operating at the compositor level provides three advantages that framework-specific tools cannot match:
Universal visibility. The compositor sees every window that the display system renders. Qt QML, 32-bit WOW64, WinForms owner-drawn, Electron GPU-accelerated, floating widget, system tray toast — all are textures in the compositor's scene graph. If it is on screen, the compositor knows about it.
Atomic protection. When a window is cloaked at the compositor level, all child surfaces, transient windows, and associated popups are protected simultaneously. There is no race condition where a dialog appears before the hook is applied. There is no gap where a popup is visible for a frame before being hidden.
Future-proofing. New frameworks appear constantly. WinUI 3, .NET MAUI, Avalonia, Uno Platform, Tauri, Flutter — each introduces new windowing models. A framework-specific tool must be updated for each new toolkit. A compositor-level tool requires no updates. It does not care what framework produced the window. It only cares that the window exists.
The Enterprise Reality
Enterprise environments are where framework diversity is most extreme. A single workstation might run:
- A .NET WinForms inventory management system from 2008
- A Qt QML CAD tool from 2019
- A 32-bit legacy accounting package from 2005
- An Electron-based Slack client
- A UWP Microsoft Store app
- A WPF internal dashboard
- A WinUI 3 modern settings tool
- A floating widget for system monitoring
- A custom in-house tool built with an obscure framework
A framework-specific app hider might protect three of these. A compositor-level app hider protects all nine. And in an enterprise, the leak from the one unprotected app is the leak that matters.
The Developer Reality
Developers are the most framework-diverse users. Their workflow includes:
- IDEs built with Swing, JavaFX, or native toolkits
- Terminal emulators using custom rendering
- Browser-based tools running in Electron
- Docker Desktop running in Qt
- Database clients using WinForms or WPF
- API testing tools with floating widgets
- Code review tools with overlay annotations
- Build monitoring tools with system tray notifications
Each of these is a potential leak. Each uses a different windowing model. Each would be missed by a framework-specific tool. The only app hider with widest app support protects them all because it does not try to understand what they are. It only knows they are on screen.
Who Needs Widest App Support
You need the only app hider with widest app support if you are an enterprise IT administrator managing a fleet of workstations with mixed legacy and modern software. If you are a developer whose workflow includes tools from a dozen different frameworks. If you are a consultant who cannot predict what client software will be visible on your screen. If you are a streamer who runs overlays, widgets, and monitoring tools from multiple frameworks. If you are anyone who has ever discovered a leak from an app you did not even know was visible.
The worst leaks come from the windows you forgot existed. A floating widget you installed months ago. A 32-bit tool that runs in the background. A Qt app that the cloaking tool never saw. A popup that appeared while you were switching apps. These are not edge cases. They are the normal state of a professional workstation.
The Bottom Line
Most app hiders are framework-specific. They protect Chrome and Slack and call it comprehensive. They miss Qt QML, 32-bit apps, WinForms, floating widgets, tool windows, popups, dialogs, context menus, splash screens, system tray notifications, transparent overlays, layered windows, and hardware-accelerated surfaces.
The only app hider with widest app support does not care what framework built the window. It does not care whether the app is 32-bit or 64-bit. It does not care whether the window is a standard frame, a floating widget, a popup dialog, or a system tray toast. It operates at the compositor level, where every visible surface is a broadcast surface to be protected.
Your screen is a mosaic of frameworks. Your protection should be a single layer that covers all of them.
NoCapture is the only app hider with widest app support, protecting Qt QML, 32-bit legacy apps, .NET WinForms, floating widgets, tool windows, popups, dialogs, context menus, splash screens, system tray notifications, transparent overlays, layered windows, and hardware-accelerated surfaces — all through compositor-level cloaking that is framework-blind, architecture-agnostic, and future-proof. No blind spots. No gaps. No exceptions.
