Rivatuner Statistics Server Changelog

What's new in Rivatuner Statistics Server 7.3.5 Beta 5

Sep 13, 2023

Ported to VC++ 2022 compiler. Please take a note that due to this change RivaTuner Statistics Server will no longer be able to start under Windows XP. Please stay on the previous versions of the product if you need this OS support
Please take a note that size of mandatory VC++ 2022 runtime redistributables roughly doubled comparing to the previously used VC++ 2008 redistributables, and we’d like to avoid providing overblown application distributive, drastically increased in size due to bundling newer and much heavier VC++ redistributables with it. To deal with this issue we provide our own original tiny web installer for VC++ redistributables, which allowed decreasing the size of final application distributive drastically even comparing to the previous VC++ 2008 based version. Please take a note that install time can be increased slightly due to downloading VC++ 2022 runtimes redistributables on the fly during installation. If you install RivaTuner Statistics Server offline, you can always deploy required VC++ 2022 distributives later with web installer by launching .RedistVCRedistDeploy.bat
Fixed issue in asynchronous skin scaling implementation, which could cause deadlocked RTSS.exe to stay in memory after closing application with [x] button from skinned GUI when skin scaling was enabled
Now uninstaller removes configuration files for OverlayEditor, HotkeyHandler and DesktopOverlayHost when you choose clean uninstallation mode. Please take a note that your own overlay layouts stored inside .PluginsClientOverlays folder will never be removed during uninstallation by design
Now RivaTuner Statistics Server ignores its own process and DesktopOverlayHost in screen and videocapture requests. So you no longer see unwanted screenshots or videos captured from OverlayEditor's or DesktopOverlayHost's 3D windows when you open them simultaneously with other 3D applications and initiate screen or video capture
Improved hypertext parser:
Image loading <LI> hypertext tag handler has been improved to allow loading embedded images from external folders
Now hypertext parser supports application specific embedded images. You may use this feature to display game specific logos in your overlay layouts. Sample.ovl layout included into distributive demonstrates this technique by displaying game specific logos for Escape From Tarkov, Forza Horizon 5 and Ratchet and Clank : Rift Apart
Now hypertext parser accepts both ANSI and UTF-8 encoded degree Celsius symbol
Improved OverlayEditor plugin:
Fixed keyboard based layer position adjustment when “Snap to grid” option is disabled
Fixed buffer overrun in OverlayEditor's GUI, causing it to crash when total text length displayed in "Cell" column of "Text table properties" window was longer than 260 symbols
Fixed status bar panes and hypertext debugger panel rendering for high DPI scaling modes
Now OverlayEditor supports saving overlay layouts to or loading overlay layouts from external folders. To allow you to differentiate local (i.e. stored inside .PluginsClientOverlays) and external layouts, local layouts will be displayed as naked filename only in editor's window caption (e.g. "Overlay editor - sample.ovl"), while external layouts will be displayed with full filepath
Now OverlayEditor supports context highlighting for text file embedding <F=textfile.txt> hypertext tag. Visual tag browser displayed when you type in <> in hypertext field also support inserting <F> tag
OverlayEditor is no longer rendering the very first frame with no sensor data displayed, now it is always rendering the first frame after polling all data sources
%CPUShort% macro is additionally packing Ryzen CPU names now. "Ryzen N" name is packed to "RN", and "Ryzen Threadripper" is packed to "TR" with this macro
Added conditional layers support. This powerful feature allows you to add programmability to your overlays and make them look different depending on some conditions, which you can program yourself. For example, you may create differently looking overlay on AMD and NVIDIA GPUs, you may create different representation of CPU usage bars depending on logical CPU count, add special layers displaying thermal alerts when either CPU or GPU is overheating, add layers visible depending on PTT-styled keyboard polling and so on. Conditional layers support is based on two key components:
Seriously improved correction formula parser in data source settings window, which is allowing you to program complex logical conditions and create so called boolean data sources, which report true (1) or false (0) depending on condition you define:
Relational operators support: <,>,<=,>=,== and !=. Result is boolean true (1) or false (0). For example, you may define boolean data source called IsGpuOverheating with correction formula “GPU1 temperature” >= 80, which will return 1 when GPU temperature is above or equal 80C, otherwise it will return 0
Logical operators support: ||, &&, !. Result is boolean true (1) or false (0). Logical operators allow you to combine multiple conditions, for example you may define boolean data source called IsGpuFanFail with correction formula (“GPU1 temperature” >= 80) && (“GPU1 fan tachometer” == 0), which will return 1 when GPU fan is not spinning AND temperature is critical (so it is not an idle fan stop case)
Bitwise operators support: &, |, ^, ~, << and >>. Please take a note that ^ was used for power operator before, however we see no practical use for power operators in correction formulas so it is no longer supported. ^ is used for bitwise XOR operator now
Ternary conditional operator support: condition ? expression1 : expression2. Result is expression1 if condition is true, otherwise it is expression2. Please take a note that Basic-styled syntax for ternary conditional operator syntax is also supported, so you can also use alternate if(condition, expression1, expression2) syntax depending on your preferences
Hexadecimal const values support. C-styled syntax with 0x prefix is supported, for example x+10 formula can be also represented as x+0xa
New cpuvendor, gpuvendor and cpucount variables support allow you to check CPU/GPU vendor identifiers or logical CPU count and use it in your overlay. For example, you may define IsNVIDIAGpu boolean data source and set correction formula to gpuvendor == 0x10de, then use it to display NVIDIA logo in your overlay only when NVIDIA GPU is installed on end user’s PC. Modified sample.ovl overlay layout demonstrates this technique to display AMD/Intel CPU logos depending on CPU vendor id and use different CPU usage bars layouts depending on logical CPU count
New rtssflags variable support allows you to check some global RTSS flags. It allows you to check if framerate limiter, video capture or benchmark mode is currently active. For example, you may define boolean data source called IsBenchmarkActive and set correction formula to (rtssflags & 0x100) != 0 to check state of benchmark mode activity bit
New validate(expression) function returns boolean true (1) when expression result is valid, otherwise it returns 0. For example, you may use it to check if some data source if physically supported on your system (unsupported values are invalid and reported as N/A). If you’re importing a data source from external provider, e.g. HwInfo, data can be invalid and reported as N/A when provider application is not running, so you may also effectively use validate() function to check if data is currently available. This function is useful when you combine it with ternary conditional operator, for example you may define formula validate(x) ? x : 0 for a data source importing data from HwInfo to make sensor report 0 when HwInfo is not running
New key(vkcode) functions allows to poll keyboard and return key press counter and current key up/down state bit. Please take a note that OverlayEditor uses new dedicated HotkeyHandler’s interface to access its low-latency keyboard polling status, so HotkeyHandler must be also active for this function to work. For example, you may define boolean data source called IsKeyDown and set correction formula to (key(0x41) & 0x80000000) != 0 to report 1 when keyboard key ‘A’ is down, then use it to apply PTT-styled visibility to show some specific layer. Alternately, you may define boolean data source called IsKeyToggled and set correction formula to (key(0x41) & 1) != 0 to check bit 0 of key press counter, which is incremented each time you press it. This way you can effectively implement some layer visibility toggle depending of this pre-programmed key in your overlay
New “Visibility source” setting in layer properties allows you to use one of boolean data sources defined in your overlay and representing some logical condition to show or hide the layer depending on it. If there is no binding in “Visibility source” setting, the layer will be always visible as before. Otherwise it will be visible only when visibility source reports a value different from zero
Added <IF>/<ELSE> and <SWITCH>/<CASE> hypertext extension tags support. Power users may embed these extension tags directly into hypertext instead of “Visibility source” setting to make some parts of layer visible depending on some condition. Please take a note that nested conditional blocks are not supported, so new <IF> tag always closes the previous open conditional block or immediately opens new one. Also, more complex expressions are not allowed into hypertext too, you can only use boolean data sources there. The only exception is ! (NOT) symbol, which is allowing you to invert value reported by boolean data source. Also, please take a note that <IF>/<ELSE>/<SWITCH>/<CASE> tags are extension tags parsed at OverlayEditor plugin level. They are not native hypertext tags, so you cannot use them to format hypertext inside external applications like CapFrameX or AIDA
Added PresentMon data provider. Now presentation related metrics from Intel PresentMon (including GPU busy, introduced in PresentMon 1.9.0) can be displayed directly in OverlayEditor’s layouts:
Added helper PresentMonDataProvider.exe application, which localizes all PresentMon interoperability in a separate process. PresentMonDataProvider supports PresentMon data streaming either from modern independently installable PresentMon service (downloadable from https://game.intel.com/story/intel-presentmon/) or from legacy PresentMon console application, bundled with the plugin. Please take a note that modern PresentMon service provides additional CPU/GPU telemetry, so this data is not available in OverlayEditor’s PresentMon data provider if you don’t install the service and stream it from legacy console PresentMon
Please take a note that PresentMon reports data with noticeable time lag, which varies from 0.5 to 2.5 seconds on our hi-end test system. We added our own msReportingLag to PresentMon data provider, so you may see it in your overlay layouts. Lag is just a part of problem, the worst thing is that the lag is not static due to batching streamed frames inside PresentMon (which means that it may collect a few frames then stream them all at once). So, if you try to render PresentMon's frametime graph in realtime using streamed data as soon as you receive it, graph scrolling will be extremely jerky due to batching. However, it is still possible to implement smooth scrolling of PresentMon's frametimes with a simple trick, if you apply some fixed delay to it. Delay must be large enough to compensate the maximum PresentMon's reporting lag. We selected fixed 3000ms delay in our implementation, which allows smooth scrolling. Delay is not hardcoded, it is defined by PM_DisplayDelay overlay environment variable (can be edited in Layouts -> Edit -> Environment variables)
Added new built-in overlay layouts demonstrating PresentMon integration functionality and displaying native realtime RivaTuner Statistics Server’s frametime graph on top and overlapped PresentMon’s frametime and GPU busy graphs below. Most of reviewers prefer to see the frametime graph displayed on per-frame scale, as it is the only real way to diagnose and see single frame stutters. However, native Intel's PresentMon overlay displays it on averaged time scale. So to allow you to compare apples to apples we included two different versions of overlay layouts for PresentMon in RivaTuner Statistics Server distributive: presentmon_frame_scale.ovl and presentmon_time_scale.ovl. presentmon_frame_scale.ovl displays PresentMon't frametimes on per-frame scale, similar to native RivaTuner Statistics Server’s frametime graph. presentmon_time_scale.ovl displays PresentMon's frametimes on fixed time scale, defined by user adjustable overlay refresh period (33ms by default). Averaging window for this overlay layout is adjustable via environment PM_AveragingWindow variable and it is set to double refresh period (66ms) by default. Both layouts display PresentMon's data with fixed 3000ms display delay to allow smooth scrolling
Both built-in PresentMon based overlay layouts use new conditional layers functionality to display dynamic “Limited by CPU/GPU” bottleneck indicator. The indicator is based on boolean IsGpuLimited data source applied to PresentMon’s frametime and GPU busy streams and defined as (msGpuActive / msBetweenPresents) >= 0.75. In ideal GPU limited case this ratio should be as close to 1 as it is possible, but in reality there is always some CPU overhead so the threshold was reduced to 0.75 to take overhead into account. Please don’t forget that you can always edit built-in layout and increase the ratio inside IsGpuLimited data source’s formula, if you find the threshold too low
Now OverlayEditor supports environment variables for overlay layout. The variables can be changed in Layouts -> Edit -> Environment variables field. Currently environment variables are used to tune advanced properties of PresentMon data provider. Power users may also use environment variables during development of complex overlay layouts with hardware dependent conditional layers (e.g. sample.ovl, which is displaying Intel or AMD logo depending on CPU vendor). In such usage scenario you may use overlay environment variables to emulate different hardware and test your overlay look on it (e.g. set environment variables to "cpuvendor=0x1022;cpucount=8;gpuvendor=0x1002" to emulate a system with 8 thread AMD CPU and AMD/ATI GPU on a PC with Intel CPU and NVIDIA GPU)
Minimum refresh period for overlay layout is no longer limited by 100ms. Now you can decrease it down to 16ms. Please take a note that such low refresh period is intended to be used with PresentMon's data sources only. Use it with caution and avoid defining such low refresh period values for overlays using other types sources, which poll hardware on each refresh period and may decrease system performance due to such high polling rate
Improved OverlayEditor’s data sources polling architecture. Now each data source can be polled asynchronically with own refresh period. This feature is currently reserved for new PresentMon’s data sources only, which can be polled and updated with independent refresh period. New PM_RefreshPeriod environment variable defines asynchronous refresh period for all PresentMon’s data sources at once. If PM_RefreshPeriod is not defined or set to 0 in environment variables, PresentMon's data sources will be also polled synchronously with the rest data sources
Added power user oriented config file switch allowing using idle based rendering loop for OverlayEditor’s window instead of default timer based rendering loop
Improved HotkeyHandler plugin:
Added asynchronous keyboard status polling interface for interoperability with new OverlayEditor plugin
Bundled DesktopOverlayHost tool has been upgraded to v1.3.3:
DesktopOverlayHost is now compiled as UIAccess process, which allows it to be displayed on top of most of modern fullscreen applications similar to xbox gamebar gadgets. You may use it to display mirrored overlay copy on top of applications like Destiny 2 and CSGO, which do not allow traditional hook based overlay rendering. Please take a note that Microsoft is allowing UIAccess window to be displayed on top of normal windows (including fullscreen game applications) only when the process is installed in secure location (i.e. Program files and subfolders). So you won't be able to use UIAccess topmost rendering functionality if you install RivaTuner Statistics Server inside some custom location (e.g. D:ApplicationsRTSS)
Added tiny DesktopOverlayHostLoader.exe companion process. UIAccess processes cannot be launched by Windows task scheduler, so companion loader process is necessary to start DesktopOverlayHost at Windows startup
Added power user oriented config file switch allowing enabling flip model for DesktopOverlayHost’s Direct3D11 rendering backend
ReShade compatibility related D3D1xDevicePriority setting has been reverted to select old ascending D3D1x device selection priority by default. So it is no longer necessary to change this setting to unlock overlay support in D3D10 applications
Slightly changed Vulkan layer to improve conformance to Vulkan specs
Added experimental support for "Beta : Use Unicode UTF-8 for global language support" option enabled in administrative regional OS settings. Now each localization description file contains additional "Codepage" field, defining runtime ANSI to UTF8 conversion rule for selected language pack
Seriously revamped German localization by Klaus Grosser
Added target process filtering support for debug logging system
Added On-Screen Display profile for The Texas Chainsaw Massacre and common technique aimed to improve stability in future applications using similar behaviors
Updated profiles list

New in Rivatuner Statistics Server 7.3.4 (Apr 3, 2023)

Improved hook engine:
Added WinUI3 runtime libraries to injection ignore triggers list
Added 64-bit VK Play overlay library to the list of trigger modules for delayed injection engine
Now injection ignore triggers list can specify modules, dynamically loaded by hooked application during runtime. This feature can be used to the exclude applications using delayed load of WPF/WinUI3 runtimes (e.g. Microsoft Power Toys)
Altered environment variable based compatibility manifesting mechanism. Initially the mechanism was intended to allow game developers to disable RTSS overlay support at game level in case of detecting some fundamental incompatibilities, however due to some weird reason it was globally used inside recent versions of VK Play game launcher to lock overlay support in any games launched by it. Such usage pattern is now detected and no longer allowed, now compatibility manifesting mechanism is ignoring VK Play game launcher's attempts to use it to disable hooking
Various compatibility improvements:
Various Direct3D12 overlay renderer cleanups for both D3D11on12 and native Direct3D12 rendering implementations aimed to improve compatibility with Direct3D12 debug layer. Please take a note that default D3D11on12 based Direct3D12 overlay renderer is now compatible with debug layer as is, but optional native Direct3D12 overlay renderer hooks retail command queue only by default due to performance reasons, and debug layer expects wrapped debug command queue to be used by Direct3D12 application during debugging. So debug layer will throw OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR exception if you try to use overlay configured to use native Direct3D12 renderer. If you absolutely need to debug your Direct3D12 application with RivaTuner Statistics Server overlay enabled in such environment, you may get rid of this debug layer exception with HookDirect3D12DebugLayer profile switch, which will enable wrapped debug command queue hooking
Improved compatibility with applications using multiple in-game overlays (e.g. both Steam and Epic Games Overlay) and using late injection for one of them (e.g. Rogue Company, which is injecting Steam overlay hooks at startup but using late Epic Games Overlay hooks injection during matchmaking)
Slightly reworked Epic Games Overlay compatibility strategy. Now RivaTuner Statistics Server disables IDXGISwapChain1::Present1 hooking when Epic Games Overlay hook module is detected instead of ignoring nested IDXGISwapChain1::Present1 -> IDXGISwapChain::Present hook calls. Compatibility strategy is disabled by default now, considering that it was recently patched from Epic Games Overlay side
Improved compatibility with Direct3D12 applications using multiple Direct3D12 swapchains (e.g. Prepar3D v5, which is using separate swapchains for main game window and vehicle select window)
Improved compatibility with Direct3D9 applications, which never use Direct3D9 device’s implicit swapchain and present frames from additional swapchain only (e.g. Brawlhalla or Don’t Starve Together)
Improved compatibility with OpenGL3+ applications, using overly restrictive debug checks in retail products and stopping rendering on any OpenGL errors (e.g. Defold Editor). Now RivaTuner Statistics Server uses different strategy instead of internal error interception for overlay renderer fallback from in-context rendering to separate context rendering
OpenGL pixel unpack alignment state is now restored properly by OpenGL overlay renderer to improve compatibility with old builds of Ryujinx
Improved compatibility with Vulkan applications, using multiple coexisting swapchains (e.g. Godot v4 editor)
Bumped version inside Vulkan layer manifest to improve compatibility with some Vulkan 1.2+ applicaitons (e.g. Ryujinx)
D3D1x device selection priority has been changed from ascending to discending to improve compatibility with ReShade 5.6, which creates dummy D3D10 device for D3D11 applications. Power users may select the previous ascending selection priority via profile if necessary
Improved compatibility with Vulkan applications, creating multiple dummy Vulkan devices on different GPUs during startup (e.g. Far Cry 3 with DXVK mod)
Frametime counter in shared memory is now buffered and it no longer updates dynamically during presenting the frame. Buffering is implemented to protect the counter from being asynchronously accessed by third party monitoring clients and prevent such client applications from reading incomplete frame timings
High application detection level is now restricted for Forza Horizon 5 via built-in application profile
Added power user oriented config file switch, allowing displaying 3D API (either abbreviated or full) in framerate counter displayed by "Show own statistics" option
Added new ScaleToFit application profile property. The property is intended to enable alternate offscreen overlay rendering mode and scale it to fit entire 3D application window while keeping original overlay proportions. New property is aimed to simplify the process of resizing overlay displayed via DesktopOverlayHost on small portable USB displays. Please take a note that the only supported form of scaling is stretching. Overlay shrinking is not supported
Added new environment variable based profile override mechanism, which is allowing the processes to override some application specific RTSS profile properties on the fly. New mechanism is aimed to allow DesktopOverlayHost to toggle new ScaleToFit profile property on the fly directly from executable and without physically altering the profile file
Slightly altered Direct3D9 and Direct3D1x blending setups for offscreen rendering mode to make final blending result look identical for offscreen rendering mode in Direct3D9 and Direct3D1x
Added optional power user oriented offscreen overlay rendering mode support for OpenGL applicaitons
Improved hypertext format:
Added new <FC> hypertext tag, allowing displaying total frame counter during benchmarking session
Added new <M> hypertext tag, allowing specifying independent margins for left, top, right and bottom edges of the layer. The tag supports both positive (inner) and negative (outer) margins adjustable in zoomed pixel units. Margins affect layer background fill area and layer content placement, you can use the margins to achieve layer border or shadow effects
Improved image embedding <I> hypertext tag syntax. Added optional tag parameter defining embedded image rotation angle
Improved bar embedding <B> hypertext tag syntax. Added optional tag parameter allowing drawing variable width bar border instead of filling the bar with the solid color
Added new <V> hypertext tag support for defining general purpose variables. Up to 256 general purpose integer variables can be defined in hypertext then referenced later as subsequent tag parameters. Additional "L" or "H" postfixes can be added to variables to extract low or high 16-bit integers from 32-bit integer variables
Improved hypertext parser:
Optimized dynamic colors attributes recalculation in hypertext parser for overlay layouts containing multiple graphs
Added shared memory access timeout to hypertext parser. Timeout is necessary to ensure that multiple simultaneously running 3D applications do not skip overlay updates when they try to access shared memory simultaneously (e.g. when scanline sync is enabled so multiple running 3D applications start rendering overlays synchronously)
Increased size of internal shared text buffer used to render performance profiler's and scanline sync debug info panels. Previously enabling both performance profiler's and scanline sync debug info panels simultaneously could cause buffer overflow on the systems with too long monitor name
Added integrated functions support to hypertext syntax. The following integrated functions are currently supported by hypertext parser:
$MAP function is intended for mapping the value ranges, e.g. for mapping [0;60] FPS range to [-90;90] degree rotation angle range in animated gauge indicator
$SPR function is intended for calculating animated sprite coordinates from specified sprite matrix and value range. Function result is packed in single 32-bit integer value, it can be stored to variable and independent coordinate components can be unpacked with previously mentioned "L" and "H" postfixes
Improved covering extent calculation for overlays containing some specific sequences of embedded bars and backspace symbols
Improved scanline sync implementation:
Added scanline sync support for non-native resolutions (e.g. DSR). This feature requires altering negative scanline index interpretation rule, now negative index is treated as offset from maximum visible scanline index instead of treating it as offset from VTotal before. Please keep it in mind and subtract vertical blanking interval from your target scanline index to get it positioned identically to the previous version
Altered <Alt> + framerate limit field clicking functionality. Previously it allowed setting framerate limit to the primary display refresh rate, now it is setting framerate limit to refresh rate of display containing RivaTuner Statistics Server window
Framerate limit is no longer displayed as blank field when using <Alt> + framerate limit field clicking functionality for some periodic refresh rate values, defined with arbitrary non-power-of-10 refresh rate denominator. Such periodic refresh rates are rounded to 3 decimal places
Added synchronous command queue flushing support (enabled by setting SyncFlush to 2) for Direct3D12 applications
Synchronous Vulkan command queue flushing is no longer enabled by default, now it is also engaged only when you explicitly request it by setting SyncFlush to 2
Name of target display device selected by SyncDisplay profile switch is also displayed in scanline sync debug info panel in addition to display device index
Improved OverlayEditor plugin:
Added Intel Arc GPUs support to internal HAL
Added extended temperature monitoring support for NVIDIA GPUs to internal HAL
Added core temperature sensor to internal HAL for legacy Overdrive 7 capable AMD GPUs (Fiji and older)
Added extended CPU temperature, power and clock monitoring support to internal HAL. Those data sources duplicate data provided by MSI Afterburner HAL and additionally provide bus clock, per-CCD temperature monitoring (Zen 2 or newer CPUs) and effective CPU clock monitoring. CPU monitoring functionality is provided by low-level RTCoreMini driver, bundled with the plugin. RTCoreMini is IOCTL compatible stripped down version of MSI Afterburner's RTCore driver, which lacks MMIO access functionality used for low-level GPU access on legacy graphics cards
Added effective core/memory clock sensors for NVIDIA GPUs to internal HAL. Unlike target clock, effective clock takes PLL resolution (e.g. physical clock generation step) and any forms of hardware clock slowdown/throttling (e.g. thermal) into account. Please take a note that in order to reflect throttling, effective clock sensors use averaged PLL clock counters during some period of time, so realtime effective clock changes are expected to be slightly lagged/delayed comparing to instantaneous target clock changes
Added PerfCap mask data source for NVIDIA GPUs. This data source duplicates combination of MSI Afterburner's original binary "Power limit", "Temperature limit", "Voltage limit" and "No load limit" monitoring graphs and allows displaying them natively in OverlayEditor
Added total board power monitoring support for AMD RADEON RX 7900 series graphics cards to internal HAL
Added special stub data source to internal HAL. This data source is not bound to any physical sensor so it doesn't consume any CPU time by polling hardware. You may use stub sources to implement some virtual sensors implemented purely via correction formulas and referencing other data sources only (e.g. total power consumption represented as "CPU power" + "GPU1 power" + fixed_delta)
Updated classic overlay layout, now it also displays VRAM temperature on supported systems
Updated classic and sample layouts to support CPU temperature and power readback from internal HAL
Now sample overlay layout displays thread usage bars for the first 16 threads instead of the first 8 threads before
Added new mini overlay layout. Please take a note that the second usage displayed in CPU column in this layout is max CPU thread usage, it is handy to detect games bottlenecked by signlethreaded performance
Rendering in overlay editor’s window is now paused when you open “Overlay data sources” window to let you to see real idle CPU and GPU sensor readings unaffected by editor’s window background rendering
Added alternate “Framerate history” and “Frametime history” data sources. Those data sources duplicate data provided by MSI Afterburner HAL. Unlike existing realtime “Framerate” and “Frametime” data sources, which are providing per-frame instantaneous framerate/frametime statistics independently for each 3D application, alternate data sources are sampled with overlay layout’s refresh period and reflect averaged framerate and maximum frametime per sampling period similar to MSI Afterburner. Similar to Afterburner, those data sources also cannot reflect independent statistics for multiple simultaneously running 3D applications and apply to foreground 3D application only
Added layer margins adjustment to layer setting dialog. Now you can specify independent margins for left, top, right and bottom edges of the layer and supports both positive (inner) and negative (outer) margins adjustable in zoomed pixel units. Margins affect layer background fill area and layer content placement, you can use the margins to achieve layer border or shadow effects
Added new xmin, xavg, xmax and swa variables support to data source's correction formulas. Now you may specify these variables to display minimum, average, maximum or sliding window average smoothed value for a data source if necessary. Please take a note that now you may also associate a hotkey in HotkeyHandler plugin for resetting collected minimum/average/maximum statistics
Now you may hold <Ctrl> while clicking <Add> button in data sources setup window to create a copy of selected data sources or additionally hold <Shift> to increment instance indices of copied sources if it is available. This feature can be used to simplify the process of cloning of multiple instances of similar data sources, e.g. Windows performance counters based usages for logical processors
CPU usage data sources in internal HAL have been switched to alternate implementation based on NtQuerySystemInformation(SystemProcessorIdleInformation), because traditional legacy idle time reporting in NtQuerySystemInformation(SystemProcessorPerformanceInformation) is broken in current Windows 11 22H2 builds
Added new Import and Export commands to Layouts menu and *.OVX overlay layout exchange file format support. Previously to share your overlay layouts with others you needed to pack and distribute all dependent files (e.g. embedded image and external test files for dynamic layers) with your *.OVL file, then user needed to extract those files to local .PluginsClientOverlay folder on his PC. New Import and Export commands are aimed to simplify this process. Export command will create special overlay layout exchange file (OVX), containing OVL and all dependent files (such as embedded image) used in your layout. OVX is the only file you need to share now. Import command will open OVX, extract all required dependent files from it and install them into .PluginsClientOverlay folder
Added settings for specifying fixed rotation angle in static image properties window
Added settings for specifying dynamic rotation angle in animated image properties window. This way you may easily implement animated gauge-styled indicators, e.g. define gauge arrow sprite and make it rotate in desired range depending on input range. Sample overlay layout included in distributive demonstrates this technique with animated framerate gauge indicator
Added settings for displaying layer border in layer properties window
Added SMART attributes monitoring and hard drive temperature monitoring support to internal HAL. The implementation is based on original MSI Afterburner's SMART plugin, but unlike original implementation which supports SMART attributes readback on IDE/SATA drives only, internal HAL's implementation also provides support for SMART attributes reading on NVMe devices (including dual-channel memory/controller temperature monitoring on new Samsung NVMe drives). Please take a note that SMART monitoring is disabled by default due to performance reasons, you may enable it in new internal HAL properties window
Added data provider properties accessible via "..." button next to selected provider in "Add data sources" window. Currently configurable properties are available for internal HAL only, you can enable SMART monitoring or disable low-level IO driver there if necessary
%VRAM% macro is now aligned to closest 0.5GB boundary
Added functions support to correction formula parser. The following functions are currently supported:
Unary format conversion functions int(x) and flt(x)
Unary rounding functions ceil(x), floor(x) and round(x)
Binary comparison functions min(x,y) and max(x,y)
Bit-testing function test(x,mask). You may use such bit-testing function to extract desired bits from bitmask, it is intended to be used in conjunction with new PerfCap mask data source to extract independent performance capping limits from it and display them as independent graphs
Now you may use integer output format specifier “%d” inside data source’s format field
Now hypertext editor field inside layer properties window supports context highlighting for native hypertext tags displaying some text info (e.g. <FR>, <API>, <EXE> etc). Now you may double click such highlighted tag or press "..." button to replace it with other tag or macro via popup macro/tag browser menu
Now hypertext editor field inside layer properties window displays helper popup tag or macro browser menu when you type in <> or %% sequence. This allows you to select desired tag or macro visually from it instead of typing it in manually
Added new "Snap to grid" option to "View" menu. Previously snap to grid mode was used by default, but you could individually position/resize layers in absolute pixels by holding <Shift> during layer movement/resizing. New option is allowing you to disable snap to grid globally. <Shift> key can still be used, but now it inverts global snap to grid mode for individual layers (i.e. it works as before for enabled "Snap to grid" mode and allows enabling snap to grid just for individual layers if global "Snap to grid" option is disabled)
Now you may hold <Ctrl> button pressed in "Overlay data sources" window to show correction formulas used by each data source inside "Values" column
Improved HotkeyHandler plugin:
Added new XOR modifier type to profile modifier hotkeys. You can use XOR modifier to toggle boolean profile properties
Altered common pictures / videos folders location detection way to minimize warnings triggered by enabled controlled folder access
Added new "Reset statistics" preset to overlay editor's hotkey. You may define such hotkey if you use new xmin, xavg, xmax or xswa variables in correction formulas to display statistics for any data sources and want to reset it
Bundled DesktopOverlayHost tool has been upgraded to v1.3.1. New version provides multiple changes and new features aimed to improve DesktopOverlayHost usability in multimonitor environment in general and in specific case of multimonitor environment when secondary mini-display is mounted inside the PC case and used to display RTSS overlay with DesktopOverlayHost:
Slightly reorganized DesktopOverlayHost properties window, "Start with windows" option was moved to properties from tray icon context menu
Now all changes you do inside the application’s properties are being applied to main window in real time, so you no longer need to close the properties when adjusting transparency or chroma key to see the result
Added optional Direct3D11 and OpenGL renderers, which can be used to bypass known architectural limitations of Direct3D9 desktop overlay renderer. Direct3D11 renderer is selected by default now, but you may select desired renderer in application properties
Added new “Scale overlay to fit entire window” option to application properties. New option is using RTSS profile control API and toggles new ScaleToFit property directly inside DesktopOverlayHost.exe profile. So now you may either render overlay inside DesktopOverlayHost as is, in its' natural size, or enable this new option to scale overlay to fit entire DesktopOverlayHost window area (which can be useful for manual overlay size finetuning if you plan to display DesktopOverlayHost window on small external display). When enable, it scales the overlay to keep original overlay proportions instead of just resizing it to whole window and possibly distorting it. Please keep in mind that only stretching is supported, overlay will be rendered in original size if you try to shrink it
Now you may click top left corner of DesktopOverlayHost borderless window to maximize it. Changing mouse cursor indicates target click area
Now you may use tray icon menu to move the window to any display and maximize it there. So all window location adjustments are done on the primary display, which is especially convenient when using DesktopOverlayHost with mini-display mounted inside the PC case
Now you may use '1'...'0' keys when DesktopOverlayHost window is focused to move it to displays 1..10 or 'W' to maximize it
Now you may use <Ctrl> + '1'...'0' keys when DesktopOverlayHost window is focused to resize window to display 1..10 resolution
Properties of DesktopOverlayHost window are also displayed on the primary display now, if you invoke the properties from application tray icon
Added new "Lock multimonitor window position” option to advanced properties. When this option is enabled DesktopOverlayHost locks the window position, tracks display mode change events and patches monitor relative position on monitor coordinate space changes. This allows keeping overlay displayed in expected position on the secondary monitor even when fullscreen game changes the primary monitor resolution (which may cause changes in secondary monitor coordinate spaces and may cause the windows displayed there to be moved without such special locking feature)
Added new "Show window always on top" option to properties window
Added new "Suspend rendering in idle" option to properties window. You may enable it to save some power when DesktopOverlayHost is displaying overlay on desktop and no other 3D applications are running. When new option is enabled, DesktopOverlayHost will reduce its' own framerate to 1 FPS in idle (i.e. when no other 3D applications are running or when DesktopOverlayHost is a foreground application) but restore the full 30 FPS framerate when you launch some 3D application and switch to it
It is no longer possible to launch multiple instances of DesktopOverlayHost. Now it will display properties of running application instance on attempt to launch the secondary instance of DesktopOverlayHost
Now DesktopOverlayHost's executable file is located in the root of RivaTuner Statistics Server’s installation folder, it is digitally signed and intaller adds shortcut to it to start menu. Please keep it and mind and ensure that you launch correct version of DesktopOverlayHost if you update RivaTuner Statistics Server without uninstalling the previous version, because in this case two copies of DesktopOverlayHost will be located inside your RivaTuner Statistics Server subfolders
Added profile caching system aimed to improve RivaTuner Statistics Server start time
Added process modules list dumping to debug system
Now you may press <F5> in RivaTuner Statistics Server's window to reread currently selected profile, if you modify it manually with some external text editor
Fixed issue causing “Start with Windows” option state to be reset after opening application properties then closing the application
Fixed issue causing overlay font to be invisible in some legacy 16-bit color exclusive fullscreen applications (e.g. Quake 3 : Arena in 16-bit display mode under Windows 10)
Fixed issue causing language icons to be displayed in wrong palette for some languages (German, Portuguese and Ukrainian) in "User Interface" tab
Improved compatibility with third party skins in “Layered with alpha” skin composition mode
Switched to alternate digital signature for hooks DLLs
Added On-Screen Display profile for Prepar3D v5
Added On-Screen Display profile for Brawlhalla
Added On-Screen Display profile for Don’t Starve Together
Added On-Screen Display profile for VK Play version of Atomic Heart
Added On-Screen Display profile for Ryujinx
Added On-Screen Display profile for Overwatch 2
Updated profiles list

New in Rivatuner Statistics Server 7.3.3 (Dec 3, 2021)

New in Rivatuner Statistics Server 7.3.2 (Nov 23, 2021)

Recently introduced Direct3D11 swapchain latching mode is no longer enabled by default, now it is profile based and applied in compatibility profiles only when it is really necessary (e.g. in Microsoft Flight Simulator 2020, which may simultaneously use multiple swapchains). Enabling it globally could cause the On-Screen Display to disappear on <Alt>+<Tab> in some games with bugged renderers, which leak swapchain during display mode switch
Fixed Windows XP/Vista compatibility regression, introduced in the previous version due to adding Windows 7+ specific in-process RAM usage performance counters
Fixed issue in video capture module, which could cause some 64-bit applications to crash when trying to capture video encoded with external VFW codecs
Improved compatibility with multithreaded Direct3D12 applications, which concurrently create new swapchains while presenting a frame on a swapchain from different thread (e.g. World of Warcraft)
Framerate limiter’s passive waiting mode, introduced in the previous version, is no longer power user oriented. Now it is available in GUI under compatibility properties, so you can enable passive waiting if you prefer reduced CPU load and power consumption or disable it if you prefer maximum framepacing precision
Various compatibility improvements in the hook engine:
Added hooking support for Microsoft DirectX 12 Agility SDK based Direct3D12 applications (e.g. Halo Infinite insider tech preview and possibly other future Direct3D 12 applications compiled with Agility). New DirectX 12 Agility model assumes that the game can be shipped with a local copy of Direct3D 12 runtimes, which can be newer than your system Direct3D12 runtimes. By default RivaTuner Statistics Server’s hook engine is configured to block injection into any custom Direct3D runtimes located outside OS system folder because such case is typical to Direct3D proxy libraries used in third party game mods, which are frequently fundamentally incompatible with overlays. So hooks were blocked on purpose in such environment, making overlay invisible. Running RivaTuner Statistics Server in such environment also reduced performance due to periodically repeating and failing overlay injection attempts. Previously this could be solved by creating application profile for such game with enabled “Custom Direct3D support”option, which is intended to allow injecting custom Direct3D runtimes located outside system OS folders.
New Agility compatible hooking path automatically addresses it in the following way:
Simplified form of “Custom Direct3D support” mode is now internally engaged by RivaTuner Statistics Server when Agility SDK based Direct3D12 application is detected. Full “Custom Direct3D support” mode functionality is overabundant and not necessary for Agility case. New Agility compatible hooking path is optional and can be disabled by power users at application profiles level for troubleshooting or performance testing
Added retry counter for reinjection attempts, aimed to minimize performance penalty for situations when Agility SDK based Direct3D12 application cannot be injected
DXGI swapchain hooks are now suspended during dynamic hook offsets initialization, this change is aimed to reduce risk of incompatibilities caused by enabling “Custom Direct3D support” profile in conjunction with application detection level set to “High” for Agility based Direct3D12 applications
Added debug/compatibility profile switch allowing disabling hook reinjection mode
Added debug/compatibility option allowing disabling hook integrity control mode and enabling hook entry point relocation
Changed unconditional injection delay handling approach. Now it overrides conditional trigger module based delay,
previously unconditional delay didn't affect the cases when conditional delay was triggered
D3D12 command queue hook is affected by delayed injection now, but the rest D3D12 swap chain creation hooks are still injected immediately and ignore any delays by default
All API hook handlers have been slightly refactored to allow switching between different API hooking implementations
Added new "Use Microsoft Detours API hooking" option, which is allowing RivaTuner Statistics Server to switch to Microsoft Detours API hooking library instead of own API hooking engine. This option doesn't help RivaTuner Statistics Server itself, but it may help to fix other third party applications which also hook 3D API calls and use vanilla Microsoft Detours for that (e.g. OBS 27.1.0 and higher). So you may try to enable it you're using RivaTuner Statistics Server with some third party overlay or videocapture software and it refuses to work
Added unified Direct3D12 command queue caching based algorithm for handling periodic swapchain recreation in some Blizzard games (e.g. Diablo 2 : Resurrected and World of Warcraft)
Improved On-Screen Display hypertext formatting implementation:
Fixed covering extent calculation for layers with embedded objects resized to layer extent
Improved dynamic tabbing implementation. Dynamic tabulation value is no longer global for whole hypertext, now each layer calculates it independently
Added sticky layer position tags. Sticky layers are intended for displaying latency markers for luminance sensor based systems similar to LDAT, which are expected to be displayed in a fixed position unaffected by On-Screen Display origin selection
Improved concept of cursor position placeholder layers. Hypertext is no longer being automatically appended with LF symbol when the last rendered symbol is a backspace. Such approach allows using cursor position placeholder layers to define exact desired position of text output for the next hypertext clients instead of defining position one line above it
Added new <RES> hypertext tag, allowing displaying framebuffer resolution in On-Screen Display
Added new <ARCH> hypertext tag, allowing displaying application architecture info (x64 or UWP) in On-Screen Display
Added new <API> hypertext tag, allowing displaying application 3D API info in On-Screen Display. This tag is quite similar to <APP> tag, but unlike existing tag it displays full 3D API name instead of abbreviated one (e.g. OpenGL instead of OGL)
Added new <TIME=format_string> hypertext tag, allowing displaying custom formatted system date/time in On-Screen Display
Added dynamic color formulas support for <C> hypertext tag
Added GUIDs to internal graph autoscaling cache implementation. GUIDs ensure that autoscaling is not applied to wrong graph when you switch between different OSD layouts containing different sets of displayed graphs
Added new <GRMIN> and <GRMAX> hypertext tags, aimed to display minimum and maximum limits of the last embedded graph. New tags are intended to be used in conjunction with autoscaling graphs to display their dynamic limits. Please pay attention to hypertext rendering Z order and ensure that you specify the tags after rendering target embedded graph to make them work as expected
Improved load image <LI> tag format. Now the tag parameter can be wrapped with quotation marks if the filename contains some reserved symbols (round brackets, triangle brackets and comma)
Improved SDK:
Improved RivaTuner Statistics Server host API:
Added helper PickColorEx API function, allowing the plugins to use extended version of host color picker dialog window. Extended version may display “>>” button, allowing the clients to implement some additional color adjustment functionality
Added helper GetColorPreview function, allowing the plugins to generate RGBA color preview in client specified image buffer
Improved shared memory layout:
Now each running 3D application entry contains current framebuffer resolution info. This feature is required to allow displaying foreground application resolution info in DesktopOverlayHost
Additional extended 32KB hypertext slot is now available to OSD client applications
Improved HotkeyHandler plugin:
Added workaround for internal DirectInput issue, which could cause hotkey handler to stop processing hotkeys correctly after locking/unlocking PC from keyboard with <Ctrl>+<Alt>+<Del> or <Win>+<L>. To bypass it the plugin is resetting hotkey handler state after lock screen transition now
Added optional RawInput based hotkey handler implementation
Improved OverlayEditor plugin:
Added layers list editor window. You can access it via “Edit list” command in “Layers” menu or via <Ctrl>+<Shift>+<L> keyboard shortcut to adjust layers Z-order visually with drag and drop or select desired layer
Added <Apply> button to <Layer properties> window. Now you can test your changes without closing the properties
Added sticky layer position options to <Layer properties> window
Added %Date% macro for embedding system date into hypertext
Added maximum CPU core load data source to HAL. Sample overlay is displaying maximum CPU core load history graph under per-core CPU load barchart graphs
Decreased timer resolution to improve editor’s framepacing
Introduced concept of dynamic color attributes, which brings MSI Afterburner's OSD alarm thresholds feature support natively to the plugin:
Any color attribute (e.g. layer text or background color) can be switched to dynamic mode by pressing ">>" button inside the color picker dialog or switched back to static color mode by pressing "<<" button
Dynamic mode is reflected by “D” letter displayed on top of color preview box
Dynamic colors can be linked with any data source visible to the plugin, can have up to 5 open or closed data source value ranges mapped to different colors
Dynamic colors can either select fixed color by range or blend colors for nearby ranges allowing implementing smooth gradients for dynamic color changes if necessary
Dynamic colors can be either calculated inside the plugin and applied to formatted hypertext as static color on the fly or you can optionally embed dynamic color formula into the hypertext layer. In this case embedded objects (e.g. graphs) can use this formula to recalculate colors independently for each displayed graph point
Added new %CPUShort% macro. This macro definition is similar to previously existing %CPU% macro, containing compacted CPU branding string, but %CPUShort% additionally strips CPU clock frequency info starting from @ symbol
Text table specific color attributes are now displayed in recent colors selection panel in color picker dialog
Text table line name and cell text can use special symbols now (e.g. newline n symbol)
Hypertext edit field in layer properties dialog is now multiline, so it is more convenient to work with complex layers (e.g. layers combining multiple embedded objects)
Fixed issue which could cause skipping some overlay refresh iterations
Added new keyboard shortcut to the overlay editor window. Now you may press <Ctrl>+<Shift>+<M> to apply layout master settings. The same can be done from menu: Layouts -> Edit -> Master settings
Now all embedded graphs are using buffered update approach instead of asynchronous update for each graph before. This change is aimed to eliminate risk of seeing short flickering when switching between different overlay layouts containing different sets of displayed graphs
Overlay layout timer is now reinitialized properly when switching between different overlay layouts with hotkeys
Sample overlay layout supplied with the plugin was designed as a technodemo, showing you as many complex overlay creation techniques as it is possible. Now the plugin includes two more built-in overlay layouts, which suit better for everyday usage:
Classic layout is close to classic native MSI Afterburner's layout. It combines traditional text table based sensors representation with frametime graph and contains the most frequently used and the most useful sensors including process specific ones
Benchmark layout is entirely focused on framerate/frametime monitoring. It displays autoscaling frametime graph and dynamic distribution of the slowest frames with highlighted 1% zone. Such representation gives better visual demonstration of 1% low framerate to beginners. Dynamic distribution of the slowest frames is also useful when you're altering percentile calculation related options
Improved hotkey handler plugin:
Added DirectInput initialization mutex, aimed to prevent possible deadlock in IDirectInputDevice8::Acquire during application start when it creates one more DirectInput device for FCAT overlay working in “latency marker” mode
Improved RTSSSharedMemorySample sample:
Fixed sample crash on the systems with more than 8 logical processors
Now the sample demonstrates new sticky layer position tags usage
Added new “latency marker” rendering mode for FCAT overlay. New mode is aimed to be used in conjunction with third party luminance sensor based input latency monitoring systems similar to LDAT. In this mode RivaTuner Statistics Server displays color latency event markers reflecting current input state when keyboard or mouse buttons are pressed or released. In this mode RivaTuner Statistics Server additionally stores high precision latency marker registration and latency marker presentation timestamps into shared memory and provides the timestamps to client applications. Client applications may use this data as a backend for input latency calculation in conjunction with additional data they receive from luminance sensor
Added new "Percentile buffer" option to general properties. New option allows switching between unlimited and rolling ring buffer modes for 1% low and 0.1% low metrics calculation. Unlimited mode is preferred if you manually start benchmarking session with a hotkey. Ring mode can be preferred if you permanently keep the benchmark mode enabled and want to see 1% and 0.1% low metrics reflecting just a few last seconds of gameplay
Slightly altered geometry batching implementation in On-Screen Display renderer. Previously RivaTuner Statistics Server internally represented On-Screen Display contents as a few uber batches, containing all On-Screen Display geometry grouped by primitive type (for example, the first batch containing triangles representing all On-Screen Display symbols, solid color bars, and embedded images and the second batch containing all lines used to render all graphs). Such batching provides optimal rendering performance and minimizes draw calls count and rendering pipeline state changes. With such implementation it was possible to render On-Screen Display contents in expected Z-order for the same type of graphics primitives (e.g. for text, images or solid color bars), but line primitives were always rendered on top of everything. New altered geometry batching implementation allows splitting uber batches on smaller batches, so it is now possible to render both lines and triangle primitives in expected Z-order. Please take a note that batches splitting mode is enabled by default, but power users may enable old uber batch rendering mode at profile level if necessary
Improved scanline sync implementation:
Now index of target display device for multimonitor systems is also displayed in scanline sync info panel
SyncDisplay profile switch, which is defining index of target display device for multimonitor systems, can be set to -1 now. In this case target display device will be selected automatically by monitor displaying 3D application's foreground window
Added power user oriented profile switch, allowing enabling HDR specific color space conversion for On-Screen Display in D3D11/D3D12 HDR applications. This profile switch can be used to correct On-Screen Display appearance when it looks too dim in scRGB HDR applications or oversaturated in HDR10 applications
D3D12 videocapture queue depth has been increased from 3 to 8 frames. This change is aimed to improve captured videostream smoothness in applications like Forza Horizon 4, which render more than 3 frames ahead
Added hooking profile for Deathloop. The profile disables “High” application detection level setting for this game, which is incompatible with its protective system implementation. Please take a note that application detection level settings in RivaTuner Statistics Server are application compatibility options, which are intended to be used at profiles level only for games dynamically loading DirectX runtimes. It is recommended to use it only for applications, which cannot be hooked with default “Low” application detection level. It is strongly not recommended to enable “High” level globally for all processes running in the system
Added hooking profile for Fallout 76. Similar to Deathloop profile, it also disables “High” application detection level setting for this game, which is incompatible with its protective system implementation
Added On-Screen Display profile for Diablo 2 : Resurrected
Added On-Screen Display profile for World of Warcraft
Added On-Screen Display profile for Forza Horizon 5
Application tray icon is DPI aware now
Application installer is DPI aware now
Updated profiles list

New in Rivatuner Statistics Server 7.3.2 Beta 1 (Apr 2, 2021)

Recently introduced Direct3D11 swapchain latching mode is no longer enabled by default, now it is profile based and applied in compatibility profiles only when it is really necessary (e.g. in Microsoft Flight Simulator 2020, which may simultaneously use multiple swapchains). Enabling it globally could cause the On-Screen Display to disappear on <Alt>+<Tab> in some games with bugged renderers, which leak swapchain during display mode switch.
Added new “latency marker” rendering mode for FCAT overlay. New mode is aimed to be used in conjunction with third party luminance sensor based input latency monitoring systems similar to LDAT. In this mode RivaTuner Statistics Server displays color latency event markers reflecting current input state when keyboard or mouse buttons are pressed or released. In this mode RivaTuner Statistics Server additionally stores high precision latency marker registration and latency marker presentation timestamps into shared memory and provides the timestamps to client applications. Client applications may use this data as a backend for input latency calculation in conjunction with additional data they receive from luminance sensor
Improved On-Screen Display hypertext formatting implementation:
Fixed covering extent calculation for layers with embedded objects resized to layer extent
Improved dynamic tabbing implementation. Dynamic tabulation value is no longer global for whole hypertext, now each layer calculates it independently
Added sticky layer position tags. Sticky layers are intended for displaying latency markers for luminance sensor based systems similar to LDAT, which are expected to be displayed in a fixed position unaffected by On-Screen Display origin selection
Improved concept of cursor position placeholder layers. Hypertext is no longer being automatically appended with LF symbol when the last rendered symbol is a backspace. Such approach allows using cursor position placeholder layers to define exact desired position of text output for the next hypertext clients instead of defining position one line above it
Improved SDK:
Improved OverlayEditor plugin:
Added layers list editor window. You can access it via “Edit list” command in “Layers” menu or via <Ctrl>+<Shift>+<L> keyboard shortcut to adjust layers Z-order visually with drag and drop or select desired layer
Added <Apply> button to <Layer properties> window. Now you can test your changes without closing the properties
Added sticky layer position options to <Layer properties> window
Added %Date% macro for embedding system date into hypertext
Decreased timer resolution to improve editor’s framepacing
Improved RTSSSharedMemorySample plugin:
Fixed plugin crash on the systems with more than 8 logical processors
Now the sample demonstrates new sticky layer position tags usage

New in Rivatuner Statistics Server 7.3.1 (Mar 12, 2021)

New in Rivatuner Statistics Server 7.3.0 (Mar 8, 2021)

Scanline sync no longer stops working in OpenGL applications when OSD support is disabled at application profile level
Fixed Vulkan device and instance handle leak in Vulkan bootstrap layer
Fixed crash on capturing screenshots in Cyberpunk 2077 when scRGB HDR mode is enabled
Improved compatibility with Vulkan applications using multiple Vulkan instances and devices
Various Vulkan bootstrap layer and Vulkan overlay renderer cleanups aimed to improve compatibility with Vulkan validation layer
Added alternate asynchronous On-Screen Display renderer for Vulkan applications presenting frames from compute queue (id Tech 6 and newer engine games like Doom 2016 and Dooom Eternal). The implementation is using original AMD’s high performance concept of asynchronous offscreen overlay rendering and the principle of asynchronous combining with framebuffer directly from compute pipeline with compute shader without stalling compute/graphics pipelines. PresentFromCompute entry in global profile template is set to 1 by default now and it enables new asynchronous implementation. The previous synchronous and more performance consuming implementation is also available and can be enabled by setting PresentFromCompute to 2. It is recommended to enable the previous synchronous implementation for performance comparisons only and for estimating difference in performance hit between new and old implementations
Improved compatibility with multithreaded Direct3D1x applications, using multiple Direct3D devices and swapchains and concurrently presenting frames on them from different threads (e.g. Windows Terminal)
Various compatibility improvements in the hook engine:
Now any application may manifest itself as incompatible with RivaTuner Statistics Server overlay/hooks either via declaring special named exported variable (recommended and preferred way for EXE-level implementation) or via setting process environment variable (alternate way for DLL-level implementation). So the applications incompatible with RivaTuner Statistics Server may prevent its API hooking functionality with just a couple lines of code at compile time without need to add exclusion profile for it from RivaTuner Statistics Server side
Added user extendable profile mapper to profile loader. The mapper is allowing RivaTuner Statistics Server to map multiple executable names matching with specified wildcard (e.g. vegas130.exe, vegas140.exe and so on for different versions of Sony Vegas) to a single profile file, so it is no longer necessary to create exclusion profiles for each version of such application independently
Added user extendable injection ignore triggers list. Similar to injection delay triggers list, injection ignore triggers list allows defining the set of DLL modules, which will prevent RivaTuner Statistics Server from injecting target process when any of such modules is detected in the process context. This feature is aimed to exclude applications using typical GPU accelerated GUI libraries from hooking. The list currently includes WPF framework libraries (PresentationFramework.dll and PresentationFramework.NI.dll), so all WPF applications are excluded from hooking now
Improved 32-bit runtime disassembler provides better compatibility with 32-bit applications when stealth mode is enabled
Added Direct3D12 hooking support for Direct3D12 runtime changes introduced with KB4598291
Improved RivaTuner Statistics Server host API:
New localization API is allowing the plugins to use host multilanguage translation functionality for localizing the plugin’s GUI
New On-Screen Display preview API is allowing the plugins to render On-Screen Display on top of Direct3D frambuffer specified by caller and report back each rendered layer’s screen position and extent. On-Screen Display preview API can be used to implement visual On-Screen Display editing functionality
Added helper PickColor API function, allowing the plugins to use advanced host color picker dialog window
Improved On-Screen Display hypertext formatting implementation:
Various fixes in alignment, dynamic tabbing, positioning and backspace tags parsing implementation
Added layer definition tags. Each layer defined inside the hypertext is treated by parser as an independent block of text and new On-Screen Display preview API is able to report each rendered layer’s screen position and extent independently. Please take a note that layer definition tags also affect text extent calculation, so embedded objects with zero height and width defined inside the layer are covering just their layer area instead of whole On-Screen Display area
Added extent override tags support. By default the layer extent is defined by hypertext content, but you may force the layer extent to be greater than actual content extent with new extent override tag. The tag also allows aligning the layer content by left/right/top/bottom or centering it horizontally/vertically
Added image loading tags support. The tags are allowing the parser to load and embed a custom PNG image into On-Screen Display font texture
Added image embedding tags support. The tags are allowing you to render a part of On-Screen Display font texture image into hypertext. This allows you to display custom logos or animated image sequences into On-Screen Display
Added defaults override tags support. The tags are aimed to be used in pairs, to start and stop defaults override blocks inside the hypertext. The first tag starts the block, stores default hypertext formatting attributes (text color, size and so on) and saves currently applied hypertext formatting attributes as new defaults. This way user defined defaults are being applied with default text color or size tags inside defaults override block. The next tag ends the block and restores previously saved default hypertext formatting attributes
Changed embedded object size interpretation. Now positive size values are treated as zoomed pixels instead of fixed pixels
Added new <EXE> hypertext tag, allowing displaying hooked process executable name in On-Screen Display
Added range autoscaling flag support for embedded graphs
Added new type of plugins: client plugins. RivaTuner Statistics Server is designed to act as a server process, which is running passively and providing different functionality (On-Screen Display rendering, screen and video capture, benchmarking etc) to multiple client applications connected to it (e.g. MSI Afterburner). GUI for such functionality is normally located at client application side.
New client plugins allow integrating GUI for such functionality directly into RivaTuner Statistics Server, without the need to run additional client applications, so new client plugins architecture is intended for those who prefer to use RivaTuner Statistics Server as a standalone solution without MSI Afterburner. SDK is now including the following open source client plugins:
HotkeyHandler plugin is a built in hotkey processor, which is providing and demonstrating implementation of the following functionality:
Low-latency DirectInput based hotkey handler, similar to MSI Afterburner’s internal one
Full set of standard hotkey based functionality, available in MSI Afterburner client and based on RivaTuner Statistics Server API. This includes On-Screen Display visibility control, framerate limiter activation/deactivation, screen capture, video capture and benchmarking functionality. Now all those features can be also used in standalone RivaTuner Statistics Server usage scenario
Up to 4 additional general-purpose programmable profile modifier hotkeys. You may bind almost any profile modification related actions to those hotkeys, e.g. increase of decrease framerate limit, toggle between multiple predefined framerate limits, increase or decrease scanline index for scanline sync mode, zoom OSD in/out, enable or disable global hooks and many more
OverlayEditor plugin is advanced visual hypertext editor, providing you more than any currently existing overlay can do. There were a lot of fair and independent commercial overlay reviews recently, claiming that it is absolutely impossible to develop visual overlay editing in free applications and that feature wise all free overlays are second tier products comparing to commercial ones. We decided to take it as a challenge, burst that marketing bubble and provide the plugin with such functionality free of charge to anyone who still believes in free system software distribution principles like us. So this plugin was developed from scratch in just a few weeks. It comes with fully open source code included in SDK, so you can peek inside and improve it or just see if such kind of functionality is really a rocket science development:
Unified and extremely flexible overlay layout editing GUI, which can be used in combo with any major and most popular hardware monitoring cores available on the market: HwINFO64, AIDA64 or MSI Afterburner. Do you wish to attach something else, e.g. GPU-Z? That’s not a problem, it can be easily done by any beginner developer in just a few hours because the plugin is completely open source. Your overlay layout can be easily adapted to any hardware monitoring data provider application and it will look exactly the same and stay exactly the same feature rich. With such modular architecture overlay rendering and editing application is completely decoupled from hardware monitoring core so it is extremely easy to troubleshoot hardware monitoring related compatibility issues and switch to a different hardware monitoring data provider application. Such modular architecture is a pro, not a con
The plugin provides internal data sources, which are measured by RivaTuner Statistics Server itself (e.g. framerate, frametime, minimum/maximum/average/1%/0.1% low framerates for benchmark mode). Such data sources can be used in overlay layout as is, without running any additional hardware monitoring data provider application in background
The plugin provides internal HAL (Hardware Abstraction Layer) and minimalistic built-in hardware monitoring core based on it. The HAL provides basic CPU and RAM usage related data sources and architecture specific GPU related monitoring data sources (such as graphics engine usage, videomemory usage, graphics processor and videomemory clocks, temperatures, power consumption, fan speeds and so on) available on modern discrete AMD and NVIDIA GPUs and integrated Intel GPUs. Internal HAL do not rely on low-level access to hardware in any form, it uses only native GPU monitoring functionality embedded in OS and GPU display drivers: NVAPI for modern NVIDIA GPUs, AMD ADL for modern AMD GPUs and D3DKMT for Intel iGPUs and legacy GPUs. Such approach don not break our main principle of decoupling overlay from hardware monitoring application, so HAL data sources have close to zero chances to affect hardware compatibility and they can be safely used in conjunction with any external data provider application of your choice
The plugin provides internal ping monitoring data source, implementation is a direct clone of MSI Afterburner’s ping monitoring plugin. Ping monitoring is not natively available in HwINFO64 or AIDA64, so this internal data source is aimed to help those who plan to use this plugin without MSI Afterburner in combo with HwINFO64 or AIDA64
The plugin provides an ability to import data sources from Windows performance counters, implementation is a direct clone of MSI Afterburner’s PerfConter plugin. Windows performance counters provide you built-in monitoring of HDD usage and read/write speeds, network interface download and upload rates, a lot of detailed global and per-process CPU, memory and pagefile related metrics as well as hundreds of other performance counters visible to OS
The plugin provides MSI Afterburner styled correction formulas for all external data sources. Which means that you can transform data received from external hardware monitoring data provider applications in any form, for example convert memory usage from megabytes to gigabytes and many more
The plugin provides layer based overlay layout representation, which is typical for graphics editors. Such architecture suits best for creating more complex and artistic On-Screen Display layouts, but requires a bit more time and efforts
Each layer is independently formatted and positioned hypertext block, which can display both static and dynamic hypertext. In addition to standard customization of each layer’s hypertext formatting attributes (text and background color, font size, subscript or superscript text size, text alignment etc), you can also embed the following objects directly into hypertext of each layer:
Rich set of different macro definitions, displaying system time in different formats, programmable timers, your PC hardware specs and of course current values of internal plugin data sources (e.g. framerate or frametime) of external data sources exported from different hardware monitoring applications (e.g. GPU temperature exported from MSI Afterburner)
Traditional, diagram or barchart styled graphs attached to any data source, either internal or external one
Static images, displaying your hardware manufacturer logos and so in
Dynamic animated images, changing depending on data source connected to animation input. This way you can create absolutely uniquely looking graphics indicators in your overlay layouts, e.g. round progress indicators, gauges etc
You’re not limited to embed just a single object per layer. This means that for example you may create a layer containing all CPU load barchart graphs and make them share the same settings template, which makes it much easier to modify such overlay layouts
Complete freedom of choice, you can still customize On-Screen Display layout via built-in GUI of MSI Afterburner, HwINFO64 or AIDA64. Use new plugin only if you need it and wish to create something more complex than native MSI Afterburner or HwINFO64 On-Screen Display layout
Added asynchronous process specific performance counters access interface. The interface is integrated into hooks library, which is running inside protected process context and may report hooked process specific RAM and VRAM usages to client applications
Added new open source DesktopOverlayHost tool to SDK. DesktopOverlayHost is a simple blank borderless 3D window with adjustable size, position, transparency and chroma keying support. You can use it as a platform for displaying any 3D API hook based overlay right on top of your Windows desktop. Implementation is overlay vendor agnostic, so you can use it with RivaTuner Statistics Server, as well as with other third party overlays like EVGA Precision X1 and so on
Added ShowForegroundStat profile switch, which is allowing any 3D application to display foreground 3D process framerate and frametime statistics instead of application’s own ones. This switch is used by new DesktopOverlayHost tool profile to let it to display foreground 3D process statistics on desktop
Added RenderDelay profile compatibility switch, allowing delaying On-Screen Display initialization and rendering for some applications when it is necessary (e.g. Resident Evil 3 in Direct3D11 mode when HDR mode is enabled)
FCAT overlay update rate is no longer limited to overlay content update rate in offscreen overlay rendering mode
Added new hypertext tags for displaying process specific 1% low and 0.1% low framerate graphs. Now multiple simultaneously running 3D applications can display their own independent 1% low and 0.1% low framerate graphs instead of foreground 3D application’s 1% low and 0.1% low framerate graphs in the previous version
Improved 1% low and 0.1% low framerate graphs rendering implementation for graph and diagram rendering modes. The graphs showing the history of 1% low and 0.1% low framerate changes has no statistical sense, so now RivaTuner Statistics Server is showing you more informative dynamic histogram of sorted and the most slowest immediate framerates with highlighted 1% or 0.1% areas on it. For barchart rendering mode 1% low and 0.1% framerate graphs still display the current value like before
Added new “moving bar” rendering mode for FCAT overlay. New mode is aimed to simplify visual identification of tearline position and it can be used when calibrating Scanline Sync settings
Added new “Frametime calculation point” option to “General” application properties. This option is aimed to help those who try to directly compare frame rendering start timestamp based frametimes with frame presentation timestamp based frametimes. Please refer to new option context help to get more detailed info
Added new “Percentile calculation mode” option to “General” application properties. This option is aimed to help those who try to compare different implementations of 1% low and 0.1% low framerate metrics in different applications. Please refer to new option context help to get more detailed info
Added new “Framerate limiting mode” option to “General” application properties. Two alternate framerate limiting modes selectable with this option (“front edge sync” and “back edge sync”) are intended to be used in conjunction with scanline sync mode. Using those options in tandem allows enabling so called hybrid scanline sync mode. In this case actual target scanline synchronization is performed just once for initial tearline positioning then tearline position can be steered with high precision system clock. This option can also help those who try to compare flatness of frametime graphs measured at different points (frame start vs frame presentation timestamp based)
Added 3 more decimal digits to fractional framerate limit adjustment control. Extended framerate limit adjustment precision can be necessary for new hybrid scanline sync mode, where the previous 0.001 FPS adjustment precision can be insufficient
Added fractional frametime limit adjustment support. Extended frametime limit adjustment precision can be necessary for new hybrid scanline sync mode, where the previous 1 microsecond adjustment precision can be insufficient
Now you may hold <Alt> and click framerate limit adjustment control to set framerate limit to your refresh rate
Now up/down spin buttons associated with framerate limit adjustment control tune the limit in minimum adjustment step instead of fixed 1 FPS step (e.g. in 0.1 FPS step if single decimal digit after comma is specified)
Added power user controllable passive wait stage to framerate limiter’s busy waiting loop. It is aimed to help those who is ready to sacrifice timing precision in favor of lower CPU load
Improved power user oriented scanline sync info panel. New performance counters are aimed to improve the process of scanline sync calibration and help you to diagnose tearline jittering. The following new performance counters have been added to it:
Sync start – index of scanline where 3D application called 3D API frame presentation function and scanline sync engine started the process of waiting for the target scanline
Sync end – index of scanline where scanline sync engine ended the process of waiting for target scanline. Ideally it must be as close to expected target scanline as it is possible
Present – index of scanline where 3D API frame presentation function was actually called after performing scanline synchronization. For normal scanline sync modes it is pretty close to the previous performance counter. For hybrid scanline sync mode it can drift depending on your framerate limit, if it doesn’t match with your display refresh rate
Present latency – time spent inside 3D API frame presentation call
Updated hardware encoding plugins:
All hardware encoding plugins are using new host localization API, so all plugins support multilanguage settings GUI
Updated Intel QuickSync H.264 encoder plugin. Now you may manually select target display device in the plugin’s settings. Please take a note that manual device selection can be required on Intel DCH drivers to address problems with wrong automatic Intel iGPU device selection, which could prevent the encoder from working properly
Added alternate and user configurable CPU yielding implementation to busy wait loops used in both framerate limiter and scanline sync implementations. Alternate CPU yielding implementation is used by default now, it can improve previously existing and close to ideal framepacing accuracy even further under heavy CPU load conditions due to minimizing context switching related timing penalties
Added alternate named pipe interface for streaming frametime statistics to third party applications in real time
Updated profiles list

New in Rivatuner Statistics Server 7.3.0 Beta 10 (Jan 29, 2021)

Features:
The server provides framerate and frametime monitoring support to the client applications. Framerate and frametime statistics is being collected for DirectX, OpenGL and VULKAN applications. The statistics can be rendered in On-Screen Display or provided to client applications connected to the server.
The server provides 3D acceleration usage statistics to the client applications. The clients can use the statistics to determine if any 3D applications are currently running and apply different hardware profiles depending on it.
The server provides On-Screen Display support to the client applications. The clients can display any text info in the On-Screen
Display in DirectX and OpenGL applications. The server can be also used as a standalone framerate monitoring solution and display own framerate statistics in the On-Screen Display.
The server provides desktop and in-game screen capture support to the client applications. BMP, PNG and JPG screen capture formats are supported.
The server provides high-performance real-time desktop and in-game video capture support to the client applications.
Uncompressed, high-performance custom RTV1 and native MJPG video encoding, encoding with third-party external VFW compatible codecs (e.g. Lagarith or x264vfw) and hardware accelerated H.264 encoding via Intel QuickSync, NVIDIA NVENC and AMD VCE are supported in conjunction with wide range of additional video capture related options, multisource stereo and multichannel (for Window Vista and newer) audio capture with Push-To-Talk support. The functionality of expensive commercial video capture products is now available to everyone absolutely for free! There is no need to buy dedicated video capture software anymore!
Framerate limiting support. Limiting the framerate during gaming can help to reduce the power consumption as well as it can improve gaming experience due to removing unwanted micro stuttering effect caused by framerate fluctuations.
User extendable architecture. You may express your creativity and design your own skins for RivaTuner Statistics Server, create localization for your native language, use the server to display any custom text in On-Screen Display directly from your own application and many, many more!

New in Rivatuner Statistics Server 7.3.0 Beta 6 (Jul 16, 2020)

New in Rivatuner Statistics Server 7.3.0 Beta 2 (Feb 7, 2020)

Scanline sync no longer stops working in OpenGL applications when OSD support is disabled at application profile level
Various compatibility improvements in the hook engine:
Now any application may manifest itself as incompatible with RivaTuner Statistics Server overlay/hooks either via declaring special named exported variable (recommended and preferred way for EXE-level implementation) or via setting process environment variable (alternate way for DLL-level implementation). So the applications incompatible with RivaTuner Statistics Server may prevent its API hooking functionality with just a couple lines of code at compile time without need to add exclusion profile for it from RivaTuner Statistics Server side
Added user extendable profile mapper to profile loader. The mapper is allowing RivaTuner Statistics Server to map multiple executable names matching with specified wildcard (e.g. vegas130.exe, vegas140.exe and so on for different versions of Sony Vegas) to a single profile file, so it is no longer necessary to create exclusion profiles for each version of such application independently
Added user extendable injection ignore triggers list. Similar to injection delay triggers list, injection ignore triggers list allows defining the set of DLL modules, which will prevent RivaTuner Statistics Server from injecting target process when any of such modules is detected in the process context. This feature is aimed to exclude applications using typical GPU accelerated GUI libraries from hooking. The list currently includes WPF framework libraries (PresentationFramework.dll and PresentationFramework.NI.dll), so all WPF applications are excluded from hooking now
Added new type of plugins: client plugins. RivaTuner Statistics Server is designed to act as a server process, which is running passively and providing different functionality (On-Screen Display rendering, screen and video capture, benchmarking etc) to multiple client applications connected to it (e.g. MSI Afterburner). GUI for such functionality is normally located at client application side. New client plugins allow integrating GUI for such functionality directly into RivaTuner Statistics Server, without the need to run additional client applications, so new client plugins architecture is intended for those who prefer to use RivaTuner Statistics Server as a standalone solution without MSI Afterburner. SDK is now including open source HotkeyHandler client plugin, which is providing and demonstrating implementation of the following functionality:
Low-latency DirectInput based hotkey handler, similar to MSI Afterburner’s internal one
Full set of standard hotkey based functionality, available in MSI Afterburner client and based on RivaTuner Statistics Server API. This includes On-Screen Display visibility control, framerate limiter activation/deactivation, screen capture, video capture and benchmarking functionality. Now all those features can be also used in standalone RivaTuner Statistics Server usage scenario
Up to 4 additional general-purpose programmable profile modifier hotkeys. You may bind almost any profile modification related actions to those hotkeys, e.g. increase of decrease framerate limit, toggle between multiple predefined framerate limits, increase or decrease scanline index for scanline sync mode, zoom OSD in/out, enable or disable global hooks and many more
Updated hardware encoding plugins:
All hardware encoding plugins are using new host localization API, so all plugins support multilanguage settings GUI
Updated Intel QuickSync H.264 encoder plugin. Now you may manually select target display device in the plugin’s settings. Please take a note that manual device selection can be required on Intel DCH drivers to address problems with wrong automatic Intel iGPU device selection, which could prevent the encoder from working properly
Added alternate and user configurable CPU yielding implementation to busy wait loops used in both framerate limiter and scanline sync implementations. Alternate CPU yielding implementation is used by default now, it can improve previously existing and close to ideal framepacing accuracy even further under heavy CPU load conditions due to minimizing context switching related timing penalties
Updated profiles list

New in Rivatuner Statistics Server 7.2.0 (Oct 30, 2018)

Added On-Screen Display performance profiler. Power users may enable it to measure and visualize CPU and GPU performance overhead added by On-Screen Display rendering. Two performance profiling modes are available:
Compact mode provides basic and the most important CPU prepare (On-Screen Display hypertext formatting, parsing and tessellation), CPU rendering and total CPU times, as well as GPU rendering time (currently supported for Direct3D9+ and OpenGL applications only)
Full mode provides additional and more detailed per-stage CPU times.
Improved built-in framerate limiter:
Fractional framerate limit adjustment functionality is no longer power user oriented, now you may specify fractional limit directly from GUI
Now you may click “Framerate limit” caption to switch framerate limiter to alternate “Frametime limit” mode. New mode allows you to specify the limit directly as a target frametime with 1 microsecond precision
Added alternate framerate limiting mode, based on synchronization with display rasterizer position. Now you may synchronize the framerate to up to two independent scanline indices per refresh interval. Combining with power user configurable scanline wait timeout and graphics pipeline flushing options, those settings provide experienced users vendor agnostic ultra low input lag adaptive VSync, half VSync or double VSync functionality on any hardware
Added power user oriented idle framerate limiting mode. Unlike traditional framerate limiting mode, idle framerate limiting mode is only affecting inactive 3D applications running in background. Idle framerate limit is specified as a target frametime with 1 microsecond precision. Idle framerate limiting mode helps to reduce power consumption when you minimize some heavy 3D applications and switch to other processes
Various On-Screen Display optimizations and improvements:
Added adjustable minimum refresh period for On-Screen Display renderer. The period is set to 10 milliseconds by default, so now the On-Screen Display is not allowed to be refreshed more frequently than 100 times per second. Such implementation allows keeping smooth animation when On-Screen Display contents are being updated on each frame (e.g. when displaying realtime frametime graph) without wasting too much CPU time on it
Added alternate GPU copy based Vector2D On-Screen Display rendering mode implementation for Direct3D1x applications. New mode provides up to 5x Vector2D performance improvement on NVIDIA graphics cards, however it is disabled on AMD hardware due to slow implementation of CopySubresourceRegion in AMD display drivers
Vector2D rendering mode is now forcibly disabled in Vulkan applications on AMD graphics cards due to insanely slow implementation of vkCmdClearAttachments in AMD display drivers
Revamped geometry batching and vertex buffer usage strategy in pure Direct3D12 On-Screen Display renderer (currently used in Halo Wars 2 only)
Added Vector2D rendering mode support to pure Direct3D12 On-Screen Display renderer
Optimized On-Screen Display hypertext parsing and tessellation implementation
Optimized state changes in OpenGL On-Screen Display rendering guru implementation
Improved implementation of On-Screen Display rendering from separate OpenGL context (profile compatibility switch used in certain OpenGL applications, e.g. Pyre) on AMD graphics cards
Optimized state changes in Direct3D1x On-Screen Display rendering implementation
Solid rectangles and line primitives in Direct3D8 and Direct3D9 On-Screen Display rendering implementations are now rendered from vertex buffer instead of user memory
Improved OpenGL framebuffer dimensions detection when framebuffer coordinate space is selected
Increased static vertex buffer size for Vulkan and pure Direct3D12 renders to increase amount of primitives rendered in On-Screen Display in a single pass
Improved desktop duplication based desktop video capture implementation ( Windows 8 and newer OS versions):
Now desktop video recording sessions do not stop on display mode switch or on switch to exclusive fullscreen mode. Such approach allows you to start capturing video on desktop then launch some 3D application and create a video file containing both desktop and 3D application’s video streams
Improved video capture API allows video capture frontend applications (e.g. MSI Afterburner) to force desktop or 3D application video capture modes in addition to default mixed desktop/3D application capture mode
Now desktop capture is using multhithreaded active busy-wait loop frame capture instead of timer driven frame capture in order to improve frame timing precision and resulting video smoothness. The previous timer driven frame capture can be enabled via configuration file if necessary
Decreased desktop duplication timeouts in order to improve RivaTuner Statistics Server GUI response time under certain conditions during desktop videocapture sessions in timer driven frame capture mode
Improved SDK:
Improved RTSSFrametimePipeSample sample. Now the sample demonstrates frametime pipe connection for applications running with both full administrative and limited user rights
Improved NVENC plugin. Added NVIDIA 416.xx drivers family support. The plugin was recompiled with newer NVENC encoder API headers, because NVIDIA stopped supporting legacy v4 NVENC API in release 416 and newer series drivers. Due to this change NVENC plugin no longer supports pre-release 358 NVIDIA drivers
Fixed On-Screen Display rendering in wrong colors when Vector2D mode is selected and Direct3D1x applications use 10-bit framebuffer
Fixed Vulkan fence synchronization issue, which could cause GPU-limited Vulkan applications to hang due to attempt to reuse busy command buffer
Active busy-wait loop in the framerate limiter module is now forcibly interrupted during unloading the hooks library to minimize the risk of deadlocking 3D application when dynamically closing RivaTuner Statistics Server during 3D application runtime
Improved CBT hooks uninstallation routine to minimize the risk of deadlocking 3D application when dynamically closing RivaTuner Statistics Server during 3D application runtime
Improved validation in OpenGL On-Screen Display rendering routine to minimize the risk of crashing OpenGL applications
Changed OpenGL cleanup routines to improve compatibility with OpenGL applications using multiple rendering contexts (e.g. GPU Caps Viewer)
Improved synchronization in 32-bit API hook uninstallation routines
Added timeout to API hooks injection in CBT hook handler. The timeout is aimed to reduce injection related CPU overhead on some systems, related to high mouse polling rate combined with keyboard/mouse hooks installed by third party applications
Interoperability D3D10 page flips on some systems are now filtered by framerate calculation module in OpenGL/Vulkan applications
Hook engine is now using alternate double jump x64 hook trampoline to improve compatibility with third party 64-bit On-Screen Display applications
Added compatibility profile switch for hooking IDXGISwapChain::ResizeBuffers via VTable instead of hotpatching
Added hook epilogs support to 32-bit VTable hook handler
Fixed instance checking implementation in 64-bit RTSSHooksLoader and EncoderServer helper applications
Added exclusion profile for Forza Horizon 4. Please take a note that On-Screen Display is currently not supported in this game due to its protective system limitations
Forcible graphics and compute queues synchronization is now disabled by default for Vulkan applications presenting frames from compute queue (AMD Vulkan rendering codepaths in DOOM and Wolfenstein II : The New Colossus). Due to this change, On-Screen Display will be invisible in those games on such platforms by default. Experienced users, understanding and accepting that On-Screen Display rendering will cause performance penalty, may re-enable it with PresentFromCompute profile switch
Added tri-state skinned buttons support in the skin engine
Updated profiles list

New in Rivatuner Statistics Server 7.1.0 (Sep 26, 2018)

New in Rivatuner Statistics Server 7.0.2 (Sep 26, 2018)

New in Rivatuner Statistics Server 7.0.0 (Sep 26, 2018)

Added initial Microsoft UWP applications support. Now RivaTuner Statistics Server provides full On-Screen Display, framerate/frametime statistics collection and framerate limiting support for sandboxed Windows 10 store applications. Screencapture and videocapture are currently not supported in UWP environment
New default Metro interface styled skin designed by 00pontiac
Default skin composition mode is now set to layered mode with color key and light transparency
Improved default On-Screen Display rendering configuration provides better default On-Screen Display appearance on modern mainstream PC display resolution. Now raster 3D rendering mode with Unispace font and shadow rendering are enabled and zooming ratio is set to 3 by default
Framerate is now displayed as integer value, however you may return back to floating point framerate representation with configuration file switch if necessary
Hook engine is now using alternate shorter x64 hook trampoline to provide compatibility with Windows 10 Creators Update Direct3D9 runtimes. The previous trampoline can be enabled via the configuration file if necessary
Hook libraries are now digitally signed by MSI to simplify and speed up the process of new versions’ whitelisting by third party anticheat systems. Thanks to MSI, EAC and BattleEye for making it possible!
Fixed bug in Vulkan On-Screen Display cleanup code causing The Talos Principle to crash to desktop on changing video settings
Improved On-Screen Display rendering quality in Direct3D1x applications using sRGB framebuffers
Fixed bug is skin engine causing part of the profiles window to be rendered in solid black color when using layered skin composition mode with alpha channel
Fixed crash on startup under Windows Vista with no platform update installed
On-Screen Display is no longer being rendered improperly when switching between vector and raster On-Screen Display rendering modes during Direct3D1x application runtime
FCAT overlay support is no longer limited to vector On-Screen Display rendering modes in Direct3D1x applications, now it is also supported for Direct3D1x applications when raster 3D On-Screen Display rendering mode is enabled
On-Screen Display shadow in now rendered in proper RGB colors instead of BGR in On-Screen Display preview window
New On-Screen Display shadow rendering for raster 3D mode provides improved shadow rendering quality for some combinations of fonts and low On-Screen Display zooming ratios. The previous mode can be also enabled via profile if necessary
Now “Delete profile” button is unlocked when “Hide pre-created profiles” option is enabled and template based profile is selected
Now you may hold <Ctrl> when pressing “!dd profile” button to create a profile for currently active 3D applications, or hold <Shift> to create a profile with disabled application detection (i.e. exclusion) for currently active 3D applications
Added On-Screen Display transparency support. New On-Screen Display color picker window allows you to adjust color opacity level to make On-Screen Display to appear semi-transparent if necessary. Please take a note that transparency if fully supported for raster 3D On-Screen Display rendering mode. Some symbols of polygonal vector 3D font can be rendered with artifacts when transparency is selected and vector 2D mode doesn’t support transparency at all
Added On-Screen Display background color fill mode. New “On-Screen Display fill” option allows you fill underlying On-Screen Display area with solid or transparent color. Fill color and transparency level can be customized in “On-Screen Display palette” colors list
Updated SDK:
Improved shared memory layout. Now each running 3D application entry contains x64/UWP application architecture usage flags in addition to previously available 3D API usage flags
Added text formatting tags support for On-Screen Display text. Now the client applications using RivaTuner Statistics Server to render a text in On-Screen Display (e.g. AIDA, HwInfo or MSI Afterburner itself) can apply custom text colors, alignment, size and position to some parts of displayed text. Format tags are fully supported for raster 3D On-Screen Display rendering mode only, some tags are ignored for vector On-Screen display rendering modes
Improved On-Screen Display text macro translator. To provide more flexibility and customization %FRAMERATE% macro is now deprecated and replaced with new tags allowing printing application specific framerate, frametime and 3D API independently
Updated RTSSSharedMemorySample sample code. Now the sample demonstrates text format tags usage and shows you how to apply custom On-Screen Display color, subscript style and custom alignment to a text rendered in On-Screen Display from a client application. The sample also demonstrates framerate display via both %FRAMERATE% macro and new tags
Improved On-Screen Display preview window:
Now you may detach and set custom position and size of preview window by double clicking preview window area. Increased size of preview window can be useful if you prefer to adjust On-Screen Display position visually via dragging it inside the preview
Now you may right click preview window area and select “Capture screenshot” command from the context menu to automatically capture screenshot from currently running 3D application and use it as On-Screen Display preview background, or use“Load” command to open and load some previously captured screenshot. This feature can be useful if you prefer to adjust On-Screen Display position visually via dragging it inside the preview. Original On-Screen Display preview window background can be restored with “Clear” command from the context menu
Improved dynamic Direct3D12 presentation command queue detection algorithm
Added On-Screen Display support for Direct3D11 applications using alternate frames presentation technique (e.g. Halo Wars Definitive Edition)
Added power user oriented profile compatibility setting, allowing enabling alternate VTable based hooking for Direct3D1x applications concurrently presenting frames from multiple threads (e. g. Forza Horizon 3 or Halo Wars 2)
Added power user oriented profile compatibility setting, allowing enabling pure Direct3D12 On-Screen Display renderer for some Direct3D12 applications conflicting with D3D11on12 interop layer (e.g. Halo Wars 2)
Added power user oriented profile compatibility setting for OpenGL applications rendering from forward compatible 3.x+ context with disabled deprecated immediate OpenGL mode functionality. The switch allows the server to fall back to rendering path using a separate legacy OpenGL context
Added On-Screen Display profile for Wolfenstein : The New Order
Added On-Screen Display profile for Citra Nintendo 3DS emulator
Added On-Screen Display profile for CEMU Wii U emulator
Revamped internal benchmarking engine
Updated profiles list