* feat(input): the arithmetic of controller statistics - classes, batteries, makers, one pad seen twice (D155-D163) Nothing reads a device yet. Domain.Input says whether an XInput state or a DualSense report is a pad in use and what its battery is, adds a battery's readings up, counts switches and decides when two entries are one pad; Application.Input holds one session's slices and turns them into a reading a second; InputSessionBuilder turns a session's readings into its totals, its controllers as JSON and its timeline. TelemetrySample can carry a reading. Every byte and reading under test was written by hand: no report from a real controller has passed through this code. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * feat(input): a session can store what it was played with - schema 0024, the .partial file's chunk 11, both tiers (D160) Nine columns on sessions (the time in front and its four classes, the switches of method, the sources that answered, the controllers as JSON) and three on games (what a store lists of controller support), ADD COLUMN only. The .partial file gains chunk 11, so a session recovered after the Agent died keeps its readings. SessionFinalizer.Build stores them before the tier branch: hooked, unhooked and recovered sessions alike. The input series are sensor_blobs rows named input.*, which the sensors' read now leaves out and FindInputSensorsAsync returns. Nothing produces a reading yet. A ledger this build has opened cannot be opened by 0.1.0-beta.49 or earlier. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * feat(input): the input reader, which the Agent does not start yet - raw input for controllers, XInput, the time of the last input (D155, D158, D159) Application.Input.InputReader takes a slice about ten times a second from Infrastructure.Input.Win32InputBackend, on the thread of InputDeviceHub, which exists only while a session has a view of it. It opens no device, sends nothing to one and registers for no keyboard or mouse. tools/input-readonly-check.ps1 holds its Windows calls to a list. With no controller at hand, what the reader does with one connected is not established. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * fix(input): an arm of XInputPad.Battery's switch said what the default says (Qodana, on #464 after it merged) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(input): no using that makes the file's own qualified names redundant (InspectCode) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(input): what InspectCode reported in the reader's tests - redundant casts, a hub disposed twice, a suppression not needed Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * wip(input): the Agent records what a session was played with - the switch, the terms, the legal texts Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * style(input): import order in the Agent's composition; no redundant qualifier in a test (InspectCode) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * wip(input): what a store lists of controller support, the input libraries, the game page's three rows * wip(input): the game page's details tests expect the three controller rows; the library names test without ToLowerInvariant Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * docs(guide): the settings page listed Controllers and input twice Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * feat(input): a session's summary says what it was played with - the shares, the controllers and their batteries, two charts, marks on the frame-time chart; Trend, Compare and the CSV export (D155-D163) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * release: 0.1.0-beta.50 - what a session was played with: controllers and input, read from outside the game; owner-only item 48 (D155-D163; with D152, D154) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(app): the bar's gap is named by the class that has it; one sentence for the frames session's own sensors Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(app): the fixture's constant is named as the format check wants Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(input): the last-input time is asked not to go back, not to match .NET's tick - the two differ by the time the PC slept; the finding in 21_INPUT_DEVICES and HANDOFF's traps Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * refactor(app): the notes of a session's input need its controllers' record, not its row Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * docs(handoff): auto-merge does not wait for Qodana - the trap, and what was fixed here Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
36 KiB
FrameLedger — Disclaimer
Version: 2.18 · Effective: {{RELEASE_DATE}}
0. This is pre-release software
FrameLedger is pre-release software. Every build published so far is a pre-release: a beta, or an alpha — a beta's
source built to try a newer version of .NET, at times a prerelease one, with the further risks set out in the Alpha
notice (legal/ALPHA_NOTICE.md, shown before an alpha build runs). It has been tested on a small number of
machines and games — the games are listed in docs/LIST_GAME_TESTED.md in the project's repository, and what the software
cannot do is listed in LIMITATIONS.md there and in the app under Help ▸ Limitations — and it certainly still contains
bugs — some of them not yet known to anyone. Features can
change or disappear between builds, recorded data can turn out to be wrong, and an update can require your data to be
migrated.
Windows and your processor. From 0.1.0-beta.37 FrameLedger is built on .NET 11. Microsoft supports .NET 11 on Windows 11, and on Windows 10 only in its LTSC and IoT editions. FrameLedger has been run on Windows 11 only: on Windows 10 22H2 Home or Pro it may run, but it is untested there and nobody supports it. It does not start on a processor without SSE4.2 and POPCNT.
By installing or running a pre-release build you accept that:
- it may crash, hang, fail to record, or record wrongly, and may cause the game you are measuring to do the same;
- the developer is not responsible for any incident, loss or damage that results, including lost progress, corrupted saves, lost recordings, wasted time, or anything else described in this document;
- no support, fix, or response time is promised. Reports are welcome and are read; nothing is owed in return.
If that is not acceptable to you, do not use a pre-release build.
1. How FrameLedger measures (read this first)
To measure what a game is actually doing — its real render resolution, which upscaler is running at which quality preset, whether frame generation is active, whether rays are being traced — FrameLedger loads a component (FrameLedger.Overlay.dll) inside the game process and observes calls the game makes to graphics APIs. Vulkan titles use a standard Vulkan layer instead. This is the same class of technique used by widely-used tools such as frame-rate overlays, screen-recording software, and post-processing injectors.
None of this information is obtainable from outside the process, which is why the software works this way.
FrameLedger only loads a library from its own installation directory. The injection path refuses anything else, and there is no setting that changes this.
Be precise about what that does and does not promise, because the shorter version — "only FrameLedger's own component is ever loaded" — claims more than the check performs:
- It establishes where the file came from, not what is in it. There is no filename, version or content comparison, and that is deliberate: a check on the name
FrameLedger.Overlay.dllwould be satisfied by any library that borrowed the name. - A FrameLedger installation contains several hundred files, because the application ships self-contained with the .NET runtime beside it. Any library in that directory satisfies the check.
- FrameLedger is distributed unsigned, so nothing attests to that directory's contents. Anyone able to write there could alter what gets loaded — and could equally replace the component that performs this check.
Install it somewhere only you can write to, and verify the published SHA-256 checksums.
What it observes inside the game: arguments the game passes to graphics APIs we intercept (presentation, upscaling, ray tracing, pipeline creation) — and, only while Advanced metrics is on, one thing that is not an argument: the graphics driver's own report of how long the stages of the game's last frames took, which the component asks NVIDIA's driver for itself (§2 says exactly how).
What it reads about the game from outside it, in every session: the game process's own memory use — its dedicated and shared video memory and its working sets, the figures Windows' Task Manager shows — from Windows' performance counters and process-memory information. For a game it does not inject into, FrameLedger opens the game's process for this with the least access Windows offers, once a second, and closes it again; it reads nothing inside the process.
What it reads about controllers, the keyboard and the mouse, from outside the game, unless you switch it off: which game controllers are connected, whether one is in use, its battery level, and the time of the last keyboard or mouse input — to say how much of a session was played with a controller and how much with the keyboard or mouse. It asks Windows, never the game; it opens no controller and sends nothing to one; and it keeps no key, button or text (the Privacy Policy says exactly what is kept). It reads none of this until you have accepted the Privacy Policy that describes it.
What of that list is observed today is stated once, in §4 below (the block
legal/ACCURACY.mdcarries, dated). The list here describes what the software is designed to observe, and the boundary — API arguments, and the one report asked of the graphics driver that the line above names; nothing of the game's own memory — holds for all of it.
What it never does: read or write the game's memory outside those API arguments; read save files, chat, or network traffic; read what you type or which buttons you press — it keeps only whether a controller, or the keyboard or mouse, was in use, read from Windows and never from the game; send anything to a controller; modify game behavior; hide itself from any security software; or install a kernel driver of its own.
2. Anti-cheat systems — the main risk to you
Loading code into a game process can be detected by anti-cheat and anti-tamper systems, and may result in a warning, a block, or a permanent ban of your account. This risk falls on you, not on the developer.
FrameLedger is designed to reduce that risk substantially:
-
Injection is off by default and must be enabled by you per game.
-
Before injecting, and every 30 seconds afterwards, FrameLedger scans for known anti-cheat and anti-tamper components. If it finds one, it refuses to inject; if a session is already running, it stops at the next scan. No setting turns this off, globally or per game; the one exception you can make yourself, per game, still runs every check and is described in §2A. Because the scan runs every 30 seconds rather than continuously, anti-cheat that loads mid-session may be present for up to 30 seconds before FrameLedger detects it and stops.
And there is a second, longer window you should know about. The part of FrameLedger running inside the game also stops on its own if it loses contact with the part doing the scanning — because a scanner that has stopped cannot protect you. It waits 65 seconds before concluding that contact is lost, so that one delayed scan on a busy machine does not end your session. In the worst case those windows combine: if the scanner stops at the moment anti-cheat appears, the component inside the game may keep running for up to 65 seconds afterwards. That number is 65 and not 30, and this document says so rather than leaving the 30 above to imply it.
-
What "stops" means differs by graphics API, and the difference is worth stating plainly. For Direct3D and OpenGL titles FrameLedger injects a library and genuinely removes its hooks. Vulkan titles use a Khronos layer instead, and a layer cannot remove itself from the loader's chain while the game is running — attempting to leave crashes the application. There, "stops" means FrameLedger stops observing and passes every call through untouched. It records nothing further, but its library remains loaded until the game exits.
-
FrameLedger contains no evasion techniques of any kind — it does not hide, rename, obfuscate, or disguise itself. It is intended to be plainly identifiable to any security software that looks.
For completeness about what it does run inside the game: besides the intercepted calls themselves, the component starts one background thread. It wakes once a second, or when the game loads a library, and then: checks FrameLedger's own shared memory for a request to stop and for the heartbeat of the safety scan described above; asks Windows, by name, whether the graphics, upscaling and frame-generation libraries it knows about are loaded, and puts its interception into the ones that are (for ray tracing it creates one command list on the game's own Direct3D 12 device, to find the functions to intercept); writes its counters to FrameLedger's shared memory; and writes FrameLedger's own log file.
One call it makes itself, into the graphics driver — only while Advanced metrics is on. In a Direct3D 12 game that had already loaded NVIDIA's driver library (
nvapi64.dll), the component asks that library — by name, among what the game loaded; it never loads it — for two of the driver's read-only functions, and keeps the library and the driver file those functions are in from being unloaded for as long as the game runs. Then, about once a second, on the game's own thread that presents its frames, right after a frame has been handed over, it calls them: one returns the driver's report of how long the stages of the last frames took, the other the driver's low-latency state. It calls no function that sets, marks or delays anything. A library of that name sitting in the game's own folder is not the driver's and is not called. What this costs the game is the length of that call, once a second — a few millionths of a second where it was measured. A call that faults is caught, counted once, and not repeated; a call that takes two thousandths of a second or more is the last one until the game is closed. A call that never returns would hold the game's presenting thread, and FrameLedger cannot stop it — it has not happened in any test, and it is said here because it is the one thing in this component whose length FrameLedger's own code does not bound. With Advanced metrics off — the default — none of this happens.It does not scan the game's memory, list the modules or processes on the system, or query Windows services — deliberately, because software that does those things from inside a game process looks like the thing this tool is trying not to be mistaken for.
-
FrameLedger injects into a game only after you enable that game individually. For every other game — and for any game where the safety checks refuse — it records the session's start, end and duration together with whatever hardware sensor readings your machine provides and the game's own memory use as Windows reports it (§1), and reports every other measurement as not available. There is no measurement mode that works without injecting; an earlier version of this document described one, and it was never built. FrameLedger never estimates a value it could not measure, and it always shows which of the two modes produced a session. Neither mode requires administrator rights.
However, these protections cannot be complete:
- The list of known anti-cheat systems cannot be exhaustive. New systems appear, and a game can add one in an update.
- Some anti-tamper technology (for example Denuvo) can react badly to injection even in single-player games — usually a crash, but potentially lost progress or play time.
- Heuristic detection can flag well-behaved software.
- The developer cannot restore a banned account, recover lost progress, or intervene with any game publisher on your behalf.
FrameLedger is intended for offline and single-player play. If you enable injection for a game with any online or competitive component, you do so entirely at your own risk and are solely responsible for the consequences, including compliance with that game's terms of service.
2A. There is no way past the guard — and one narrow exception you can make yourself
Versions 0.1.0-beta.3 and 0.1.0-beta.4 offered a per-game switch to overrule the guard. It has been removed. If FrameLedger finds anti-cheat or anti-tamper software in a game — before it injects, when a session starts, or during a session — it refuses, turns hooking off for that game, and says so on the game's page. There is no setting, per game or global, that overrules that. Sessions recorded under the earlier switch stay in your database, marked as such in their notes.
Since 0.1.0-beta.9 there is one exception, and it is not a way past the guard. A Settings option, off unless you turn it on, lets you make an exception — one game at a time, after a disclosure you must accept — for a game whose only finding is a single anti-cheat that works entirely in user mode (no kernel driver, no service, and no driver file anywhere in the game's folder) and that is on no list of titles FrameLedger refuses. Since 0.1.0-beta.11 the game does not need to have been measured before: the first two sessions under the exception are a trial, and if one of them does not go well — it crashes, records nothing, does not end normally, is stopped for safety, or something new is found — the exception ends and can never be made again for that game. Under it the guard still runs every check, before injecting and every 30 seconds, and still refuses anything else it finds; after the trial the exception ends by itself when something new is found, when a session under it crashes or is stopped for safety, or when the game is updated, and turning the option off suspends it. Sessions recorded under it are marked with the anti-cheat they ran beside. Two good sessions are not evidence that the anti-cheat did not notice — a ban may still come later.
It exists because users asked for it, and it carries exactly the risk this document describes. That anti-cheat may still detect FrameLedger in the game and warn, block or permanently ban your account — possibly days later — and FrameLedger cannot know whether it did. Earlier sessions that went well are no promise about the next one. Do not use it with a game you play online or competitively unless you accept losing that account; the developer cannot reverse a ban.
3. Stability
Software running inside another process can, in principle, destabilize it. FrameLedger guards every intercepted call, disables itself automatically after repeated internal faults, and automatically stops injecting into a game that crashes shortly after injection twice. Despite this, the developer is not responsible for crashes, lost progress, corrupted saves, or any other loss arising from use of the software. Save your game before benchmarking.
4. Measurement accuracy
Frame timing is derived from high-resolution timestamps taken at the moment the game presents each frame; upscaling, frame-generation and ray-tracing state are read from the parameters the game passes to those APIs. This is substantially more accurate than inferring settings from files on disk, but no measurement is guaranteed to be exact:
⚠ What FrameLedger actually measures today — 2026-11-11. The software is a beta; its latest beta is
0.1.0-beta.50(2026-11-15), an unsigned installer built from that tag with its checksums published beside it (alphas — experimental builds that try a newer .NET — are published apart). The source holds the desktop app (library, store import, charts, settings) and the background Agent, which records a session when a game in the library runs (unless you switched its recording off), injects only into games you enabled and only past the safety guard, and stores sessions in a local database. What that path measures:
- Frame times and output resolution: measured from the present call for Direct3D 11/12 and OpenGL titles FrameLedger injects into. Vulkan titles are measured only when FrameLedger itself starts the game with its Vulkan layer enabled, which the Play button set to Start directly (since beta.21) and the Agent's command-line launch do. A Vulkan title started any other way is not observed by the layer; FrameLedger injects its Direct3D component into it instead, and what that records on a Vulkan title has not been verified. Direct3D 9 and every 32-bit title are not measured.
- Which upscaler is running: measured from the API a Direct3D title calls — DLSS or NIS through NVIDIA Streamline (with Ray Reconstruction Yes/No), and FSR through AMD's shipped FidelityFX DLLs: named FSR 3 from the older DLLs, and FSR without a version from the newer ones, which host both FSR 3.1 and FSR 4. FSR 2, and FSR shipped any other way, is not identified. For DLSS titles that bypass Streamline, the NVIDIA driver's own per-process record is stored with the session and shown as DLSS (driver-reported). The NVIDIA driver's profile for the game — the DLSS and frame-generation overrides the NVIDIA App sets — is read, never changed, and shown as the driver's settings beside what was measured. Intel XeSS is not read (its SDK licence forbids it), and neither is an upscaler compiled into the game: those read
N/A, or "Unknown upscaler" when another vendor's hook ran in the game. Vulkan and OpenGL titles readN/A.- Quality mode: shown only when it is known. When the NVIDIA App overrides DLSS Super Resolution for the game and the NVIDIA driver reports that the override applied in the session, the override's mode is shown and marked as the NVIDIA App's. Otherwise the mode the game itself passed: the DLSS options a Streamline title passes with its per-frame call (not yet seen on a real title), or, for FSR through AMD's FidelityFX libraries, the mode whose render size the game asked for and then rendered at. In every other case — FSR at a dynamic resolution among them — no mode is shown.
- DLSS version: the version of each DLSS library the game loaded and whether it came from the game or from the NVIDIA driver; "DLSS 4" or "DLSS 4.5" only when the session shows it (the model preset the driver reports, a measured multi-frame factor, or the NVIDIA App's Dynamic frame generation that the driver reports applied); "DLSS 5" only when the game was seen running its neural rendering, otherwise "runtime loaded" when its library was loaded.
- Render → output resolution: measured where the vendor's own per-frame call carries the render size (AMD FidelityFX dispatches, and Streamline titles whose resource tags state it);
N/Awhere it does not: DLSS titles that bypass Streamline, Streamline titles whose tags carry no size, and Vulkan and OpenGL titles.- Frame generation (Direct3D titles only): the Displayed rate is counted from presents, plus the presents DXGI's own counter saw on the same swap chain that the hook did not; the Native rate from the vendor's own per-frame calls (NVIDIA Streamline, AMD FidelityFX) where the title makes them, and
N/Awhere it does not. When frame generation did not stay in one state for the whole session (menus, loading screens, a settings change), no session-wide factor is shown: the factor, Native and Displayed are those of the state that held longest — five-second windows whose ratios agree within 10 %, covering at least 10 s and 10 % of the time the game was presenting — and are always shown with the share of the session they cover; with no such state, the reason is shown instead. The session summary lists each state it held, with its share of the time and its own Native → Displayed rates. DLSS-G and FSR FG are named from the calls the game makes; any other generator (XeSS-FG, one compiled into the game) is shown only as active with the technology not identified, and is never named. Where a technology is named but its frames could not be counted, or frame generation is not measured, the software shows Presented FPS with a note on what it may include — never a Native figure. Where generated frames were counted, the lows, median and stutter are taken over application frames only.- Ray tracing: Yes/No measured on Direct3D 12 from ray-dispatch and acceleration-structure-build calls; the technique and path tracing are
N/A, and so is ray tracing on other APIs.- Display mode: how each game's window was shown — exclusive full-screen, borderless, windowed or minimised — as a share of the session, with the window's size and the monitor's, in every session. Exclusive full-screen is known only for Direct3D titles FrameLedger injects into, from the game's own swap chain; for every other session the window alone is read, and a window covering its monitor reads full-screen or borderless. What Windows does behind the game (fullscreen optimizations) is not visible.
- Engine version: the exact Unreal Engine 4 or 5 version, read from the game's executable on disk and labelled with what it rests on;
N/Awhere the executable names none. Since beta.19 also Unity's (from its player library or its data file — without the release letter where only the library's number is readable), Godot's (from its data pack) and RPG Maker's maker and version (MV and MZ from their core script; XP, VX and VX Ace by their runtime library's version, which is not the editor's). RPG Maker 2000/2003 is not detected. Since beta.20 also Ren'Py's (from its engine's version file). Other engines show what their own files state.- The game's own memory (since beta.12): its dedicated and shared GPU memory and its private working set — the numbers Task Manager's Details tab shows — with its working set and commit, read once a second from Windows' own counters, from outside the game, in every session: a game FrameLedger injects into through the handle it already holds, any other by opening it briefly with the least access Windows offers (and adding up every process running its executable). Shown with mean, median and peak. The game's other processes (launchers, helpers) are not counted.
- Video memory: in use on the whole graphics card, recorded from Windows and GPU-driver telemetry and charted. Not measured at all: the video-memory budget Windows gives a game, which frame spikes were shader compilation, end-to-end PC latency, and HDR. Stutter count and stutter time are measured from frame times.
- NVIDIA's latency report (only with Advanced metrics on; Direct3D 12; a game that uses NVIDIA Reflex): how long the driver says each stage of a frame took — simulation, render submit, present, driver, the operating system's queue, the graphics card — read from the graphics driver about once a second and shown as the driver reported it: the driver's numbers, not a measurement by FrameLedger, an average of the frames of one read, never checked against another tool, and not the delay from a click to the screen. The stages overlap and do not add up to the total. The graphics card's stage runs from its start to its end and includes the time the card waited — in one game it was longer than the whole frame — so since beta.48 two figures the driver works out itself are shown beside it: the card's active time, and the time from one frame's end to the next. A driver may give neither, and then there is no line. Read in two real games, on one driver and one card (2026-11-14). A game that does not use Reflex has none. The session summary's latency fields stay N/A.
- Pacing, VSync and the graphics card (since beta.14): the share of the time below 30 FPS, below 60 FPS and below the monitor's refresh rate, measured from frame times with small margins so that a game held at its limit is not counted as below it (a rate less than 2 % under the line reads partly as at it), and how much one frame's time differs from the next; for Direct3D titles, how many frames asked to wait for the display and how many allowed tearing — what the game asked, not what the driver did; the graphics card's clock speeds, fan speed and memory temperature in every session, and, on NVIDIA cards only, how much of the time its power limit or its temperature held it back, read once a second; and frames per watt — the game's own frames per second for each watt the graphics card drew, never counting generated frames,
N/Awhere the game's own frame rate is not known.- Controllers and input (since beta.50; on unless you switch it off in Settings, and only once you have accepted the Privacy Policy that describes it): how much of the time a game was in front it was played with a controller, with the keyboard or mouse, with both or with neither; each controller's connections and drops; its battery. All of it is read from Windows, from outside the game: it says a controller was in use while the game was in front, not what the game did with it. Keyboard and mouse are one figure — only the time of the last input is read — and input a program injects (Steam Input mapping a controller to keys, a macro tool) counts as keyboard and mouse. An Xbox-compatible controller and a DualSense are read for use; another maker's controller is listed and never counted as in use. A DualSense on Bluetooth reports its battery only where Steam or the game has switched it to its long report, and an Xbox controller on Bluetooth may report none. None of this had been read from a real controller when it was written (2026-11-14): it was checked against data written by hand.
- Processor and memory: how busy the processor was (time busy, all cores together — not the frequency-scaled figure Task Manager draws) and how much system memory was in use, read from Windows once a second and charted. Processor temperature is read only when the Agent runs as administrator — an option, off by default, for which Windows asks at every start of the Agent — with PawnIO installed, and that reading has not yet been checked on real hardware; everywhere else it is
N/A.- Advanced metrics (since beta.39; off unless you switch it on in Settings): with it on, a session also stores what the graphics driver and the sensor library report about the hardware — the graphics card's memory, load, clocks, fans, voltages and power in detail, what a display can do, the driver's settings for the game — as they report it: NVIDIA's figures once a second, the sensor library's every five seconds. None of these readings has been checked against another tool. The processor's, the memory's and the motherboard's need the Agent as administrator with PawnIO and have never been read on real hardware; a drive's temperature is not read. The Advanced page shows them as they were stored, and what the PC reads at the moment only while that page is open.
- What a game tells its upscaler (since beta.40; only with Advanced metrics on, only for a game measured from inside): the output size, presets and exposure a game hands DLSS, and the sharpening, jitter, exposure, depth range, field-of-view range, flags and frame time it hands FSR, are read from the arguments of the calls FrameLedger intercepts and shown as the game stated them — not checked against what the upscaler did. Most games set their DLSS options through a call that cannot be intercepted and show none; the FSR values need FSR 3.1 or later through AMD's own library. Since beta.43 also what a game tells NVIDIA Streamline about each frame (jitter, motion-vector scale, depth range, field-of-view range, how often it reset the upscaler's history — for the first viewport that called, where a game has several) and how it configures FSR frame generation (the settings it asked for, not whether frames were generated). Since beta.44 also what Streamline answers when a game asks about a feature — its version, and what it requires (graphics APIs, V-Sync, GPU scheduling, Windows and driver versions): Streamline's answer as the game received it, not a check of the PC. A game that asks only while it starts has none and the session says so; the Unreal Engine games run so far ask again later, and were read. Since beta.45 also whether Streamline says each feature is supported and whether it is loaded, and what the game did with it after FrameLedger attached — switched it on or off, allocated and freed its resources (counted to fifteen), shut Streamline down: calls the game made, not a statement that a feature ran or produced anything. FSR's upscaling values, Streamline's constants (seven games), its answers about a feature (seven games), the frame-generation configuration (one game) and five of beta.45's six calls (five games) have been read from real games; no game run so far allocated a feature's resources after FrameLedger attached, and the DLSS options have not been confirmed on one yet. A game may give a value in a unit of its own: one gives Streamline its field of view in degrees, and it is shown as given.
- Safety: every pre-injection check runs before injection, including the signed-by-a-known-vendor half of the suspicious-module rule. During every capture the Agent re-runs the checks every 30 s and stops capturing on a refusal: a Direct3D or OpenGL game's hooks are removed, and the Vulkan layer goes passthrough. A global switch in Settings turns all hooking off, and a running capture stops at its next check; it can only refuse, never permit. There is no override. A finding about a game — anti-cheat named in its process or in its folder (any kernel driver there counts), or the game on a title list by its store id or executable name — turns hooking off for that game, whether found by the Agent's own check of every game in the library, before injection, at a session's start or by the 30 s re-check; the game's page says so, and nothing turns it back on for that executable — except a user-mode exception you make yourself, per game, in Settings (off by default): only where the only finding is one anti-cheat that runs entirely in user mode, with no driver file in the game's folder. Its first two sessions are a trial, and one that does not go well ends it for good. The guard still runs every check under it and ends it on anything new; a ban remains possible.
Where a value is not measured it reads
N/A, with two exceptions: FPS then shows Presented FPS with a note on what it may include, and ray-tracing flags may show a value you set yourself, labelled as yours. The software never substitutes an estimate.
- Frame timing: typically better than 0.05% error; hardware sensors carry their own accuracy limits (±1–2 °C is normal).
- 1% Low and 0.1% Low are statistical and are hidden when the sample size is insufficient.
- Path tracing has no reliable technical signature; FrameLedger reports it as
N/Aand never asserts it. (This line promised a confidence-scored suggestion; none is computed. Corrected 2026-09-15.) - When measurement is unavailable (no-injection mode, unsupported API, missing vendor support), fields read
N/A. FrameLedger does not substitute estimates for measurements.
Do not use FrameLedger's output as the sole basis for purchasing, warranty, overclocking, or safety decisions.
4A. Your PC must meet the game's own requirements
FrameLedger measures a game; it does not make one run. Make sure your PC meets at least the minimum system requirements published by the game's developer or publisher before you measure it — read them first.
If you run FrameLedger with a game on a machine below that game's minimum requirements, low frame rates, stutter, crashes, overheating, failures to start, and readings that look wrong are consequences of that choice. They are your responsibility, not the developer's, and they are not defects of FrameLedger. The same applies to unstable overclocks or undervolts, overheating or failing hardware, out-of-date or beta graphics drivers, a Windows installation that is missing updates, and other overlays, injectors or "optimizer" tools running at the same time.
FrameLedger adds a small cost of its own while it records. On a machine that is already at its limit, that cost can be the difference between a game that runs and one that does not. Turn hooking off for that game if so.
5. Hardware and drivers
FrameLedger reads GPU telemetry through vendor libraries that ship with your graphics driver. It only reads — it never changes clocks, fan curves, power limits, or any other hardware setting. Optional CPU-temperature support — and, with Advanced metrics on, reading the processor's, the memory's and the motherboard's sensors — relies on the separate third-party PawnIO driver, which you install at your own discretion under its own license; some anti-cheat systems object to third-party kernel drivers regardless of what they are used for.
5A. Running the capture agent as administrator — optional, and your decision
Since 0.1.0-beta.10 a Settings option, off unless you turn it on, starts FrameLedger's capture agent as administrator. Windows asks you every time the agent starts — also when you sign in — and the prompt names an unknown publisher, because FrameLedger is not code-signed. It lets FrameLedger open and measure a game that itself runs as administrator, and read the CPU temperature — and, with Advanced metrics on, the processor's, the memory's and the motherboard's sensors — where PawnIO is installed. It changes nothing in the anti-cheat guard (§2, §2A), opens no process that Windows or an anti-cheat driver protects, and never starts a game as administrator: games you start from FrameLedger run with your standard rights.
The risk is yours. FrameLedger is installed in your user folder, which any program running under your Windows account can change (§1). If such a program replaced FrameLedger's files, it would run with administrator rights the next time you accept the prompt. Accept it only for a copy you installed from the project's GitHub Releases, and turn the option on only if you trust everything that runs under your account. The developer is not responsible for what runs under an administrator prompt you accept.
6. Third-party names
Windows and DirectX are trademarks of Microsoft Corporation. NVIDIA, DLSS, Reflex, NVAPI, AMD, FSR, Intel, XeSS, Vulkan, Steam, GOG, Epic Games, itch.io, Unity, Unreal Engine, and all other product names are trademarks of their respective owners. FrameLedger is an independent project and is not affiliated with, endorsed by, or sponsored by any of them, including any game publisher or anti-cheat vendor.
7. Content creators
If you publish benchmarks or videos using FrameLedger data, you are responsible for how you present the numbers. The software deliberately shows native frame rate alongside frame-generation-boosted output, and labels which measurement tier produced each session; keeping both visible in published material is strongly encouraged.
7A. Your data, unsigned builds, and third parties
- Your recordings are yours to back up. They live in one folder on your PC (
%LOCALAPPDATA%\FrameLedger). A bug, an update, a disk problem or an uninstall can damage or remove them. The developer cannot recover them. - Builds are not code-signed. Windows SmartScreen and antivirus products may warn about or block the installer or
the component loaded into a game. Verify the download against the published
SHA256SUMS.txt; only download from the project's own GitHub Releases page. A build obtained anywhere else is not the developer's and is not covered by anything here. - FrameLedger is not affiliated with any game, publisher, platform, GPU vendor or anti-cheat vendor (§6). None of them supports it. If a game's or a platform's terms forbid third-party software that loads into the game, using FrameLedger with it is your decision and your responsibility.
- Numbers are for your own information. Do not rely on them for a purchase, a warranty claim, a refund dispute, a review you are paid for, or any decision where being wrong costs money, without checking them another way (§4).
8. No professional advice
Nothing in the software or its documentation constitutes professional, legal, or engineering advice.
Contact: contact@poli0981.dev · Developer: https://poli0981.dev/ · Project: https://github.com/poli0981/frameledger