Mount a Taskbar overlay with real-time system data In Windows, it's one of those things that, once you try it, you won't want to live without. Being able to see CPU and GPU usage, temperatures, FPS, memory consumption, or the overall health of your system without having to minimize a game or a demanding app completely changes the experience, whether you're a gamer or work with video editing, 3D modeling, or virtual machines.
Furthermore, if your goal is to create your own Windows overlay application without risking bans (for example, a deck tracker or a hardware monitor for full-screen games), you'll need to combine several pieces: taskbar overlays, OSD over Direct3D/Vulkan, self-updating data panels, reading system counters, and in many cases, integration with mature tools like MSI Afterburner, RivaTuner, or even Kusto-type query-based dashboards (KQL).
What exactly is a Taskbar Overlay and how does it relate to overlays in games?
In the Windows world, we often mix together under the same umbrella of Taskbar Overlay Two concepts that should be kept separate to avoid confusion. On one hand, there's the overlay of information on the taskbar button itself: small icons on top of the main icon, progress bars, thumbnails with buttons, blinking alerts, etc. On the other hand, there are OSD-type overlays that are drawn on top of a full-screen game or app using the graphics pipeline (Direct3D, Vulkan, etc.).
In the taskbar sectionWindows exposes APIs such as TaskbarItemInfo in WPF or Win32 taskbar APIsFrameworks like Electron encapsulate them in high-level methods. There you can experiment with a... overlay icon that changes color when the temperature rises, with progress bars on the button, with JumpLists for quick access, or with thumbnails that include their own control buttons without opening the main window.
The second block is that of on-screen overlays, what we usually call OSD (On-Screen Display)This is what you see when you use MSI Afterburner with RivaTuner Statistics Server: a semi-transparent block overlaid on the game image displaying FPS, frametime, CPU/GPU loads, voltages, temperatures, etc. This layer doesn't touch or patch the game executable; it hooks into the Direct3D/Vulkan rendering stream to draw on top of it. minimize the risk of bans.
The powerful idea is to combine both things coherently: detailed data on screen while you play or with a summarized and persistent state in the taskbar when the game minimizes or you switch windows. Ultimately, it's about having a kind of "system health light" always visible, reinforced with a more comprehensive panel when you need to look more closely.
APIs, frameworks, and approaches for creating overlays without aggressive injection
To develop an overlay app that works well in full-screen games and doesn't raise anti-cheat suspicions, you have several options depending on the language and stack. With C#, C++ or Go You can use both native APIs and modern desktop frameworks like Electron or WPF.
In the classic .NET ecosystem, one of the cleanest ways to communicate with the taskbar is to use WPF and the TaskbarItemInfo classThis class allows you to set properties such as Overlay, which admits a System.Windows.Media.ImageSource and draw a small image in the bottom right corner of the program icon. It's ideal for displaying a system status (green, amber, red) without depending on the notification area, which in versions like Windows 7 tends to hide icons.
In desktop applications based on web technologies, Electron It makes playing games with the Windows taskbar quite easy. You can create JumpLists with app.setUserTasks For actions such as “Start monitoring” or “Change overlay profile”, define buttons in the thumbnail with BrowserWindow.setThumbarButtons, place a overlay icon with BrowserWindow.setOverlayIcon and do blink the button from the taskbar with BrowserWindow.flashFrame when something gets bad in terms of temperature.
If your obsession is not to inject anything into game processes, the healthy pattern is to separate. Data Capture y render of overlayOn one hand, you read system performance counters, logs, or public APIs (for example, those from Windows Performance Counters or external tools). On the other hand, you draw the overlay as a floating window. always-on-top and borderless, or through hooking mechanisms documented in the graphics backend, in the style of what RTSS does: it integrates with Direct3D but only to monitor, not to manipulate the game.
Taskbar Overlay as a dashboard: well-organized real-time data
If you think about your Taskbar Overlay a little, it's really nothing more than a miniature real-time dashboardThe same concept you see in Microsoft Fabric dashboards, Azure Data Explorer, or solutions based on Kusto / KQL: a canvas composed of “tiles” or icons, each backed by a query to a data source.
In these systems, each icon is typically associated with a KQL query and a display configuration (line chart, table, KPI, etc.). Applied to your overlay, each metric you want to display (GPU temperature, FPS, latency, RAM usage, etc.) can be modeled as an icon. query to a data source and as a concrete way of displaying it: text, status color, mini-graphic or even a simple large number above the taskbar icon.
Another interesting idea about these panels is that they allow organize icons on pages or viewsYou could replicate this as overlay “profiles”: a light view for gaming, a more feature-rich one for editing tasks, and another focused on diagnostics. In many dashboards, this definition can be exported to JSONThis fits perfectly with an app that wants to save and share complete configurations of metrics, positions, and styles.
The dashboard approach also brings concepts such as explicit data sources, well-defined queries, filtering parameters, and self-updating policiesApplied to your overlay, this means defining how often you refresh the different data groups (every second for FPS/temperature, maybe every 30-60 seconds for heavy or remote stats) to prevent the system from crashing.
Activate, configure, and power panels in real time
If you are inspired by platforms like Microsoft Fabric or Azure Data ExplorerThe typical workflow for working with real-time dashboards begins by enabling the functionality at the tenant and workspace level. The "Create real-time dashboards" option is activated in the portal, and from there, users can define KQL-based dashboards and associate data sources with them within a specific workspace.
Once you can create panels, you usually define the first reusable data sourcesConceptually, these are simply references to Kusto or similar databases within the same workspace. Multiple icons can point to the same source but with different queries. In your Taskbar Overlay, you could have a "Local Team" source that interacts with system counters, another "Game Logs" source for analyzing log files, and perhaps a "Cloud Service" source for backend statistics.
At the interface level, these panels typically offer a edit mode From here you can add icons, define reusable base queries, and declare global parameters. In another administration tab you configure data sources and update frequency, setting minimum limits to prevent some bright spark from forcing a refresh every 50 ms and bringing everything down.
When you add a new tile, the normal procedure is to choose the data source, write the KQL query, execute it to see what it returns, and then, based on the result, choose a associated visual object (line, bar, KPI card, table…). Then you adjust axes, scales, colors, legend, and, if necessary, hide the title to save space. You can apply this same philosophy to how you decide what goes into your overlay and how it's drawn on screen.
Advanced editing: icons, pages, parameters and auto-update
One of the keys to any serious panel is that the underlying query of each icon is editableTypically, an icon includes a small pencil that opens an editor where you see the tree of tables and functions on the left and the query itself on the right. Many platforms today even integrate a Copilot-type assistant, to whom you describe what you want to see and it generates an initial query that you then refine.
To avoid having a "graveyard of numbers", the panels allow you to group tiles into thematic pagesYou can replicate this idea as profiles or views within your overlay: hardware vs. network, quick view vs. detailed view, basic user vs. advanced user. You could even set up master-detail flows: a general PC status that, when clicked, opens a detailed view of the CPU or GPU.
The shared parameters They're another very useful trick. In dashboards, they're used to reduce the volume of data as quickly as possible: for example, a time interval parameter, or the identifier of a machine or process. In your overlay, you could model parameters like "refresh interval," "active game," or "consumption profile" and have various parts of the system react in a chain reaction when they change.
Regarding user experience, the following are usually added interactive legends that allow you to activate/deactivate data series with a click, combine them with CTRL for multiple selection, use SHIFT for ranges, etc. Even if your Taskbar Overlay isn't going to have complex charts, the idea of being able to hide or dim individual metrics It's very portable with shortcuts or clicks.
Auto-update is the piece that ties it all together: each panel defines a minimum interval and default frequencyThe minimum refresh rate acts as a global limiter (for example, refreshes faster than every 30 seconds are not allowed), and then each user can choose to refresh faster or slower within that range. In your overlay, it's best to clearly separate what needs ultra-fast refresh (FPS, temperature) from what can be refreshed at a more relaxed pace (cumulative statistics, averages, etc.).
Export overlay and panel settings to JSON
Another interesting feature of modern monitoring panels is that their entire configuration can be customized. export to JSONThis file describes the panel title, pages, tile list with IDs, queries, positions, parameters, display types, and auto-refresh settings. It also includes data sources and the JSON schema itself.
This allows you to use those files as templates and backupsYou can version them in Git and even edit them manually to make bulk changes. Platforms often allow "replace from file" to restore an entire panel from a previous JSON file. Extrapolating this idea, your Taskbar Overlay could save and load complete profiles of metrics, styles, and positions in JSON, shareable between users or teams.
Detailed integration with the taskbar in Electron
If you choose Electron as a base for your overlayYou have at your disposal a fairly comprehensive set of Windows taskbar-specific APIs, in addition to other cross-platform ones. JumpListsFor example, these are the lists that appear when you right-click on the app icon. app.setUserTasks You can define shortcuts to frequent tasks that do not depend on the current state of the window, such as starting or pausing monitoring, opening a performance panel, or changing overlay profiles.
Another useful piece is the thumbnail toolbarA bar with up to seven buttons appears above the window thumbnail when you hover your mouse over the taskbar icon. BrowserWindow.setThumbarButtons You could display buttons to pause the overlay, switch between light/advanced views, or reset statistics, without needing to open the main panel.
To indicate the status at a glance, BrowserWindow.setOverlayIcon It lets you place a small image over the app icon, identical to the WPF concept. It's perfect for a global health traffic light of the system: green icon when everything is within normal parameters, yellow when any metric enters the warning zone and red when there are critical temperatures, throttling or extreme use.
Finally, with BrowserWindow.flashFrame can you do blinking taskbar button When something serious happens: for example, if the CPU reaches a sustained 100% usage or if the GPU temperature spikes with the game minimized. In that case, it's advisable to call flashFrame(false) when the window regains focus or after a reasonable amount of time so as not to turn your app into a constant nuisance.
WPF-type integration: TaskbarItemInfo Overlay property
In .NET environments with C# and WPFThe key mechanism for the overlay in the icon is the class TaskbarItemInfoThis class exposes the property Overlay, of type System.Windows.Media.ImageSourceThis defines the image that will be displayed over the program icon in the taskbar. By default, it is nullwhich means there is no overlay whatsoever.
In XAML you can declare the configuration directly within <Window.TaskbarItemInfo>, instantiating a TaskbarItemInfo with name and assigning the overlay image as static resourceIn addition, you have properties such as ThumbnailClipMargin to adjust the thumbnail cropping and Description to improve the accessibility and description of the taskbar button.
If you prefer to do it in C#, simply retrieve an image resource (for example, a DrawingImage) through FindResource and assign it to taskBarItemInfo1.OverlayThe result is a small image, static or animated, located in the lower right corner of the icon, which adopts the correct size and respects the color depth if it is based on an object IconThe only significant limitation is that the overlay is not displayed if the user has configured the taskbar with small icons.
This all stems from a very specific problem: in versions like Windows 7, the notification area icons are usually hidden by defaultTherefore, relying solely on the system tray to communicate status falls short. Overlays on the taskbar button avoid this problem and ensure that critical status changes are visible, even if the system tray icon is collapsed.
Monitor your PC in real time with MSI Afterburner and RivaTuner
For extracting reliable, real-time hardware data, few combos are as proven as MSI Afterburner together with RivaTuner Statistics Server (RTSS)Afterburner was born as a GPU overclocking tool, but today it is a very complete monitor that collects data from CPU, GPU and other component sensors, and integrates with RTSS to paint them on top of games and 3D applications.
The main advantage of this duo is that it allows you to configure a Detailed OSD within full-screen games without having to minimize or look at external tools. You can display CPU/GPU usage and frequency, temperatures, power consumption, voltages, FPS, frametime, RAM and VRAM usage, and much more, with customizable text, graphics, and color styles.
In addition, Afterburner can rely on suppliers such as HWiNFO64, HWMonitor or AIDA64 to drastically increase the number of available sensors. And it does so with very low resource consumption, which is crucial if you're monitoring while gaming or working with demanding software.
Installation and basic configuration of the Afterburner + RTSS combo
The setup is fairly straightforward as long as you download MSI Afterburner from its official website to avoid modified or malware-infected versions. The installer is usually bundled with RivaTuner Statistics Server, and it's recommended to check the box to install RTSS in the same process and, before anything else, review a essential hardware checklist to ensure maximum compatibility.
After installation, open Afterburner and go to the properties menu (gear icon). On the General tab, it's crucial to review the compatibility options so that it can communicate correctly with the system and with RTSS. Then, in the tab of MonitoringYou choose the refresh rate (for example, 1000 ms to update every second), select which sensors you want to track, and decide whether each one will be displayed on the screen (OSD), in the notification area, or on external devices such as LCD keyboards.
By checking “display information on screen,” you indicate that this metric will appear in the in-game overlay. For data like FPS or frametime, it's often useful to enable this display. graphic plus textWhile for temperatures or CPU/GPU usage, text is usually sufficient. You can also adjust the graph limits to ensure consistent scales and prevent information from being squashed.
Fine-tuning the OSD in RivaTuner and per-game profiles
Although much of the metrics selection is done from within Afterburner, the fine-tuning the overlay (position, appearance, 3D application detection, etc.) is done within RivaTuner Statistics Server. RTSS usually starts minimized in the notification area, from where you can open its main interface.
In RTSS it is advisable to start by ensuring that Show On-Screen Display It's enabled, otherwise you won't see anything at all in the games. The option Application detection level Control how aggressively RTSS identifies programs that should receive overlays; it's usually best to leave it on "Low" to avoid unwanted overlays in non-graphics apps. Medium or High modes are reserved for cases where the overlay doesn't appear in certain games and you need to force it.
Other options like “Stealth mode” “Custom Direct3D support” is recommended to be left disabled unless you are having problems with specific games. “Framerate limit” It allows you to set an FPS limit from RTSS, useful for saving power or adapting to 60Hz monitors, although it is often more cost-effective to limit it from the game itself or from the GPU driver.
The RTSS interface includes arrows for move the overlay around the screenso that it doesn't obscure important HUDs. You can configure profiles per application, so each game has its own positions and set of metrics: in one game you might need to see temperature and FPS, in another you're more interested in frametime and VRAM usage. This flexibility is a good example of what you should offer in your own Taskbar Overlay.
A very practical setting is usually to always show GPU temperature and loadCPU temperature and power consumption, and FPS. With that combination, you already have a quick indication of whether the bottleneck is thermal, CPU-related, or GPU-related. If you want to go a step further, add RAM and VRAM usage, and a frametime graph to catch any stuttering that isn't reflected in the average FPS.
Extend the overlay to mobile: second screen for metrics
One drawback of having a screen overlay is that it can be distracting if you take a lot of screenshots or record videos and want a clean image. A very interesting alternative is to delegate some of the monitoring to a... second cheap external screen, like an old mobile phone, leaving the game free of extra elements.
Applications like Pitikap integrate with MSI Afterburner: you install the component on your PC and the mobile app (Android or iOS), verify that both devices are on the same Wi-Fi network, and connect them. From there, you can add information modules to the Windows client and view them as customizable widgets on the phoneadjusting colors, sizes and arrangement according to how you have positioned the device.
This approach fits very well with the idea of a complete overlay system: certain data can be seen in the taskbar, others in a OSD within the game and others in a dedicated external panel which doesn't clutter the image. Everything orchestrated as if they were different views of the same real-time dashboard.
Combining the Windows APIs for the taskbar (TaskbarItemInfo, Win32), windowing frameworks like Electron or WPF, the mental model of dashboards based on KQL queries, and established tools like MSI Afterburner and RivaTuner, you can build a very complete Taskbar Overlay system. You'll have reliable, real-time metrics, configurable via JSON, with profiles, pages, and parameters, and more. without resorting to invasive injections Nor should you get into trouble with anti-cheat systems, which is exactly what you want when you want to monitor without becoming a suspect. Share this information so more users know about Taskbar Overlay.