CapFrameX Capture and Analysis Tool: baixar versions anteriors

CapFrameX 1.9.1 restores the experimental in-game overlay with signed binaries, brings back the bundled BENCHLAB service, and improves overlay compatibility, hardware information, and capture workflows. This is a stable release; the in-game renderer remains experimental.

Revised v1.9.1 packages (build 1.9.1.5)
The packages have been rebuilt to correct the missing Authenticode signature on LiveCharts.Wpf.dll reported in #451. All packaged Windows DLLs, including managed dependencies and satellite resources, now have valid Authenticode signatures. Installer custom-action dependencies are signed before embedding. Existing valid vendor signatures are preserved.

The release verification now rejects any unsigned or invalidly signed packaged binary. Package hashes in SHA256SUMS.txt have been updated; the VirusTotal link above refers to the original build. This addresses the unsigned-component cause of the Smart App Control report; verification on the reporter's SAC-enabled system is still pending.

Update using the revised installer, or extract the revised portable archive into a new folder and copy your previous Portable data folder and customized portable.json. Source for this packaging revision: v1.9.1.5.

Overlay and OSD
- Restored CapFrameX in-game (Experimental) for DirectX 11, DirectX 12, and Vulkan titles, including signed x64 and x86 hook and layer DLLs. If the in-game renderer cannot be used, the hook-free overlay takes over. Hook-free and RTSS renderers remain available.
- Automatic compatibility probing with per-game learned profiles, revalidated when conditions change, and recovery after frame-generation changes during a session, including FSR and XeSS routing. Some compatibility changes require restarting the game.
- Smoother in-game frametime charts, sharper antialiased lines, and corrected frame cadence under frame generation. The FPS graph now works without the frametime graph and can be toggled live.
- Improved column layout in the Overlay tab: OSD options arrange in three columns, wrapping to two in narrower windows, and the overlay item grid shows all columns without horizontal scrolling.
- Overlay toggles in the Overlay tab and status bar, per-entry text sizes, and an OSD log-folder shortcut.
- The hook-free overlay shows only while a capture process is detected, is placed on the selected monitor regardless of the taskbar, and averages its metrics at each refresh.
- The remote OSD API (/api/osd, /ws/osd) keeps updating while the overlay is switched off.
- Fixed template apply/revert, profile switching, and the save button.
- Share overlay compatibility reports (Overlay → OSD options) is off by default and requires explicit consent. Reports use a random participant ID and exclude full paths, account details, and raw logs; turning sharing off deletes unsent reports. Extended diagnostics remain opt-in; native overlay logging overhead is reduced.

Sensors and system information
- Bundled BENCHLAB Service 2.4.0, rebuilt as a signed, self-contained .NET 10 executable that needs no separate ASP.NET runtime. Compatible separately installed services remain supported; fixed null sensor readings.
- Updated Intel IGCL v298 and AMD ADLX 2.0, with expanded Intel telemetry, fan and PSU readings, and AMD SmartShift monitoring.
- The Info dashboard shows software components (PawnIO, PresentMon, RTSS, Vulkan layer) and platform security (Secure Boot, test signing, VBS, memory integrity), and adds Copy system info. The log explains when Windows code integrity blocks the PawnIO driver.
- Corrected Intel Alder/Raptor Lake memory gear decoding and kept per-core overlay entries consistent across CPU changes.
- Removed the AMD FLM click-to-photon latency feature with its settings, sensors, and overlay entries.

Capture, interface, and reliability
- Updated to PresentMon 2.6.0 and added stored display-layer metadata to captures.
- Restored per-game capture durations (Global or This game), added persistent hotkey disabling, and preserve

CapFrameX 1.9.0 brings a refreshed interface, built-in overlays, expanded hardware telemetry, and reduced background overhead. This is a stable release. The CapFrameX in-game overlay is unavailable in this release and will be delivered in a later update once our code-signing certificate is available.
Downloads and requirements
───────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Package │Installation
───────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
release_1.9.0_installer.zip│Extract and run CapFrameXBootstrapper.exe. Setup installs CapFrameX and removes obsolete CapFrameX Vulkan layer
│registrations.
───────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
release_1.9.0_portable.zip │Extract the complete archive and run CapFrameX.exe. Keep the included portable.json to use an isolated portable
│configuration.
───────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Install the .NET 10 Desktop Runtime (x64) first. The application now targets .NET 10. Another .NET major version, the plain .NET Runtime, or the legacy .NET Framework does not replace this requirement. Setup checks for the Desktop Runtime before installation; the portable application host checks it before startup.
The internal application version is 1.9.0.8, with the release channel. SHA-256 package hashes are supplied in SHA256SUMS.txt. See Portable Mode for portable runtime requirements and configuration.
Overlay and OSD
- Built-in CapFrameX hook-free renderer, the default for new configurations, with an output-display picker and adjustable chart refresh rate. RTSS remains available as a separate renderer.
- CapFrameX in-game (Experimental) is disabled with a notice about delivery after our code-signing certificate is available. The managed injector, DirectX hook DLLs, and Vulkan layer DLLs/manifests are excluded from these packages.
- Earlier in-game renderer selections migrate to hook-free; existing hook-free and RTSS selections are preserved.
- Opacity, zoom, placement, an OSD position hotkey, and PresentMon replay buffering for the hook-free renderer.
- Extended native-renderer logging is opt-in and persists across restarts. Reduced routine logging and improved UI responsiveness.
Revised v1.9.0 packages
The downloads have been replaced with application build 1.9.0.8 following the Defender report in #430. This revision omits the in-game overlay components and the bundled BENCHLAB service. Package hashes have been updated in SHA256SUMS.txt.
Portable users: extract this revision into a new folder. You can then copy your previous Portable data folder and customized portable.json. Overwriting the old application folder can leave removed binaries behind.
Installer users: run the revised setup to update the application and remove the previous package's in-game components and Vulkan registrations. Close CapFrameX and games before updating.
BENCHLAB remains supported when a compatible service has been installed separately. CapFrameX detects an existing service and can start it for monitoring. It no longer includes or falls back to its own service executable, and independently running services are left running when CapFrameX closes.
Sensors and monitoring
- AMD Anti-Lag status and Frame Latency Meter (FLM) integration, including passive click-to-screen measurement and vendor-aware handling.
- NVIDIA memory temperatures, memory-controller utilization, and estimated VRAM bandwidth; additional fallback handling for NVIDIA power readings.
- GPU memory allocation telemetry across vendors and support for data-rate sensor readings.
- More reliable AMD GPU detection, hybrid iGPU/dGPU 

Release Notes
Enhancements & New Features
- New Animation Error metrics (Average, P99) in Analysis and Report views, including a new animation error chart. The PresentMon parameters --track_frame_type and --track_app_timing are used to improve the accuracy of the Animation Error.
- New frametime percentile parameters (P1/P5 frametime quantiles)
- Intel fabric clock sensors (e.g. NGU/D2D clocks on Arrow Lake) based on a new IntelOOBMSM PawnIO module
- New Intel PawnIO wrapper (MSR, OC mailbox) with updated Intel MSR IDs
- Zen 6 standard path support, experimental Ryzen SMU support
- Prefer total/board power sensors over Intel's core-only "GPU TDP"
- Expanded MCP server tool set:
- Capture lifecycle tools: list capture-eligible processes, start/stop captures, wait for capture completion
- Configuration tools: read/write AppSettings, read/write overlay slot configurations, toggle single overlay entries, select logged sensors, edit record comments
- Frametime tools: frametime time series with downsampling, stutter/spike detection
- PMD tools: per-channel power summaries and time series (GPU/CPU/system power)
- Sensor analysis and cross-record analysis tools
- ETW buffer health status tool
- Frame generation awareness in metrics and comparison tools
Bugfixes
- Fixed animation error chart rendering
- App start freeze handling (ETW service health check, PawnIO initialization)
- Zen 6 core clock handling
- More robust handling of invalid PresentMon output lines
- Comparison tab variances chart corner radius
Platform & Infrastructure
- PawnIO module updates (IntelMSR, RyzenSMU, LpcIO, SMBus modules), added new IntelOOBMSM module
Runtime Requirements
- .NET 9 is now required for full feature support and optimal stability. Download here.
MCP Server: Setting up Claude Code communication
CapFrameX ships an in-process Model Context Protocol server hosted by CapFrameX.exe. Once registered with Claude Code, the assistant can read captures, compute statistics, query the live system, and diagnose capture issues. Starting with v1.8.6, the assistant can also control captures (start/stop) and modify the configuration (AppSettings, overlay entries, logged sensors) via dedicated tools. The endpoint exists only while CapFrameX is running.
Setup
1. Find the port. Open %appdata%/CapFrameX/Configuration/AppSettings.json and read WebservicePort (default 1337; CapFrameX falls back to a free port if it's taken).
2. Register with Claude Code (one-time, user-scoped):
claude mcp add -s user capframex --transport http http://localhost:<port>/mcp
3. Verify:
claude mcp list
Expected: capframex: http://localhost:<port>/mcp (HTTP) - ✓ Connected
In an active session, /mcp shows live status and the CapFrameX tools become available to the model.
Troubleshooting
- Disconnected / connect failure — CapFrameX isn't running, or the port changed since you registered. Re-check WebservicePort, then:
claude mcp remove capframex
claude mcp add -s user capframex --transport http http://localhost:<new-port>/mcp
- Tools missing in the model — start a new Claude Code session; existing sessions don't pick up newly added servers.
- Disable entirely — set McpEnabled to false in AppSettings.json and restart CapFrameX.
Note: unlike v1.8.5, the v1.8.6 tool set is no longer read-only — it includes capture control and configuration write tools. The endpoint binds to localhost without auth.
CapFrameX Portable Mode
CapFrameX supports a portable mode that allows the application to run entirely from a single folder without writing to system directories. This is useful for running from USB drives, network shares, or keeping multiple isolated installations.
Portable mode is activated by placing a portable.json file in the same directory as the CapFrameX executable. See the v1.8.5 release notes for the full configuration reference, requirements, and behavior differences.
Troubleshooting & Known Issues
The following tips address the most common issues reported by users and can help resolve stabil

Release Notes
Enhancements & New Features
- Support Intel Nova Lake + ES, Bartlett Lake, Emerald Rapids, Wildcat Lake
- New NVIDIA limit sensors
- Per-game VRAM sensors
- AMD GPU fan duty sensor
- SSD sensors
- Intel memory/uncore clock sensors incl. PTL model 0xD5
- MCP server implementation
- Removed stutter metrics from FPS graph, display times used for moving averages, reworked threshold and variance charts
- Adjusted piechart layout
- Removed GPU Power Load as default sensor
Bugfixes
- Duplicated GPU memory sensor entries
- Default sensors + new IsGroupNameCompatible helper
- Integer division in NvidiaGpu.cs
- Y-axis boundaries in frame time graph
- PMC Reader DRAM latency
Platform & Infrastructure
- ADLX 1.5 update
- IGCL update
- FrameView fully removed (project + Jenkins)
- Updated NuGet packages
- New overlay config migration test for NV Mobile + Intel
Runtime Requirements
- .NET 9 is now required for full feature support and optimal stability. Download here.
MCP Server: Setting up Claude Code communication
CapFrameX ships an in-process Model Context Protocol server hosted by CapFrameX.exe. Once registered with Claude Code, the assistant can read captures, compute statistics, query the live system, and diagnose capture issues. The endpoint exists only while CapFrameX is running.
Setup
1. Find the port. Open %appdata%/CapFrameX/Configuration/AppSettings.json and read WebservicePort (default 1337; CapFrameX falls back to a free port if it's taken).
2. Register with Claude Code (one-time, user-scoped):
claude mcp add -s user capframex --transport http http://localhost:<port>/mcp
3. Verify:
claude mcp list
Expected: capframex: http://localhost:<port>/mcp (HTTP) - ✓ Connected
In an active session, /mcp shows live status and the CapFrameX tools become available to the model.
Troubleshooting
- Disconnected / connect failure — CapFrameX isn't running, or the port changed since you registered. Re-check WebservicePort, then:
claude mcp remove capframex
claude mcp add -s user capframex --transport http http://localhost:<new-port>/mcp
- Tools missing in the model — start a new Claude Code session; existing sessions don't pick up newly added servers.
- Disable entirely — set McpEnabled to false in AppSettings.json and restart CapFrameX.
All v1.8.5 tools are read-only; the endpoint binds to localhost without auth.
CapFrameX Portable Mode
CapFrameX now supports a portable mode that allows the application to run entirely from a single folder without writing to system directories. This is useful for running from USB drives, network shares, or keeping multiple isolated installations.
How It Works
Portable mode is activated by placing a portable.json file in the same directory as the CapFrameX executable. When the application starts, it checks for this file and redirects all data storage to paths relative to the application directory.
Key Features
- Self-contained: All configuration, captures, screenshots, and logs are stored relative to the application folder
- No registry modifications: The application doesn't write to the Windows registry in portable mode
- No system folder usage: Bypasses %AppData% and Documents folders entirely
- Configurable paths: All storage paths can be customized via portable.json
portable.json Configuration
Create a portable.json file in the CapFrameX application directory with the following structure:
{
"portable": true,
"paths": {
"config": "./Portable/Config",
"captures": "./Portable/Captures",
"screenshots": "./Portable/Screenshots",
"logs": "./Portable/Logs",
"cloud": "./Portable/Captures/Cloud"
}
}
Configuration Options
─────────────────┬────────────────────────────────────────────────────────────────────────────────┬─────────────────────────
Property │Description │Default
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
portable │Enables portable mode when true │true
─────────────────┼───────────────────────────────────────────

Release Notes
Enhancements & New Features
- Ryzen SMU support Zen 5
- Overlay profile compatibility mode
- New internal management stable sensor IDs
- Drag&Drop folders on Comparison and Report tab
- Auto enable PMD measurement
- Detailed process info Capture tab
- RAM Game Used sensor
Bugfixes
- Capture files cannot be saved to network drives
- Invalid aggregation sensor data
- Invalid D3D sensors
- Sensor profiles not saved correctly
Platform & Infrastructure
- Fixed device path for latest PawnIO driver 2.1.0
Runtime Requirements
- .NET 9 is now required for full feature support and optimal stability. Download here.
CapFrameX Portable Mode
CapFrameX now supports a portable mode that allows the application to run entirely from a single folder without writing to system directories. This is useful for running from USB drives, network shares, or keeping multiple isolated installations.
How It Works
Portable mode is activated by placing a portable.json file in the same directory as the CapFrameX executable. When the application starts, it checks for this file and redirects all data storage to paths relative to the application directory.
Key Features
- Self-contained: All configuration, captures, screenshots, and logs are stored relative to the application folder
- No registry modifications: The application doesn't write to the Windows registry in portable mode
- No system folder usage: Bypasses %AppData% and Documents folders entirely
- Configurable paths: All storage paths can be customized via portable.json
portable.json Configuration
Create a portable.json file in the CapFrameX application directory with the following structure:
{
"portable": true,
"paths": {
"config": "./Portable/Config",
"captures": "./Portable/Captures",
"screenshots": "./Portable/Screenshots",
"logs": "./Portable/Logs",
"cloud": "./Portable/Captures/Cloud"
}
}
Configuration Options
─────────────────┬────────────────────────────────────────────────────────────────────────────────┬─────────────────────────
Property │Description │Default
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
portable │Enables portable mode when true │true
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.config │Configuration files (AppSettings.json, overlay configs, sensor config, UI state)│./Portable/Config
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.captures │Capture recordings │./Portable/Captures
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.screenshots│Screenshot storage │./Portable/Screenshots
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.logs │Log files │./Portable/Logs
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.cloud │Cloud download directory │./Portable/Captures/Cloud
─────────────────┴────────────────────────────────────────────────────────────────────────────────┴─────────────────────────
All paths are relative to the application directory. You can use ./ or .\ prefix, or just the folder name.
Requirements
When running in portable mode, the following dependencies must be installed on the system:
- .NET 9.0 Desktop Runtime (x64) - Download
- Visual C++ 2015-2022 Redistributable (x64) - Download
The application will check for these dependencies on startup and display a message if any are missing.
Creating a Portable Distribution
1. Copy the CapFrameX application files to a folder
2. Create a portable.json file with the configuration above
3. (Optional) Pre-create the Portable subdirectory with: Config, Captures, Screenshots, Logs
4. The application is now portable and can be move

Release Notes
Enhancements & New Features
- Increased buffer capacity for extremely high fps scenarios
Bugfixes
- Fixed driver version overlay info for AMD GPUs
Platform & Infrastructure
- Readded signed PawnIO.sys driver to address Windows SmartScreen issues
Runtime Requirements
- .NET 9 is now required for full feature support and optimal stability. Download here.
CapFrameX Portable Mode
CapFrameX now supports a portable mode that allows the application to run entirely from a single folder without writing to system directories. This is useful for running from USB drives, network shares, or keeping multiple isolated installations.
How It Works
Portable mode is activated by placing a portable.json file in the same directory as the CapFrameX executable. When the application starts, it checks for this file and redirects all data storage to paths relative to the application directory.
Key Features
- Self-contained: All configuration, captures, screenshots, and logs are stored relative to the application folder
- No registry modifications: The application doesn't write to the Windows registry in portable mode
- No system folder usage: Bypasses %AppData% and Documents folders entirely
- Configurable paths: All storage paths can be customized via portable.json
portable.json Configuration
Create a portable.json file in the CapFrameX application directory with the following structure:
{
"portable": true,
"paths": {
"config": "./Portable/Config",
"captures": "./Portable/Captures",
"screenshots": "./Portable/Screenshots",
"logs": "./Portable/Logs",
"cloud": "./Portable/Captures/Cloud"
}
}
Configuration Options
─────────────────┬────────────────────────────────────────────────────────────────────────────────┬─────────────────────────
Property │Description │Default
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
portable │Enables portable mode when true │true
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.config │Configuration files (AppSettings.json, overlay configs, sensor config, UI state)│./Portable/Config
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.captures │Capture recordings │./Portable/Captures
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.screenshots│Screenshot storage │./Portable/Screenshots
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.logs │Log files │./Portable/Logs
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.cloud │Cloud download directory │./Portable/Captures/Cloud
─────────────────┴────────────────────────────────────────────────────────────────────────────────┴─────────────────────────
All paths are relative to the application directory. You can use ./ or .\ prefix, or just the folder name.
Requirements
When running in portable mode, the following dependencies must be installed on the system:
- .NET 9.0 Desktop Runtime (x64) - Download
- Visual C++ 2015-2022 Redistributable (x64) - Download
The application will check for these dependencies on startup and display a message if any are missing.
Creating a Portable Distribution
1. Copy the CapFrameX application files to a folder
2. Create a portable.json file with the configuration above
3. (Optional) Pre-create the Portable subdirectory with: Config, Captures, Screenshots, Logs
4. The application is now portable and can be moved to any location
Behavior Differences
─────────────────────────────────────┬─────────────────────────────────┬──────────────────────
Feature │Installed Mode │Portable Mode
─────────────────────────────────────┼─────────────────────────────────┼────────────

Release Notes
Enhancements & New Features
- Effective clock support for Intel CPUs
- ADLX support AMD GPUs
- AMD NPU telemetry
- Improved overlay management
- Improved overlay templates
- Improved display detection for MRR metric
- Disk space validation when saving capture files
Bugfixes
- Fixed order Report tab table
- Fixed Revert button overlay template
- All sensors initially selected
Platform & Infrastructure
- New plugin interface
Runtime Requirements
- .NET 9 is now required for full feature support and optimal stability. Download here.
CapFrameX Portable Mode
CapFrameX now supports a portable mode that allows the application to run entirely from a single folder without writing to system directories. This is useful for running from USB drives, network shares, or keeping multiple isolated installations.
How It Works
Portable mode is activated by placing a portable.json file in the same directory as the CapFrameX executable. When the application starts, it checks for this file and redirects all data storage to paths relative to the application directory.
Key Features
- Self-contained: All configuration, captures, screenshots, and logs are stored relative to the application folder
- No registry modifications: The application doesn't write to the Windows registry in portable mode
- No system folder usage: Bypasses %AppData% and Documents folders entirely
- Configurable paths: All storage paths can be customized via portable.json
portable.json Configuration
Create a portable.json file in the CapFrameX application directory with the following structure:
{
"portable": true,
"paths": {
"config": "./Portable/Config",
"captures": "./Portable/Captures",
"screenshots": "./Portable/Screenshots",
"logs": "./Portable/Logs",
"cloud": "./Portable/Captures/Cloud"
}
}
Configuration Options
─────────────────┬────────────────────────────────────────────────────────────────────────────────┬─────────────────────────
Property │Description │Default
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
portable │Enables portable mode when true │true
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.config │Configuration files (AppSettings.json, overlay configs, sensor config, UI state)│./Portable/Config
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.captures │Capture recordings │./Portable/Captures
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.screenshots│Screenshot storage │./Portable/Screenshots
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.logs │Log files │./Portable/Logs
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.cloud │Cloud download directory │./Portable/Captures/Cloud
─────────────────┴────────────────────────────────────────────────────────────────────────────────┴─────────────────────────
All paths are relative to the application directory. You can use ./ or .\ prefix, or just the folder name.
Requirements
When running in portable mode, the following dependencies must be installed on the system:
- .NET 9.0 Desktop Runtime (x64) - Download
- Visual C++ 2015-2022 Redistributable (x64) - Download
The application will check for these dependencies on startup and display a message if any are missing.
Creating a Portable Distribution
1. Copy the CapFrameX application files to a folder
2. Create a portable.json file with the configuration above
3. (Optional) Pre-create the Portable subdirectory with: Config, Captures, Screenshots, Logs
4. The application is now portable and can be moved to any location
Behavior Differences
─────────────────────────────────────

Release Notes
Enhancements & New Features
- Auto generate overlay profiles
- vkcube overlay preview window
- PresentMon 2.4.1 with many fixes and updates
- Overlay list search and filter
- Check for FrameViewService ETW session
Bugfixes
- Option menu combo boxes
- PMD data capture interval length
Platform & Infrastructure
- Smarter PawnIO driver management
- App-level BENCHLAB service management (no need to install the service separately)
- Smarter check for .NET 9 (SDK, Desktop Runtime, Standard Runtime)
Runtime Requirements
- .NET 9 is now required for full feature support and optimal stability. Download here.
CapFrameX Portable Mode
CapFrameX now supports a portable mode that allows the application to run entirely from a single folder without writing to system directories. This is useful for running from USB drives, network shares, or keeping multiple isolated installations.
How It Works
Portable mode is activated by placing a portable.json file in the same directory as the CapFrameX executable. When the application starts, it checks for this file and redirects all data storage to paths relative to the application directory.
Key Features
- Self-contained: All configuration, captures, screenshots, and logs are stored relative to the application folder
- No registry modifications: The application doesn't write to the Windows registry in portable mode
- No system folder usage: Bypasses %AppData% and Documents folders entirely
- Configurable paths: All storage paths can be customized via portable.json
portable.json Configuration
Create a portable.json file in the CapFrameX application directory with the following structure:
{
"portable": true,
"paths": {
"config": "./Portable/Config",
"captures": "./Portable/Captures",
"screenshots": "./Portable/Screenshots",
"logs": "./Portable/Logs",
"cloud": "./Portable/Captures/Cloud"
}
}
Configuration Options
─────────────────┬────────────────────────────────────────────────────────────────────────────────┬─────────────────────────
Property │Description │Default
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
portable │Enables portable mode when true │true
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.config │Configuration files (AppSettings.json, overlay configs, sensor config, UI state)│./Portable/Config
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.captures │Capture recordings │./Portable/Captures
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.screenshots│Screenshot storage │./Portable/Screenshots
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.logs │Log files │./Portable/Logs
─────────────────┼────────────────────────────────────────────────────────────────────────────────┼─────────────────────────
paths.cloud │Cloud download directory │./Portable/Captures/Cloud
─────────────────┴────────────────────────────────────────────────────────────────────────────────┴─────────────────────────
All paths are relative to the application directory. You can use ./ or .\ prefix, or just the folder name.
Requirements
When running in portable mode, the following dependencies must be installed on the system:
- .NET 9.0 Desktop Runtime (x64) - Download
- Visual C++ 2015-2022 Redistributable (x64) - Download
The application will check for these dependencies on startup and display a message if any are missing.
Creating a Portable Distribution
1. Copy the CapFrameX application files to a folder
2. Create a portable.json file with the configuration above
3. (Optional) Pre-create the Portable subdirectory with: Config, Captures, Screenshots, Logs
4. The application is now portable and can be moved to a

Release Notes
Enhancements & New Features
- Animation Error smoothness metric. More info here.
Bugfixes
- AMD Ryzen 9000 clock speed calculation when bus speed is not 100MHz
Platform & Infrastructure
- Reworked Microsoft Visual C++ Redistributable installer detection
Runtime Requirements
- .NET 9 is now required for full feature support and optimal stability. Download here.
Troubleshooting & Known Issues
The following tips address the most common issues reported by users and can help resolve stability, overlay, and capture-related problems efficiently. We recommend working through them in order if you encounter unexpected behavior.
1. Ensure you are running the latest version
If you experience application crashes or unstable behavior, verify that you have installed CapFrameX v1.7.9 or newer. Many known issues have been resolved in this patch. If you were previously using version 1.7.7, we recommend uninstalling CapFrameX before installing the new version.
2. Reset application settings
In some cases, corrupted or outdated configuration files may cause problems. Deleting
%appdata%/CapFrameX/Configuration/AppSettings.json
will reset CapFrameX to its default settings and often resolves startup or UI-related issues.
3. Reset overlay configuration files
If overlay-related problems persist, try deleting the overlay configuration files located at
%appdata%/CapFrameX/Configuration/OverlayEntryConfiguration_(0/1/2).json.
These files will be recreated automatically on the next application start.
4. Restore missing or zero-value overlay entries
When overlay entries are missing or display constant zero values, open the Overlay tab and use the Reset button to restore all overlay entries to a valid default state.
5. Fix incorrect overlay entry order
If the order of overlay entries appears inconsistent or unintentionally rearranged, use the Sort button in the Overlay tab to restore a clean and logical ordering.
6. Resolve frametime anomalies after updates
In rare cases, existing background capture processes can interfere with CapFrameX after an update. If you encounter frametime issues, close all running PresentMon processes before installing or launching CapFrameX v1.7.9.
7. Avoid conflicts with other monitoring tools
Applications such as HWiNFO or AIDA64 that implement their own FPS or frametime metrics may conflict with CapFrameX’s capture service, as they also rely on PresentMon-based mechanisms. Disabling overlapping FPS or frametime monitoring features in those tools is strongly recommended when using CapFrameX.
Known Limitations
- PC latency metric may return invalid values (NaN) under specific conditions.
BENCHLAB Service
When using BENCHLAB service, unzip the folder in a suitable installation folder like C:\Benchlab Service or D:\Tools, then run the .bat script as admin. Don't install the service from the Download folder. Install latest .NET 9 runtime. Download here.

New features
- Support AMD Zen 5
- Support Intel Arrow Lake
- Thread Affinity Controller compatible with Arrow Lake core layout
- PresentMon v2.2 with new Start-to-PresentReturn / PresentReturn-to-PresentReturn frame time measurement approach
- New CPU Busy metric which indicates the duration the CPU was engaged in processing the frame before presenting it
- Added TBP Sim for AMD RDNA2 graphics cards
image
image
Image source: VideoCardz
Enhancements
- PMD metrics as floating point numbers with one decimal digit
Bugfixes
- Exception handling AMD ADLX API calls
Info
With the new PresentMon version the frame time measurement approach has changed from Present-to-Present to Start-to-PresentReturn / PresentReturn-to-PresentReturn. Taken from the PresentMon release notes:
"The majority of metrics are changed to use the time that the CPU started working on a frame as the reference point instead of the present() call, with values that are more aligned to measuring the quality of graphics applications (e.g., latency and duration of interaction and displayed frames). See README-ConsoleApplication.md for more details."
Unwinder (the author of RTSS):
"There is no best or preferable method. Both have their own different usage cases. Frame-start-to-frame-start frametime graph can be used to validate framepacing quality of latency oriented framerate limiting modes (low latency SK limiter mode, async/back edge sync RTSS limiter modes, NV CPL framerate limiter etc). Such graph should become "flat" when such framerate limiting strategy is in use. Present-to-present frametime graph can be used to validate framepacing quality of framerate limiters prioritizing presentation timings adjustment (latent sync or normal framerate limiter in SK, front edge sync or scanline sync in RTSS). Such graph is expected to jitter if latency oriented framerate limiting strategy is in use, but become "flat" if framerate limiter prioritize presentation timings adjustment. You may also switch between these two modes to determine which framerate limiting strategy is used by some other third party framerate limiters or in-game framerate limiters."

New features
- Updated PresentMon caputure service to v1.9.0, see PresentMon GitHub repository for more info.
- New metric: GPU Active Time (GPU Busy)
- GPU Active Time graph on Analysis tab. GPU Busy graph can be enabled via "Additional graphs".
- New overlay metrics: GPU Busy and GPU Busy Deviation. GPU Busy Deviation describes the deviation of GPU Active time from the frame time. The closer it is to 0% the more balanced the workload is.
- FPS <-> ms toggle on Analysis tab
- New real-time metrics: 1% and 0.2% Low Average
- More Powenetics v2 features
- PMD logs export (context menu)
- Mapping PMD data to frame time data points
- Smart data mapping via linear spline interpolation
- Real-time metrics reset button
- Updated AMD ADLX and Intel IGCL
- Optional ADL fallback (TBP Sim for RDNA2, Vega VRM temps etc.)
- Implementation network ping overlay entry
- Thread affinity controller (Intel hybrid architecture, AMD Ryzen with 2 CCDs)

Enhancements
- Performance optimization AMD ADLX readings
- Reset thread affinity to default when starting a new game
- Overlay entry showing current thread affinity state
- Better handling of integrated graphics (UHD Graphics and Iris Xe Graphics )

Bugfixes
- Bugfix detection error (Call of Duty MW2)
- Config files access exceptions (Moved folder from MyDocuments to AppData/Roaming)
- GPU PCIE Rx and Tx throughput unit