The owner was shown the catalog (140 entries, 110 read) and what the ten entries of reach Spike hold, read from Streamline 2.14.16's own headers, with what reading them takes: none is an export, a game gets each function through slGetFeatureFunction and keeps the pointer, so seeing its calls means handing the game a function of ours in place of Streamline's (rule 4) - and a game that fetched its functions before the attach never calls it. The owner closed it. The ten are RefusedRoute; that reach's sentence names the third refused route in English, Vietnamese and Japanese; the guide no longer says a later release reads more; 18_GPU's inventory, 20_OPEN_QUESTIONS M15 and HANDOFF say train D is not built. Nothing that was read stops being read; no hook, layout, schema or stored value changes. Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
native, fifty-four .editorconfig lines each with its reason, eleven small fixes, nothing changed in code loaded into a game (Qodana PR-2, D99/D100) (#385)
native, fifty-four .editorconfig lines each with its reason, eleven small fixes, nothing changed in code loaded into a game (Qodana PR-2, D99/D100) (#385)
FrameLedger
A local-first game performance ledger for Windows. FrameLedger records frame times, FPS metrics, hardware telemetry, and — crucially — the settings your game is actually rendering with, every time you play. Then it turns your history into charts, so you can see exactly how a patch, a driver update, or a settings change affected performance.
No telemetry. No accounts. All data stays on your machine.
New here? Start with the user guide — install, record a game, read your results, stay safe with anti-cheat, and look after your data, a page each, then every screen, every setting and what to do when something goes wrong. What FrameLedger cannot do is on one page: Limitations. How it works with the keyboard alone, a screen reader or a contrast theme, and how to report a barrier: Accessibility. All three are in the app too (Help ▸ User guide, Help ▸ Limitations, Help ▸ Accessibility), and on the project's wiki with the developer pages.
⚠ What FrameLedger actually measures today — 2026-11-11. The software is a beta; its latest beta is
0.1.0-beta.49(2026-11-14), 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.- 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.
The rows below that describe safety behaviour are qualified where they sit, rather than here, because that is where a reader checking their own risk will look. What this README describes beyond the block above is the finished product; the block is what exists.
What makes it different
Most tools tell you your frame rate. FrameLedger tells you what produced that frame rate:
- Real render resolution vs output resolution — the actual internal resolution, not the one in the settings menu.
- Which upscaler is running — DLSS / FSR, read from the API the game calls, not guessed from files on disk. Intel XeSS is not read: its SDK licence forbids it.
- Frame Generation, measured — native and generated frames counted separately. Shown as
62 → 118 FPS (×1.9 FG)when both are counted, and as a qualified Presented FPS when they are not — never as one inflated number. - Ray tracing, actually detected — including inline ray tracing (DXR 1.1
RayQuery), which frame-counting tools miss entirely. - The game's own VRAM and RAM — Task Manager's figures for the game's process, read from outside the game in every session, with mean, median and peak (since beta.12).
and whether the driver was exceeding its budget— the video-memory budget is not measured yet. - Shader-compilation stutter attribution — which frame spikes were pipeline compiles.
- PC latency when the game uses Reflex.
Plus the usual: Avg / Min / Max / Median FPS, 1% Low, 0.1% Low, frametime distributions, stutter metrics, CPU/GPU temperatures, session history, cross-session comparison, and Steam/GOG/Epic/itch.io/Xbox library import. UI in English / Tiếng Việt / 日本語.
How it works — and the trade-off, stated plainly
None of the settings data above is visible from outside a game process. To read it, FrameLedger loads a component into the game and observes the calls the game makes to graphics APIs — the same class of technique used by frame-rate overlays, recording software, and post-processing injectors. Vulkan titles use a standard Vulkan layer instead, when FrameLedger starts them.
That carries a real risk: anti-cheat systems can detect injected code and may ban accounts.
FrameLedger is built to keep that risk small and to be honest about it:
| Safeguard | |
|---|---|
| Off by default | Injection is disabled for every game until you enable it individually, after a consent prompt |
| Hard refusal | Known anti-cheat/anti-tamper components are detected before injection and every 30 s during a session. Detected ⇒ FrameLedger refuses, or stops capturing at the next scan — so up to 30 s can pass before it reacts to anti-cheat that loads mid-session. For Direct3D/OpenGL that means hooks are removed; for Vulkan it means the layer goes passthrough, because a layer cannot leave the loader chain of a running game. There is no override — not in settings, not in a config file, not on the command line One narrow exception since beta.9 (owner decisions D33, D38): per game, after its own disclosure and only while a Settings option (off by default) is on, a game whose only finding is one anti-cheat that runs entirely in user mode — no driver file in its folder, on no title list — may be hooked under a user-mode exception. legal/DISCLAIMER.md §2A).✅ Both halves run since 2026-09-10. The pre-injection refusal runs every documented check, and during every capture the Agent re-runs them every 30 s: the component inside the game removes its hooks within one frame of being told to, and within 65 s if it stops hearing from the scanner. (Until 2026-09-15 this cell said the in-session re-scan did not run at all, which stopped being true when the Agent's capture loop landed.) For a Vulkan title the stop is the layer's own: it checks the scanner's counter on every present and goes passthrough within one present of the stop flag, or after 65 s without a scan — a title that has stopped presenting is not stopped by that deadline, and presents nothing to be observed either. |
| No evasion, ever | FrameLedger does not hide, rename, obfuscate, or disguise itself. It keeps its real name, real exports, and version info. It is meant to be plainly visible to any security software that looks. This is an architectural rule, not a setting |
| Read-only | It never reads or writes game memory, never modifies game behavior, never touches saves or input, and never changes GPU clocks, fans, or power limits |
| Always a way out | FrameLedger refuses rather than pushes through. When the guard finds anti-cheat, or the hook fails, or you have not enabled a game, it stops — and records the session anyway: start, end, duration, whatever hardware sensors your machine provides, and the reason there is nothing else. Every measured value reads N/A; it never estimates one.The way out is that it does not inject, not that it measures another way. An earlier version of this row promised a no-injection measurement mode. It was designed around Intel PresentMon, that was dropped on 2026-08-27 after measurement, and no replacement was chosen — so frame times require hooking. Said in this row rather than a footnote because the row is in the SAFETY table, and a reader deciding whether to enable a game needs the real alternative, not a comfortable one |
FrameLedger is for offline and single-player games. If you enable it for anything with an online or competitive component, that is your call and your responsibility. The developer cannot reverse a ban. Please read legal/DISCLAIMER.md and docs/19_SAFETY_AND_ANTICHEAT.md before enabling it for anything.
Capture tiers
| Tier | How | What you get |
|---|---|---|
| 1 | Injected hooks (opt-in, per game) | Everything above |
| 2 | None — nothing is injected | Session duration, whatever hardware telemetry your machine can provide, the game's own memory use (read from Windows, outside the game; since beta.12), and why there is nothing else (which check refused, or that the hook failed, was not enabled, or the game is 32-bit). On NVIDIA that telemetry is measured to be GPU temperature, load, power, clocks, VRAM in use and fan speed, with no elevation; AMD and Intel are untested. Everything else reads N/A |
The tier is recorded on every session and shown in the UI. Metrics unavailable at a session's tier read N/A — FrameLedger never substitutes an estimate for a measurement.
This ladder used to have three rungs and a middle one that measured frame times without injecting. It was to be built on Intel PresentMon; that was dropped on 2026-08-27 after measurement, and no replacement was chosen. So frame times, FPS and the lows are now Tier-1-only. Said plainly because the previous README promised them without injection, and a reader who remembers that would otherwise assume it still holds.
Requirements
- Windows 11, 64-bit. Windows 10 (22H2) is not blocked, but FrameLedger is built on .NET 11 since 0.1.0-beta.37, which Microsoft does not support on Windows 10 Home or Pro, and FrameLedger has never been tested there
- A processor with SSE4.2 and POPCNT — any that Windows 11 accepts. Without them FrameLedger does not start
- A 64-bit DirectX 11/12 or OpenGL game, or a Vulkan game FrameLedger starts, for hooked (Tier-1) capture. 32-bit games — including most DirectX 9 titles — cannot be measured at all: the component FrameLedger loads is x64 and an x64 DLL cannot enter a 32-bit process. Such a title records duration and hardware telemetry and nothing else. (This line previously said "supported at Tier 2 only", which meant frame times without injection. That tier no longer exists.)
- Optional: PawnIO for CPU temperature, read only when the Agent runs as administrator (since 0.1.0-beta.3; not yet checked on real hardware). CPU load, memory in use and all GPU telemetry work without it
Elevation is optional — for everything. Hooked capture is the normal path and runs as a standard user, and there is no longer any tier that needs more than that. Elevation unlocks exactly two extras: CPU temperature sensors (not read yet read with PawnIO, not yet checked on real hardware — see the block above), and attaching to games that themselves run elevated. and the Tier-2 ETW fallback. If you expect to rely on Tier 2, run the Agent elevated. — there is no ETW fallback to rely on. Since beta.10 it is a choice in Settings — Run the agent as administrator, off by default: Windows asks every time the agent starts, games you start from FrameLedger still run as you, and LIMITATIONS.md says what it does not change.
Install
The latest beta is
v0.1.0-beta.49(2026-11-14); before itv0.1.0-beta.48(2026-11-14),v0.1.0-beta.47(2026-11-14),v0.1.0-beta.46(2026-11-13),v0.1.0-beta.45(2026-11-12),v0.1.0-beta.44(2026-11-12),v0.1.0-beta.43(2026-11-12),v0.1.0-beta.42(2026-11-12),v0.1.0-beta.41(2026-11-12),v0.1.0-beta.40(2026-11-12),v0.1.0-beta.39(2026-11-11),v0.1.0-beta.38(2026-11-11),v0.1.0-beta.37(2026-11-11),v0.1.0-beta.36(2026-11-10),v0.1.0-beta.35(2026-11-09),v0.1.0-beta.34(2026-11-06),v0.1.0-beta.33(2026-11-03),v0.1.0-beta.32(2026-10-31),v0.1.0-beta.31(2026-10-26),v0.1.0-beta.30(2026-10-26),v0.1.0-beta.29(2026-10-25),v0.1.0-beta.28(2026-10-20),v0.1.0-beta.27(2026-10-20),v0.1.0-beta.26(2026-10-19),v0.1.0-beta.25(2026-10-19),v0.1.0-beta.24(2026-10-19),v0.1.0-beta.23(2026-10-14),v0.1.0-beta.22(2026-10-13),v0.1.0-beta.21(2026-10-13),v0.1.0-beta.20(2026-10-12),v0.1.0-beta.19(2026-10-12),v0.1.0-beta.18(2026-10-07),v0.1.0-beta.17(2026-10-07),v0.1.0-beta.16(2026-10-06),v0.1.0-beta.15(2026-10-06),v0.1.0-beta.14(2026-10-06),v0.1.0-beta.13(2026-10-04),v0.1.0-beta.12(2026-10-04),v0.1.0-beta.11(2026-10-03),v0.1.0-beta.10(2026-09-28),v0.1.0-beta.9(2026-09-26),v0.1.0-beta.8(2026-09-25),v0.1.0-beta.7(2026-09-23),v0.1.0-beta.6(2026-09-23),v0.1.0-beta.5(2026-09-22),v0.1.0-beta.4(2026-09-21),v0.1.0-beta.3(2026-09-21),v0.1.0-beta.2(2026-09-17) andv0.1.0-beta.1(2026-09-16). They are pre-releases: read the notes of the one you install —CHANGELOG.mdlinks each release's own file underdocs/changelog/— for what it measures, what it does not yet, and how to update, before installing. A source build isdocs/12_BUILD.md.
- Download the latest
FrameLedger.App-win-Setup.exefrom Releases. It installs into%LOCALAPPDATA%\FrameLedger.App; your data stays in%LOCALAPPDATA%\FrameLedger, and uninstalling asks before touching it. - SmartScreen may warn — releases are not code-signed (free, open-source project). Verify the SHA-256 checksum published with each release, then More info → Run anyway.
- Follow the first-run Legal Gate and Agent setup. Nothing is injected until you enable it for a specific game.
Privacy
Everything lives locally in %LOCALAPPDATA%\FrameLedger. The only network calls FrameLedger makes are the update check — a few seconds after launch unless you turn it off in Settings ▸ Updates, and when you choose Help ▸ Check for updates — and the download of an update you accepted; both go to GitHub Releases, from an installed copy only, and nothing is applied until you restart (never while a game is hooked). There is no other request: the anti-cheat blocklist and the detection rules ship with the build and update only when you install a new one (docs/20_OPEN_QUESTIONS.md §S20), and nothing is looked up on any store. Bug reports are always built locally, shown to you, and submitted by you. Full policy: legal/PRIVACY_POLICY.md — version 2.2 removed the three rows (a rules feed twice over, a Steam lookup) that earlier versions listed for requests the software never made.
License
GPL-3.0-only (see LICENSE), with the additional terms in NOTICE that GPLv3 section 7 permits: keep the copyright line and the attribution, mark a changed version as changed and do not call it "FrameLedger" alone, and no trademark rights in the name (legal/TRADEMARKS.md). In the app: Help ▸ About. Third-party components: legal/THIRD_PARTY_NOTICES.md.
Reporting a safety gap
If you find a game with anti-cheat that FrameLedger fails to detect, please open an issue with the Safety gap form — that is a safety bug and is treated with the same priority as a security report. A vulnerability in FrameLedger itself takes the private route in SECURITY.md.
How fast a fix can reach you, stated accurately. Blocklist entries are data rather than code, so a fix is a one-line change here. But the software has no rules-update path yet: it installs the blocklist that shipped with your build and never fetches another (docs/20_OPEN_QUESTIONS.md §S20, feed half). Until that exists, a blocklist fix reaches you only when you install a new release. This paragraph previously said the opposite, and the sentence it said it in was a response-time promise attached to a security-priority commitment.
For developers and forks
FrameLedger is GPL-3.0-only free software, and you are welcome to build it, change it and redistribute it.
- Build it:
docs/12_BUILD.md—./build.ps1 checkis the whole quality gate, the same one CI runs. - Contribute:
CONTRIBUTING.md— the definition of done, what will not be merged, and that a contribution is licensed GPL-3.0-only with theNOTICEterms (no CLA). Conduct:CODE_OF_CONDUCT.md. Security reports:SECURITY.md. Accessibility — the goal, the checks and how a barrier is reported:ACCESSIBILITY.md. - Fork or redistribute:
FORKING.md— what the GPL asks of anyone who distributes builds, and the names a fork must change so it does not share FrameLedger's update feed, install folder, data, pipe or Vulkan layer. - Find your way around: the wiki's developer pages are short, and each
links to the document it summarises (
wiki/is their source). - Read the design: the developer documentation is in
docs/. Start withCLAUDE.md, thendocs/19_SAFETY_AND_ANTICHEAT.md— which constrains everything else — thendocs/01_ARCHITECTURE.md.
Architecture
| Component | Runs as | Role |
|---|---|---|
FrameLedger.exe |
Standard user | Fluent desktop UI (WPF + WPF UI), charts, library, settings |
FrameLedger.Agent.exe |
Standard user — as administrator only when you turn that on in Settings, and Windows asks at every start (beta.10) | Injection control, safety guard, data collection, GPU telemetry, storage |
FrameLedger.Overlay.dll |
Inside the game | C++20 hooks + lock-free shared-memory writer. Records only; never analyzes, allocates, or blocks |
FrameLedger.VkLayer.dll |
Inside the game | Vulkan implicit layer (Vulkan titles use this instead of injection) |
GPU telemetry is layered so the project never depends on a proprietary vendor licence: a vendor-neutral DXGI/performance-counter baseline, LibreHardwareMonitor (MPL-2.0) for sensors on all vendors, and NVIDIA's NVAPI SDK (MIT) for NVIDIA-only extras (telemetry and the driver's DLSS record; and, with Advanced metrics on, the driver's own latency report, read inside a Direct3D 12 game that uses NVIDIA Reflex). No Intel or AMD GPU telemetry SDK is bundled — see docs/18_GPU_VENDOR_APIS.md for why. The one AMD component in the tree is five MIT headers from the FidelityFX SDK, used for types only so the upscaler hook can read an FSR title's own dispatch descriptor; nothing AMD-built is linked or redistributed.
Status: pre-release (beta). Twenty-three tagged pre-releases so far; see CHANGELOG.md for what each one changed and the accuracy block at the top of this file for what is and is not measured. It is not feature-complete, it certainly still has bugs, and legal/DISCLAIMER.md §0 says what that means for you.