Getting smooth gameplay isn’t just about picking the right graphics settings—it’s about knowing what your PC is doing moment to moment. That’s where an in-game on-screen display (OSD) overlay becomes incredibly useful. With the right overlay, you can see real-time stats like FPS, frametimes, CPU/GPU usage, temperatures, clocks, and memory load while you play. Instead of guessing why a game stutters or why performance dips in certain scenes, you get immediate feedback and can adjust with confidence.
Most of the best overlays in PC gaming rely on RivaTuner Statistics Server (RTSS). It’s a lightweight, low-overhead tool that hooks into games (DirectX, Vulkan, OpenGL) and draws the overlay on top of what you’re playing. RTSS is popular because it’s fast, flexible, and works alongside multiple monitoring and benchmarking tools that feed it sensor data.
This guide breaks down two practical ways to set up RTSS-powered overlays:
1) Using MSI Afterburner with RTSS for an easy, reliable overlay focused on hardware monitoring
2) Using CapFrameX with RTSS for more benchmark-focused overlay options and expanded metrics
By the end, you’ll know what to install, how to enable the overlay, how to choose the most useful stats for your needs, and how these tools work together for accurate performance monitoring.
Prerequisites: What you need to install first
RTSS is the overlay “renderer,” but it doesn’t generate most of the data by itself. Think of RTSS as the display layer, while other apps act as the control panel that chooses what gets shown.
1) RivaTuner Statistics Server (RTSS)
RTSS is the core piece. It’s the component that actually draws the overlay in-game and is designed to stay lightweight even while displaying lots of telemetry. It was created by Alexey Nicolaychuk (known as “Unwinder”) and originally appeared as a companion tool for PC performance and overclocking workflows before becoming the backbone of many modern overlay setups.
Once RTSS is installed, open it from the Windows system tray and make sure the “Show On-Screen Display” option is toggled ON. If this is OFF, other tools can be configured correctly and still show nothing in-game—so this is a key checkbox to verify early.
A practical note: it’s generally better to install RTSS together with MSI Afterburner instead of using RTSS alone, because Afterburner not only helps you build the overlay easily, it also adds useful GPU tuning features.
2) MSI Afterburner (recommended starting point)
MSI Afterburner is widely used because it plugs directly into RTSS and makes it simple to choose exactly which stats appear in your overlay. It supports NVIDIA, AMD, and Intel GPUs and goes beyond overlays with options like fan control, voltage controls (where supported), and general GPU tuning.
During installation, make sure RTSS is included (there’s typically a checkbox for it). If RTSS isn’t installed and running, Afterburner won’t be able to display an overlay—Afterburner selects and formats the metrics, while RTSS actually renders them in-game.
3) CapFrameX (for deeper benchmarking overlays)
If your main goal is benchmarking and performance analysis, CapFrameX is a strong choice. It still relies on RTSS for overlay display, but it offers a more benchmark-oriented approach, including the ability to work alongside captured runs and live statistics. In CapFrameX, the Overlay section controls what it sends to RTSS and how the overlay is arranged, which is especially valuable if you want consistency across repeated test runs.
4) HWiNFO64 (for advanced sensors and deeper telemetry)
For the most complete hardware sensor coverage, HWiNFO64 is often the missing piece. It can expose additional sensors and flags that aren’t always available through Afterburner alone, such as specialized temperature readings, voltages, and throttle indicators depending on your platform.
If you want other overlay modules to read HWiNFO64 data, you’ll need to enable Shared Memory Support inside HWiNFO64:
– Launch HWiNFO64 in Sensors-only mode
– Open the sensor configuration (gear icon)
– Go into the main settings area and enable Shared Memory Support
One important limitation: in the free version, Shared Memory Support must be re-enabled periodically (about every 12 hours), so if your overlay suddenly loses certain sensor readouts, that’s one of the first things to double-check.
How to set up an RTSS overlay using MSI Afterburner
If you want a straightforward, reliable overlay that covers the essentials—FPS, frametime, CPU/GPU usage, temperatures, clocks, and memory—MSI Afterburner is the easiest place to start. The workflow is simple: Afterburner chooses the metrics, RTSS displays them in-game.
Step 1: Open Afterburner’s Monitoring settings
Launch MSI Afterburner and open Settings (the button placement can vary by skin), then go to the Monitoring tab. You can also use the Ctrl+S shortcut. This is where Afterburner lists all available sensors and performance metrics.
Step 2: Choose which metrics appear in the on-screen display
Scroll through the list and tick the sensors you want. For each one you want visible in-game, enable the option “Show in On-Screen Display.”
You can usually choose whether each metric appears as:
– Text only (clean and compact)
– Graph only (useful for spotting spikes)
– Both (more detail, but can get busy)
A solid “starter overlay” for most games includes:
– Framerate (FPS)
– Frametime (to spot stutter and uneven pacing)
– GPU usage and GPU temperature
– CPU usage and CPU temperature
– VRAM usage
– System RAM usage
Step 3: Set a hotkey to toggle the overlay
Go to Afterburner’s On-Screen Display tab and assign a key for “Toggle On-Screen Display.” This is useful when you want the overlay available for testing but not always visible during normal play.
At this point, as long as RTSS is installed, running, and “Show On-Screen Display” is enabled, your chosen stats should appear when a game launches.
If you want, paste the remaining portion of your original article (it cuts off at “Confirm that RTSS is…”) and I’ll rewrite the rest in the same engaging, search-optimized style while keeping the original intent intact.If you want an in-game performance overlay that shows FPS, frametimes, temperatures, usage, and other hardware sensor data, you don’t need anything complicated to get started. With MSI Afterburner and RivaTuner Statistics Server (RTSS), you can build a clean On-Screen Display (OSD) that launches with Windows and is ready whenever you boot a game—just confirm RTSS is running by checking for its icon in the Windows System Tray before you start playing.
This built-in approach is fast and flexible, and it’s ideal if you only want to display the exact stats you care about without relying on extra skins or layouts. You can keep it minimal (FPS and frametime) or expand it into a full diagnostics view with CPU/GPU utilization, temperatures, clocks, power, and more.
Making your overlay look better with RTSS templates
Customizing an overlay from scratch in Afterburner works great, but it can take time to get a polished look. If you’d rather start with a ready-made layout, RTSS includes pre-configured overlay templates you can load instantly. These templates are designed to present key performance metrics in a clean, readable format without manually placing and formatting every sensor.
Here’s how to use RTSS’s built-in Overlay Editor and load a template:
1) Enable the Overlay Editor plugin in RTSS
Open RTSS, click Setup, switch to the Plugins tab, then enable OverlayEditor.dll. After that, double-click OverlayEditor.dll to launch the editor.
2) Load an overlay layout file (.ovl)
Inside the Overlay Editor, go to Layouts, choose Load, then select one of the .ovl template files located in your RTSS installation folder under:
PluginsClientOverlays
Once loaded, the template is essentially “ready to run” and will display a structured set of stats without extra setup beyond choosing which sensors you want visible.
Optional: add a readable background for clarity
If you want a transparent dark background behind the text (helpful in bright scenes), enable the On-Screen Display fill option in RTSS settings. This makes the overlay much easier to read during gameplay without needing giant fonts or extreme colors.
Taking it further with benchmark-style overlays (TroyMetrics)
If you’re doing serious benchmarking, performance testing, or content creation, a dedicated benchmark overlay pack can be a major upgrade. The TroyMetrics Benchmark Overlays are built for richer telemetry and clearer visualization, going beyond basic FPS and temperatures.
What makes these overlays stand out:
– A CPU utilization display that adapts automatically across 4 to 24 cores, so it stays readable even on high-core-count processors
– Real-time latency monitoring, including NVIDIA Reflex Low Latency and PresentMon-based render/PC latency readouts
– Frametime graphs and stutter detection to help you “see” smoothness problems instantly
– Thermal throttle detection using HWiNFO64 sensor data
– A power detector module for supported GPUs that can expose detailed power delivery information
– Multiple presets, color variants, and display optimizations so you can pick a style that fits your setup
These overlays are frequently updated and designed for high-information displays that are especially useful when comparing settings, drivers, hardware, or game updates.
Building custom overlays with CapFrameX (RTSS-powered)
CapFrameX is widely used for frametime capture and performance analysis, but it also includes a powerful overlay builder that displays real-time metrics in-game. It uses RTSS as the rendering backend, so you get dependable overlay performance plus a highly configurable layout system.
How it works: CapFrameX lets you select the metrics, organize them into logical groups, and control visual formatting—then RTSS draws the final overlay on top of your game.
Inside CapFrameX’s Overlay tab, you’ll find:
– A large list of overlay items (FPS, frametimes, hardware info, sensor values, and more) that you can reorder and group however you like
– Three separate overlay profiles you can configure independently, making it easy to switch between layouts
– Controls for colors, formatting, group names, and separators to improve readability
– Hotkey settings for turning the overlay on/off, switching profiles, adjusting refresh behavior, and resetting metrics
Fine-tuning what shows up on-screen
CapFrameX gives you very granular control over both the content and the layout:
– Overlay items list: enable/disable metrics, drag-and-drop to rearrange, and group related entries so they appear on the same line (for example, keeping GPU metrics together and separate from CPU or RAM)
– Colors, limits, and formatting: set text colors and threshold-based changes (such as turning GPU temperature red above a chosen limit), plus tweak text size and presentation so it’s readable at a glance
– Group names and separators: add visual spacing between categories like CPU, GPU, VRAM, and RAM to reduce clutter when you’re monitoring lots of stats
Switching between multiple overlay profiles
One of the most useful CapFrameX features is its three-profile system, which lets you keep different overlays ready for different situations:
– A benchmarking profile with lots of metrics and graphs for testing and comparisons
– A gaming profile with only the essentials (like FPS and frametime) to minimize distraction
– A streaming profile organized for viewers, focusing on the stats that make sense on camera
These overlay profiles are stored as JSON configuration files in:
%APPDATA%CapFrameXConfiguration
The result is a flexible overlay setup that can be as lightweight or as data-rich as you need—perfect whether you’re casually checking performance, troubleshooting stutters, or running repeatable benchmarks.If you want to keep an eye on your PC’s performance while gaming without turning your screen into a wall of numbers, a well-tuned CapFrameX + RTSS overlay is one of the best solutions. Done right, it gives you real-time insight into framerate, frametimes, temperatures, and usage while staying small, readable, and out of the way.
Where CapFrameX overlay templates are stored
CapFrameX overlay layouts are saved as .json configuration files. You’ll find them in the CapFrameX configuration folder located at:
%APPDATA%CapFrameXConfiguration
Knowing this location is useful because it lets you back up your overlay setup, quickly swap layouts, or drop in templates shared by other users.
How to import and export CapFrameX overlay templates
One of the fastest ways to build a great overlay (especially if you care about benchmarking) is to start from a pre-made template and then customize it to match your system. CapFrameX makes this simple because overlays are just .json files.
A smooth workflow looks like this:
1) Save or download a .json overlay configuration file that matches your goals (for example, a template designed for your CPU/GPU platform or a benchmarking-focused layout).
2) Move that .json file into the CapFrameX configuration folder (%APPDATA%CapFrameXConfiguration).
3) Restart CapFrameX so it detects the new configuration.
4) Switch to the appropriate overlay profile index in CapFrameX (for example, Profile 1).
5) Fine-tune labels, group names, and colors so the overlay matches your exact hardware. If the template was built for a different GPU, you can rename a group like “RTX 3070” to “RTX 4090” so the labeling and color logic stay consistent.
This approach saves time, reduces trial-and-error, and gives you a proven layout you can tweak instead of building everything from scratch.
Advanced CapFrameX overlay options worth using
Newer CapFrameX versions add extra control that’s especially helpful if you want minimal overlay clutter or if you’re trying to avoid overlapping a game’s HUD.
Custom overlay positioning (independent of RTSS default)
You can place the CapFrameX overlay where you want on-screen, even if you’re already using RTSS tools like OverlayEditor or you need to keep clear of minimaps, health bars, or crosshair elements.
Separate overlay hotkey control
CapFrameX can use its own overlay toggle hotkey rather than relying only on the global RTSS hotkey. That means you can hide CapFrameX’s benchmarking stats when you don’t need them, while keeping other RTSS overlays visible.
Why templates are a great starting point for benchmarking overlays
You can absolutely build a CapFrameX overlay from scratch, but templates are usually the smarter move. A good template already includes logical grouping, sensible formatting, and the key stats people typically use for performance analysis (like fps, 1% lows, frametime behavior, GPU utilization, CPU load, and temperatures). From there, you only need to adjust what matters for your games and your hardware.
Overlay best practices for minimal clutter and maximum usefulness
Keep it clean and readable
The best gaming performance overlay is the one you can interpret instantly. If it blocks gameplay or forces you to squint, it’s not doing its job. Prioritize the handful of metrics you actually use, then adjust font size, opacity, and placement so your overlay stays visible without distracting you.
Use multiple profiles for different situations
Instead of trying to make one overlay do everything, create a few targeted profiles and switch depending on what you’re doing:
– Benchmarking profile: more detailed (frametimes, utilization, temps, clocks, power).
– Gaming profile: lightweight (fps plus core temperatures, maybe GPU usage).
– Streaming/recording profile: minimal or off, to keep footage clean.
Reduce conflicts with other overlays
RTSS-based overlays can clash with other overlay injectors. If things get weird (missing stats, overlay not showing, instability), temporarily disable overlays from other apps and retest. This alone fixes many issues.
Watch for performance overhead
RTSS and CapFrameX are generally lightweight, but overlay load can add up if you display a lot of sensors at very high refresh rates. If you notice new stutter after enabling an overlay, reduce the number of metrics, lower sensor polling frequency, or simplify the layout. NVIDIA’s power percentage sensor is a common trouble spot and may cause stuttering on some systems when queried frequently.
Troubleshooting common overlay problems
Overlay doesn’t appear in-game
This usually comes down to RTSS not running or not hooking properly.
– Confirm RTSS is running (system tray).
– In RTSS, try changing Application Detection Level (Medium or High can work better than Low in some games).
– Some anti-cheat protected games block overlays. Switching between fullscreen and borderless, or changing the graphics API, can sometimes help, but isn’t guaranteed.
Metrics are missing or show incorrect values
If the overlay is there but the data is wrong:
– In CapFrameX, make sure the correct game process is detected/selected so it knows where to pull metrics from.
– If you’re using Afterburner/RTSS sensor sources, confirm the desired metrics are enabled and set to display in the on-screen display.
– Disable other overlays temporarily to rule out interference.
Overlay flickers, lags, renders incorrectly, or causes crashes
Common fixes include:
– Lower the RTSS OSD refresh rate to reduce flicker and instability.
– Update GPU drivers, and if problems persist, try a clean driver reinstall.
– In RTSS settings, enabling Microsoft Detours API hooking can improve stability in certain games, especially when frame generation features are involved.
If nothing works: do a clean reinstall
As a last resort, fully uninstall RTSS and related overlay tools, remove leftover folders, reboot, then install fresh versions from trusted sources. Corrupted configs and mismatched builds can cause persistent overlay issues that only a clean reinstall resolves.
Final takeaway
A good RTSS overlay, powered by CapFrameX templates and smart layout choices, makes PC performance monitoring feel effortless. You’ll spot bottlenecks faster, confirm whether a settings change actually helped, and troubleshoot stutters or drops with real data instead of guesswork—all while keeping on-screen clutter to a minimum. Once you dial in a clean gaming profile and a more detailed benchmarking profile, switching between “play” and “analyze” becomes quick and painless.
