Compare commits

...
Author SHA1 Message Date
poli0981andClaude Opus 5.5 ea7a3701d8 docs: what FrameLedger cannot do, the games it has been run with, and the legal text for beta.10 - LIMITATIONS.md in the App, the tested-games list, Privacy 2.5, Disclaimer 2.8 (D35, D36)
Item 4 of the owner's beta.10 request (update the docs at the end, add a list of real games tested) and owner decisions
D35 (the list from a COPY of the owner's ledger plus the repository's evidence, reviewed by the owner before commit)
and D36 (legal text where it would become false, and a user-facing LIMITATIONS.md for the whole software).

- LIMITATIONS.md (repository root): the limits of the whole software in the user's words - the games it will not
  measure, an unmeasured session, frame generation, upscaling and ray tracing, the display mode, the engine version,
  sensors, the admin mode, platform and tested hardware, data, installation - each linked to its details. Embedded in
  the App (LimitationsDocument) and shown under Help > Limitations with Open on GitHub; NOT one of FR-11's accepted
  documents. LimitationsDocumentTests: embedded as written, not in LegalDocuments.Keys, every repository link exists.
- docs/LIST_GAME_TESTED.md: 22 games measured hooked, the unmeasured sessions and why, six refused by the guard, and
  the Unreal versions read without running - from a copy of the ledger (read in the scratchpad with Python sqlite3,
  never a FrameLedger binary on the data folder) and spike-notes, CHANGELOG, HANDOFF and the run reports. Approved by
  the owner 2026-09-27, with Alan Wake 2's two 2026-09-04 captures added and UMIGARI kept on its run reports.
- Legal: Privacy Policy 2.5 (a game window's display facts, the Unreal build name, and - first said here - the
  executable's content and the processor/memory counters); Disclaimer 2.8 (section 5A, the admin mode and its risk; the
  limitations page and the list in section 0); the accuracy block dated 2026-09-27 with the display mode, the engine
  version and the admin mode (README and DISCLAIMER copies, accuracy-check green); SECURITY.md's admin-mode reports.
  EULA unchanged (1.3).
- Stale text corrected in place: 19_SAFETY's ETW Tier-2 offer, README's Agent row and elevation paragraph, 04_CAPTURE's
  port list, HANDOFF D11's pipe owner check, 17_HOOK_ENGINE's fault policy (compare-and-restore, not MH_ALL_HOOKS),
  HANDOFF's "Alan Wake 2 did not run on 2026-09-04", and the 18-vs-9 session count recorded rather than guessed.
- HANDOFF: the beta.10 train (D34-D37, what was measured, the traps), owner-only item 7 (beta.10 on real hardware) and
  item 6 done by the ledger's evidence (three GF2 sessions under the exception); CLAUDE.md's reading order names both
  new documents; 08_UI's Help menu; CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-27 23:50:26 +07:00
24 changed files with 539 additions and 27 deletions

No files matched your search

+13
View File
@@ -62,8 +62,21 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
administrator no longer makes the agent an administrator's too. Updating now also waits for an administrator agent's
process to let go of its files.
- **What FrameLedger cannot do, in one place** (beta.10). `LIMITATIONS.md` lists the limits of the whole software in
plain words — the games it will not measure, what an unmeasured session holds, frame generation, upscaling and ray
tracing, the display mode, the engine version, sensors, the admin mode, the platform and your data — each linked to its
details; the app shows it under **Help ▸ Limitations**. `docs/LIST_GAME_TESTED.md` lists the real games FrameLedger has
been run with and what was measured on each.
### Changed
- **The legal documents say what beta.10 does** — you will be shown two of them again once. **Privacy Policy 2.5** adds
how a tracked game's window is shown (read from Windows) and the engine version read from an Unreal Engine game's
executable, and says for the first time two things the software already did: it reads the content of a library game's
executable (engine and library markers, its import table) and the processor load and memory in use. **Disclaimer 2.8**
adds §5A — running the capture agent as administrator, what it does and does not do, and its risk — and points at the
new limitations page and the tested-games list. The End-User License Agreement is unchanged (1.3).
- **Groundwork for the display mode (beta.10): the injected component reports how the game presents** — whether its swap
chain is in exclusive fullscreen, which window it presents to, its back buffer and swap effect — at most twice a second,
from two getters on the swap chain the game passed (measured at 13–15 ns each on the test fixture: nothing a frame rate
+4
View File
@@ -176,6 +176,10 @@ The version handshake is wired end to end as of 2026-08-05: `FlGuardBuildId` giv
8. `docs/18_GPU_VENDOR_APIS.md` — layered GPU telemetry (DXGI/PDH · LHM · NVAPI) + vendor-SDK licence rules
9. `docs/06_DATA_MODEL.md` · `docs/07_IPC.md` · `docs/08_UI.md` · `docs/16_WPFUI_SYNTAX.md`
10. Remaining (`09`–`15`).
11. **`LIMITATIONS.md`** (repository root; shown in the App under Help ▸ Limitations) — what the WHOLE software cannot
do, in the user's words, each item linked to its details. When a change moves a limit, the page changes in the same
PR (D36, 2026-09-27). **`docs/LIST_GAME_TESTED.md`** — the real games FrameLedger has been run with and what each
session measured, from a copy of the owner's ledger and the repository's own evidence (D35).
**Before writing native or capture code, read `docs/20_OPEN_QUESTIONS.md`.** It
lists the defects and gaps that survived the doc audit — things the other
+129
View File
@@ -0,0 +1,129 @@
# What FrameLedger cannot do
FrameLedger measures a game by loading a small component into it — only for a game you added and switched
hooking on for — and reading the graphics calls the game makes. That is why it can tell the real render
resolution, the upscaler, frame generation and ray tracing apart. It is also where its limits come from. This
page lists them in plain words; each item links to the document that has the details.
*Beta software: this page describes version 0.1.0-beta.10.*
## Games it will not measure
- **Games with anti-cheat.** FrameLedger looks for anti-cheat before it touches a game and refuses when it
finds one — there is no switch that overrides this. The one exception is an anti-cheat that runs entirely
inside the game (no driver, no service), which you can allow per game after a warning and two good
sessions; a ban is still possible and may come days later. Kernel anti-cheat is never allowed.
([Safety](docs/19_SAFETY_AND_ANTICHEAT.md))
- **Anti-cheat FrameLedger does not know about.** The list of anti-cheat products is FrameLedger's own and
can be incomplete. A game protected by something unknown may be hooked; that is a risk to your account
that you take by switching hooking on.
- **32-bit games and Direct3D 9 games.** Only 64-bit Direct3D 11, Direct3D 12 and OpenGL games are measured
from their own calls; a 32-bit or Direct3D 9 game is recorded without measurement.
- **Vulkan games, unless FrameLedger starts them.** A Vulkan game is measured only when FrameLedger launches it
with its Vulkan layer switched on; one started another way is not observed by the layer.
- **Games that run as administrator,** unless you turn on *Run the agent as administrator* in Settings
(off by default; Windows asks every time the agent starts). **A process Windows protects** stays closed
either way.
- **Vulkan games that run as administrator.** Windows' Vulkan loader does not load FrameLedger's Vulkan
layer into an elevated game, so admin mode does not help there.
- **A game that was already running when FrameLedger was updated** — restart the game once.
- **Games you did not switch hooking on for.** Adding a game only records its sessions; measuring it is a
separate, per-game choice with its own warning.
## What an unmeasured session contains
When a game is not measured — any of the reasons above — its session still records **how long it ran, the
machine's sensors (GPU temperature, load, power; CPU load; memory) and why nothing was measured.** Every
frame-rate, upscaler, frame-generation and ray-tracing value reads **N/A**, never 0. How the game's window was
shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
## Frame rate and frame generation
- **One inflated number is never shown.** When frame generation is measured, the page shows the game's own
frames and the displayed frames together (`62 → 118 FPS (×1.9 FG)`). When it cannot be measured, the page
shows **Presented FPS** with a sentence saying whether generated frames could be included.
- **Frame generation done by the driver outside the game** (AMD Fluid Motion Frames, NVIDIA Smooth Motion)
is not visible to FrameLedger; the rates shown are what the game presented.
- Frame generation is counted on **Direct3D games** only. DLSS Frame Generation and FSR frame generation are
named from the calls the game makes; any other generator is shown only as *active*, never named, and where
the generated frames cannot be counted the page shows Presented FPS with a note instead of a factor.
- **A session whose frame generation changed** (menus, loading, a settings change) shows the factor of the
state it spent most of its time in, with the share of the session it covers — never an average of the two.
([Metrics](docs/03_METRICS.md))
## Upscaling and ray tracing
- The upscaler is read from the game's calls: DLSS and NIS through NVIDIA Streamline, and FSR through AMD's
FidelityFX libraries. **Intel XeSS is not read** (its licence forbids it), FSR 2 and upscalers built into the
game are not identified, and Vulkan and OpenGL games read N/A. Where no hook saw DLSS but the NVIDIA driver
reports it, the page says it is the driver's report.
- **The quality preset** (Quality, Balanced, …) has not been reported on any game yet, and the render
resolution is N/A where the game's own calls do not carry it (DLSS without Streamline, for one).
- **Ray tracing** is *Yes*, *No* or *N/A* — measured from the game's ray-tracing calls on Direct3D 12, and
N/A where FrameLedger could not look. **Path tracing is never stated as a fact**: there is no API signal
for it. You can correct any of these by hand, and your correction is labelled as yours.
- HDR output, NVIDIA Reflex latency, each game's own video-memory use and shader-compilation stutter are
**not measured yet** — they read N/A. Video memory in use on the whole graphics card is recorded.
([Accuracy](legal/ACCURACY.md))
## Display mode (full-screen, borderless, windowed)
- **Exclusive full-screen is known only for a measured Direct3D (DXGI) game** — the game's own swap chain
says so. For OpenGL, Vulkan and unmeasured games, a window covering the screen reads *Fullscreen or
borderless*, never either one.
- **What Windows does behind the game is not visible:** a game in exclusive full-screen may still be shown
through Windows' compositor ("fullscreen optimizations"), and a game's menu may call a borderless window
"Fullscreen". FrameLedger reports what the game asked for.
- The mode is sampled ten times a second in a measured session and once a second in an unmeasured one; very
short switches can be missed. A session recovered after a crash, and every session recorded before
beta.10, read N/A. ([Display mode](docs/03_METRICS.md#display-mode--both-tiers-beta10))
## Engine version
- The exact version is read for **Unreal Engine 4 and 5** games, from the game's executable file on disk.
A studio can remove or rename what it is read from; then the page says the version was not found.
**Unreal Engine 3 and older are not recognised.** Other engines show a version only where their files
state one. ([Detection](docs/05_DETECTION.md))
## Sensors
- GPU temperature, load, power and memory are best supported on **NVIDIA** GPUs. **AMD and Intel GPUs have
not been tested** on real hardware yet.
- **CPU temperature** needs *Run the agent as administrator* and the separately installed PawnIO driver, and
has not been verified on real hardware yet. CPU load is the time the processor was busy — not Task
Manager's "utility" figure, which can exceed 100%. ([Telemetry](docs/18_GPU_VENDOR_APIS.md))
## Running the agent as administrator
Off by default. When on, **Windows asks every time the agent starts** and names an unknown publisher, because
FrameLedger is not signed. It lets FrameLedger open games that run as administrator and read the CPU
temperature; it does not bypass anti-cheat, does not open protected processes, and does not make games you
start from FrameLedger run as administrator. **The risk:** FrameLedger is installed in your user folder, so a
program running under your account could replace its files and would then run as administrator the next time
you accept the prompt. Turn it on only if you trust everything that runs under your account.
([Architecture, ADR-9](docs/01_ARCHITECTURE.md))
## Platform and what has been tested
- **Windows 10 22H2 or Windows 11, 64-bit only.**
- The games FrameLedger has actually been run with, and what was measured on each, are listed in
[LIST_GAME_TESTED.md](docs/LIST_GAME_TESTED.md). Everything was measured on one machine (an NVIDIA
GeForce RTX 5080 with an Intel Core i7-14700KF on Windows 11); other hardware is untested.
- **No real Vulkan or OpenGL game has been measured yet** — only FrameLedger's own test program.
- There is **no in-game overlay**; everything is shown in the FrameLedger window.
## Your data
- Everything stays on your computer (`%LOCALAPPDATA%\FrameLedger`). FrameLedger sends no telemetry; its only
network requests are the update check and the update download, both to GitHub, and the check can be switched
off. The anti-cheat list and the detection rules ship with each version — **a newer list reaches you only with
the next update.** ([Privacy policy](legal/PRIVACY_POLICY.md))
- Per-frame data is kept for the **last 20 sessions of each game** (configurable); older sessions keep their
summaries.
- A newer version upgrades the database in place, and an **older version cannot open it again** — there is
no downgrade.
## Installation
FrameLedger's programs are **not code-signed**: Windows SmartScreen may warn when you install it, and the
administrator prompt names an unknown publisher. Each release publishes SHA-256 checksums you can compare.
+13 -5
View File
@@ -5,7 +5,7 @@
> No telemetry. No accounts. All data stays on your machine.
<!-- accuracy-block:begin -->
> ⚠ **What FrameLedger actually measures today — 2026-09-26.** The software is a beta; its latest
> ⚠ **What FrameLedger actually measures today — 2026-09-27.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.9`** (2026-09-26), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
@@ -51,6 +51,14 @@
> 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/A` where the executable names none. Other engines show what their own
> files state.
> - **Video memory:** in use on the whole graphics card, recorded from Windows and GPU-driver telemetry
> and charted. **Not measured at all:** each game's own video-memory use and budget, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
@@ -58,8 +66,8 @@
> - **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 with PawnIO installed, and that reading has not yet been checked on real hardware;
> everywhere else it is `N/A`.
> 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`.
> - **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
@@ -130,11 +138,11 @@ The tier is recorded on every session and shown in the UI. Metrics unavailable a
| Component | Runs as | Role |
|---|---|---|
| `FrameLedger.exe` | Standard user | Fluent desktop UI (WPF + [WPF UI](https://github.com/lepoco/wpfui)), charts, library, settings |
| `FrameLedger.Agent.exe` | Standard user (elevation optional) | Injection control, safety guard, data collection, GPU telemetry, storage |
| `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) |
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 — 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.
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.
## Requirements
+12
View File
@@ -40,6 +40,18 @@ driver in its folder, on a title list, or with a second anti-cheat; the Agent wr
without its own tolerant pre-scan and session count; an exception that survives a new finding, a crash or safety stop
under it, or a changed executable; and the Overlay tolerating a family the guard did not.
## Running the agent as administrator
Since 0.1.0-beta.10 the capture agent can run as administrator — an option, off by default (owner decision D34,
`docs/01_ARCHITECTURE.md` ADR-9) — and Windows asks at every start of the agent. The residual risk is stated to the user
rather than solved: FrameLedger installs per user and unsigned, so a program running under the same account could replace
its files and be run as administrator when the user next accepts the prompt. What IS a security report: any way the
agent becomes administrator WITHOUT that prompt (a task, a service, an inherited token the option did not choose); a game
or any other program that an elevated agent starts with its own token instead of the desktop shell's; any privilege the
agent enables (none is — `tools/chokepoint-check.ps1` forbids the enablers under `src/`); an elevated agent that runs for
another account than the one that asked; and a named object an elevated agent creates that the same user's unelevated
processes can no longer open, or that another user can.
## A safety gap — a game with anti-cheat that FrameLedger fails to detect
This is treated with the same priority as a security report, and it takes the **public** route: open
+3 -1
View File
@@ -38,7 +38,9 @@ public interface IFrameSource : IAsyncDisposable
> with `FlGuardBuildId`), `ITargetLivenessSource` (`HeldProcessLivenessSource`, §S29(e)),
> `ITargetResolver` (`TargetResolver`, path only — never a pid), `IProcessLauncher`
> (`ProcessLauncher`, launch mode), `IRuntimeModuleSnapshot`, `INgxDriverProbe`,
> `IExecutableMarkerScan`. `ShmRingReader` itself gains no interface and no second consumer
> ~~`IExecutableMarkerScan`~~ — **corrected 2026-09-27:** the marker scan is the recorder's, not the loop's; the loop's
> later ports are `IKillSwitch` (FR-2.4), `ICapturePauseSource`, `IUserModeExceptionSwitch` and
> `IOverlayToleranceChannel` (D33) and `IDisplayProbe` (beta.10). `ShmRingReader` itself gains no interface and no second consumer
> (`NoSecondRingReaderTests`). A **pure move**: the loop's ordering rules, its tests and the
> capture host's report are byte-for-byte what they were; the host is now a thin shell that
> composes the same objects. What the table below used to call `HookedFrameSource` is this.
+5 -1
View File
@@ -24,7 +24,11 @@ WPF + **WPF UI (Wpf.Ui, Fluent)**. Shell = `ui:FluentWindow` with custom `ui:Tit
**Menu bar**
- **File:** Add game… · Import library (Steam / GOG / Epic / itch.io) · Export ▸ (Session CSV / Session JSON / Chart PNG) · Exit
- **Tools:** Agent status… · Update detection rules · Vulkan layer registration… · Open data folder · Database maintenance…
- **Help:** Check for updates · Report a bug… · Documentation · About FrameLedger (App / Developer / Third-party licenses tabs)
- **Help:** Check for updates · Report a bug… · Documentation · Limitations · About FrameLedger (App / Developer / Third-party licenses tabs)
> **Help ▸ Limitations, beta.10 (D36):** `LIMITATIONS.md` as the build embeds it (`Services.LimitationsDocument`), in a
> read-only, scrolling WPF UI `MessageBox` with *Open on GitHub*. It is information, not one of FR-11's documents:
> nothing is accepted or recorded, and the Disclaimer points at it.
The Menu sits in its own row **below** the TitleBar (never inside the drag region — 16 §Gotchas).
+1 -1
View File
@@ -624,7 +624,7 @@ Every hook body is wrapped:
```
- Any SEH exception inside our code ⇒ increment `faultCount`, record which hook, **return control to the original function** so the game continues.
- 3 faults total ⇒ set `status = self_disabled`, uninstall all hooks (`MH_DisableHook(MH_ALL_HOOKS)`), stop writing, stay dormant. The Agent sees the flag and finalizes the session as `degraded`.
- 3 faults total ⇒ set `status = self_disabled`, ~~uninstall all hooks (`MH_DisableHook(MH_ALL_HOOKS)`)~~ restore each patch's prologue only while its bytes are still our jump (compare-and-restore per patch through `StopObserving`, §Unhooking, §H7 — `MH_ALL_HOOKS` would have removed an overlay chained after us; corrected 2026-09-27), stop writing, stay dormant. The Agent sees the flag and finalizes the session as `degraded`.
- Never `__try` around the call to the original function — only around *our* code, so we never mask a game bug as ours or vice versa.
- The trampoline call to the original is always executed exactly once, on every path, including error paths.
+1 -1
View File
@@ -357,7 +357,7 @@ Implemented in `FrameLedger.Injector` and reached from managed code through a th
> That needs a real game library, and it is a false-refusal path, so it is
> recorded rather than assumed benign.
Any check failing ⇒ **injection is refused**. The UI shows which check fired and offers Tier-2 (ETW) capture instead, which requires no injection — but does require an elevated Agent, so the offer must state that plainly and fall through to Tier 3 rather than appearing to succeed and recording nothing (`04_CAPTURE` §Frame source abstraction).
Any check failing ⇒ **injection is refused**. The UI shows which check fired and ~~offers Tier-2 (ETW) capture instead, which requires no injection — but does require an elevated Agent, so the offer must state that plainly and fall through to Tier 3 rather than appearing to succeed and recording nothing (`04_CAPTURE` §Frame source abstraction)~~ **records the session unmeasured — Tier 2: its duration, the machine's sensors and the reason — which needs no injection and no elevation; there is no ETW rung and no Tier 3 since 2026-08-28** (corrected 2026-09-27: this sentence outlived the ladder it described by a month).
### The payload is checked too, and for a long time it was not
+82 -6
View File
@@ -746,8 +746,11 @@ Cyberpunk 2077 never chains `sl::DLSSOptions`, so 0xFF there is the title's trut
call, and if built, the byte stays 0xFF and the report says *derived*.
- **Do not** reach for `slDLSSSetOptions` via `slGetFeatureFunction`: §2b refused it on five
grounds that have not changed, and NGX-direct `NVSDK_NGX_Parameter_GetUI` is licence-blocked.
- **Alan Wake 2 did not run on 2026-09-04** (the owner tried every workaround; the title is
broken on this machine), so the measurement moved to **Dying Light: The Beast at DLSS**, the
- ~~**Alan Wake 2 did not run on 2026-09-04** (the owner tried every workaround; the title is
broken on this machine)~~ **Corrected 2026-09-27 (owner):** it did run late that evening — the run reports
`alanwake2-224851` and `alanwake2-230707` hold two captures (DLSS + RR, ray tracing *Yes*, 92.52 FPS; then ray
tracing off, Presented 114.52), neither with the quality preset, which is what this item needed. The earlier
attempts that day failed, so the measurement moved to **Dying Light: The Beast at DLSS**, the
first Streamline title measured whose batches carry `kFeatureDLSS` — identity `Dlss` on 4,575
of 4,575 batches. It read `UpscalerParams = 0` on three captures, because DL:TB ships
**Streamline 2.8.0, which deprecates `slSetTag` for `slSetTagForFrame`**, and only the
@@ -1310,9 +1313,13 @@ charts (6) after Games (5) because the summary opens from the Sessions tab; Sett
(`PipeTransmissionMode.Message`, `PipeOptions.Asynchronous | CurrentUserOnly`, remote clients rejected,
two instances), the ACL a `PipeSecurity` of the current user's SID plus Administrators~~ **`CreateNamedPipe`
itself (CsWin32), so the flags and the DACL are stated in code rather than left to a library default:**
message mode, overlapped, `PIPE_REJECT_REMOTE_CLIENTS`, two instances, the SDDL `D:P(A;;GA;;;<user>)(A;;GA;;;BA)`
on every instance, and the client's token user compared to the server's by impersonation on the client's
first frame (the kernel refuses it earlier). The CLIENT uses `PipeOptions.CurrentUserOnly`. *(As built
message mode, overlapped, `PIPE_REJECT_REMOTE_CLIENTS`, two instances, the SDDL ~~`D:P(A;;GA;;;<user>)(A;;GA;;;BA)`~~
`O:<user>D:P(A;;GA;;;<user>)(A;;GA;;;BA)` (the owner stated since 2026-09-17) on every instance, and the client's
token user compared to the server's by impersonation on the client's first frame (the kernel refuses it earlier).
The CLIENT ~~uses `PipeOptions.CurrentUserOnly`~~ checks the pipe's owner against its own token USER
(`PipeAccessControl.RequireOwnedByCurrentUser`, 2026-09-17) — `CurrentUserOnly` compares the token's default owner,
which an elevated token sets to Administrators, and refused the same user's Agent across elevation (corrected
2026-09-27). *(As built
2026-09-13; the wording above was the plan's, kept struck because it named a library path the build did not
take.)* Framing is
`07_IPC` §C as written: 4-byte LE length + UTF-8 JSON ≤ 1 MB, `Shared.Ipc.IpcEnvelope { type, id?, payload }`,
@@ -1687,6 +1694,63 @@ invisible to every check.
- **CA1711 rejects a type whose name ends in `Exception`**: the rules class is `UserModeExceptionRules`, the reasons
`UserModeExceptionLapse`.
## 2026-09-27 — the beta.10 train: the display mode, the admin mode, the Unreal Engine version
*Status is `CHANGELOG.md` `[0.1.0-beta.10]`; this is what no other file carries. The approved plan was six PRs:
PR-1 the Unreal version (schema 0015), PR-2 the Overlay's display region (shared-memory layout 4), PR-3 the display mode
in the Agent and the App (schema 0016), PR-4 the admin mode, PR-5 docs, legal text and the tested-games list, PR-6 the
release.*
**Decisions (owner, 2026-09-27, asked before the plan — do not re-ask):**
- **D34 — the admin mode asks Windows at EVERY Agent start.** The UAC prompt appears whenever the Agent starts with
`capture.run_elevated` on — owned by the App's window when the App starts it, flashing on the taskbar when the logon
task does. No "highest privileges" task, no service, no silent path. Games an elevated Agent starts get the desktop
shell's token. The elevated Agent is started for one user (`--for-user <SID>`) and exits 11 as any other account.
- **D35 — the tested-games list comes from a COPY of the owner's ledger** (scratchpad, Python `sqlite3`; never a
FrameLedger binary against the data folder) plus the repository's own evidence, and **the owner reviews it before it
is committed** — the repository is public.
- **D36 — legal text changes where it would become false** (Privacy 2.5, Disclaimer 2.8; EULA stays 1.3), **and
`LIMITATIONS.md` exists**: a user-facing list of what the WHOLE software cannot do, at the repository root and in the
App under Help ▸ Limitations — not one of FR-11's accepted documents (the Legal Gate records an acceptance per
document, and this is information, not terms).
- **D37 — each PR merges when its CI is green**, then the release PR and the GPG-signed tag.
**What was measured before it was written:**
- **Unreal versions, ten installed titles, read-only** (`spike-notes` §15): eight read (4.26.1 … 5.5.4), two honestly
none (Cronos demo, Rune Factory). Black Myth: Wukong's executable is protected (`.rdata` empty) and its build name sits
in `.code` — the whole-file fallback read it in 7.5 s from the owner's USB drive.
- **The display region's cost** (hook-harness `--probe-frames`, WARP): `GetFullscreenState` 12.6–13.1 ns, `GetDesc`
13.6–14.5 ns per call, at most twice a second per swap chain.
**Traps met on the way:**
- **A test run reseeds the rules file in the REAL data folder** (`RulesSeeder` in the integration tests writes
`%LOCALAPPDATA%\FrameLedger\rules`). PR-1's rules `2026.09.6` carry an extractor type (`unreal_build`) the installed
beta.9 cannot parse: its detection sweep says "rules unusable" until that Agent restarts — its seeder sees a file it
wrote itself (the marker's hash) and puts its own back — or beta.10 is installed. The guard reads the same file and is
unaffected (it ignores version extractors). Worth a scratch rules folder for the tests one day.
- **`DXGI_SWAP_EFFECT_DISCARD` is 0** — region 4 stores the effect plus one, the vendor-zero trap.
- **A minimised game presents only what the hook drops** (occlusion probes): a region-4 sample older than 2 s says
nothing about exclusivity now; the Agent keeps its window and drops its exclusive bits.
- **The Agent is DPI-unaware**: Windows scales another process's window coordinates for it. The window reader switches
its thread to per-monitor-aware (V2) for the calls and back.
- **A Tier-2 session never reaches the aggregator** — display columns live on the recorder's skeleton, or a Tier-2 row
would carry none.
- **`SessionRowColumns` is generated by a script that is not in the repository** — edit it by hand, by name.
- **`CreateProcessWithTokenW` needs `SeImpersonatePrivilege`**, which an unelevated (filtered) token does not hold: the
shell-token start is testable only on the elevated CI runner, and a runner with UAC off has an elevated shell — so the
test compares the child's elevation with the SHELL's, never with "unelevated".
- **An elevated token's default DACL omits the user** (again): the ledger's migration lock is now a `SharedMutex` with a
stated descriptor; the instance lock and the elevation marker are only probed, and a refused probe reads as held.
- **`CA2025` flags a disposable handed to an un-awaited task** even when ownership moves to it; the launcher says so in
a suppression with its reason, or splits the method so the analyzer can see it.
- **Heredocs mangle backslashes and `\a`** (`D:\another` became `D:<BEL>nother` in a test). Patch scripts are written
with the Write tool and run by path; a scan for control characters before the gate catches the rest.
**Owner-only, added to the list below:** item 7.
## Owner-only — no PR can close these
1. **§S23-2 — branch protection.** `Rules / validate` is not a required status check on
@@ -1712,11 +1776,23 @@ invisible to every check.
5. **Re-ratify §S18 blocker 3 and §S27's basis** once P2's PR-C/PR-F make the Agent the shipped
injecting entry point (§P2, decision D4). The PRs restate both entries; whether the
restatement stands is the owner's.
6. **D33's first real use (beta.9).** Turn the option on; GIRLS' FRONTLINE 2 should be listed eligible (NetEase
6. ~~**D33's first real use (beta.9).**~~ **Done by 2026-09-27, read from a copy of the owner's ledger:** three normal
hooked sessions of GIRLS' FRONTLINE 2 under the exception (NetEase Yidun) on 2026-09-26 and 09-27, the longest
3 h 9 min; the `ja` review below is still owed. *(The item as written:)* Turn the option on; GIRLS' FRONTLINE 2 should be listed eligible (NetEase
Yidun, `NEP2.dll`, three sessions); make the exception, turn hooking on and play one session: hooked, marked
*Hooked · exception*, not stopped by the 30 s re-scan or by the Overlay when `NEP2.dll` loads. Aniimo should read
*not eligible* with its `NEPKernel.sys`; the option off makes the next session Tier 2 with the exception kept. And
the `ja` text of `Safety_Exception_*`, which ships as English until a reviewer signs.
7. **beta.10 on real hardware.** (a) **The display mode:** one DXGI game taken through exclusive full-screen →
borderless → windowed in one session — the summary's shares, the Sessions column, the Trend's three share metrics —
with a note of what the game's own menu called each mode. (b) **The admin mode:** turn it on → the disclosure → the
UAC prompt → Settings says *Running elevated*; decline it → *the administrator prompt was declined*; sign out and in
with the logon task → the prompt waits on the taskbar and one Agent results; start a game from FrameLedger while
elevated → Task Manager's *Elevated* column says *No*; a game that runs as administrator → hooked; the CPU temperature
with PawnIO (closes §M10 if it reads). (c) **The Unreal Engine version** on each Unreal game's page. (d) The Legal
Gate shows Privacy 2.5 and Disclaimer 2.8 once. (e) The `ja` text of `Safety_AdminMode_*`, English until reviewed.
(f) `docs/LIST_GAME_TESTED.md` — reviewed and approved by the owner before it was committed (D35, 2026-09-27);
keep it current as games are run.
**Answered 2026-08-05, do not re-ask:** remove `gameguard` and keep `guard` (approved
over a red `Rules` gate, with the reasoning recorded in the merge commit); vendor NVAPI
+71
View File
@@ -0,0 +1,71 @@
# Games FrameLedger has been run with
*As of 2026-09-27 (0.1.0-beta.10). Built from a copy of the developer's own FrameLedger database and the repository's
measurement notes, and reviewed by the project's owner before it was published. It lists what happened on one machine;
it promises nothing about any other.*
**The machine.** Every row below was run on one PC: an NVIDIA GeForce RTX 5080 (the only graphics card), an Intel Core
i7-14700KF, 32 GB of DDR5, Windows 11 (Insider builds 26300 → 29648) and a 2560×1440, 240 Hz monitor. **No AMD or Intel
graphics card and no second machine has been tested**, and **no real Vulkan or OpenGL game has been measured** — every
measurement below is Direct3D 11 or 12. What the tiers mean and what FrameLedger cannot do: [LIMITATIONS.md](../LIMITATIONS.md).
**Two periods.** From 2026-08-03 to 2026-09-06 the games were measured with the developer's capture tool, one run at a
time against the game's own settings menu (reports in [spike-notes.md](spike-notes.md)). From 2026-09-16 the shipped
app and agent recorded them as a user would; the database holds the sessions from 2026-09-22 on — earlier ones went
with the 2026-09-16 recovery and with library entries removed since.
## Measured — hooked (Tier 1)
| Game | Engine | API | What was measured | When | Evidence |
|---|---|---|---|---|---|
| Cyberpunk 2077 | — | D3D12 | DLSS Balanced 1485×835 → 2560×1440, exact against its settings file; DLSS Frame Generation off ×1.00, ×3 (61.4 → 183.5 FPS), ×4 (58.7 → 234.1); FSR 3 + FSR frame generation ×2 (74.3 → 148.6); ray tracing *Yes* with path tracing on and *No* with it off, as set | 2026-08-15 → 09-05, about 25 runs | [spike-notes §8, §9, §11](spike-notes.md) |
| Dying Light: The Beast | — | D3D12 | DLSS Frame Generation ×4: Native 70.5 → Displayed 282.1 FPS, counted through DXGI; FSR + FSR frame generation ×2 (70.5 → 140.9); ray tracing *Yes* | 2026-09-04 → 09-06 | [spike-notes §9](spike-notes.md), [03_METRICS §Frame Generation](03_METRICS.md) |
| Hell Is Us | Unreal Engine 5.5.4 | D3D12 | DLSS Frame Generation ×4 (76.5 → 306.2); DLSS shown as *driver-reported* (it bypasses Streamline); FSR + FSR frame generation ×2 (85.7 → 171.4); XeSS frame generation shown as Presented FPS only; ray tracing *No* | 2026-09-03 → 09-16 | [spike-notes §8, §9](spike-notes.md) |
| Black Myth: Wukong | Unreal Engine 5.0.0 | D3D12 | DLSS Frame Generation ×4 (55.4 → 221.5); ray tracing *Yes* (16.2 % of frames in the app's session); a session that changed state showed its steady state (×4.1) instead of an average | 2026-08-20 → 09-16 | [spike-notes §9, §14](spike-notes.md) |
| Clair Obscur: Expedition 33 | Unreal Engine 5.4.4 | D3D12 | DLSS + Frame Generation ×4 (54.9 → 218.4) and ×2 (76.0 → 149.8); frame generation off read *none*, with DXGI agreeing; ray tracing *No* | 2026-09-04 → 09-06 | [spike-notes §9](spike-notes.md) |
| Rune Factory: Guardians of Azuma | Unreal Engine (version not in the executable) | D3D12 | DLSS Frame Generation ×4 (128.9 → 513.0); FSR frame generation compiled into the game counted ×2 but not named; ray tracing *No* (the game has none) | 2026-08-20 → 09-06 | [spike-notes §9](spike-notes.md) |
| Kingdom Come: Deliverance II | — | D3D12 | FSR (3.1 or 4) at 1505×847 → 2560×1440; frame generation *none* (the game ships none); ray tracing *No* | 2026-09-04 | [spike-notes §9](spike-notes.md) |
| Lies of P | Unreal Engine 4.27.2 | D3D12 | FSR 3 at 1506×848 → 2560×1440 with FSR frame generation ×2.04 (57.1 → 116.4) in the app; frame generation off read *none*; DLSS shown as *driver-reported*; ray tracing *No* | 2026-08-03 → 09-16 | [spike-notes §7, §9, §14](spike-notes.md) |
| Onimusha: Way of the Sword (demo) | RE Engine | D3D12 | DLSS + DLSS Frame Generation: ×3.67 and ×3.93 with the capture tool, ×4.00 in the app's steady state (60 → 240 FPS), ×3.0 (60 → 180) in the app on 2026-09-22; ray tracing *Yes* | 2026-09-05 → 09-22 | [spike-notes §9, §14](spike-notes.md), database |
| Cronos: The New Dawn (demo) | Unreal Engine (version not in the executable) | D3D12 | DLSS with frame generation off (105 FPS, *none*); on ×2 (86.8 → 172.7), DLSS Frame Generation named; ray tracing *Yes* | 2026-09-06 → 09-16 | [spike-notes §9, §14](spike-notes.md) |
| Alan Wake 2 | — | D3D12 | Path tracing Ultra with DLSS and Ray Reconstruction: ray tracing *Yes* (96.8 % of frames), frame generation read ×1.00 (the game did not apply the setting that run). On 2026-09-04: DLSS with ray tracing *Yes* (99 % of frames), 92.5 FPS, frame generation *none* by count; then ray tracing off (*No*), DLSS, Presented 114.5 FPS. The quality preset was never read | 2026-08-04 → 09-04 | [spike-notes §8](spike-notes.md), run reports |
| SILENT HILL 2 | Unreal Engine 5.1 | D3D12 | DLSS Frame Generation identified, frames not counted (Presented 78 FPS); DLSS *driver-reported*; ray tracing *Yes* | 2026-09-25 | database |
| DARK SOULS III | FromSoftware | D3D11 | Presented 59.8 FPS; no upscaler, frame generation or ray tracing loaded | 2026-09-03 | [spike-notes §9](spike-notes.md) |
| Sekiro: Shadows Die Twice | FromSoftware | D3D11 | Presented 60 FPS (the game's cap), two sessions of 15 min and 2 h 18 min | 2026-09-26 | database |
| Yu-Gi-Oh! Master Duel | Unity 6000.0 | D3D11 | Presented 239 FPS across six sessions (up to 5 h 25 min) | 2026-09-22 → 09-25 | database |
| GIRLS' FRONTLINE 2: EXILIUM | Unity 2019.4 | D3D11 | Presented 53–101 FPS; the last three sessions under the user-mode anti-cheat exception (NetEase Yidun), one of them 3 h 9 min, all ended normally | 2026-09-21 → 09-27 | database, [HANDOFF](HANDOFF.md) |
| Aniimo | Unity 2022.3 | D3D12 | DLSS at 1707×960 → 2560×1440, frame generation *none* (×1.00, 205 FPS), ray tracing *No* — then blocked (below) | 2026-09-22 | database |
| AbyssMemory | Unreal Engine 4.26.1 | D3D11 | Presented 55 FPS, one short session | 2026-09-22 | database |
| Umamusume: Pretty Derby | Unity 2022.3 | D3D11 | Presented 37 FPS, one session | 2026-09-27 | database |
| 恋しかるべき (KOISHIKARUBEKI) | Unity 6000.3 | D3D11 | Presented 59.6 FPS | 2026-09-03 | [spike-notes §9](spike-notes.md) |
| Flower in Us | RPG Maker MV/MZ (NW.js) | D3D11 | Presented 59.8 FPS over three swap chains, after two refusals that found the game's browser process ambiguous (fixed) | 2026-09-03 → 09-04 | [spike-notes §9](spike-notes.md) |
| UMIGARI | Unreal Engine 5.5.4 | D3D12 | Presented 95–97 FPS, frame generation *none*, ray tracing *No* | 2026-09-05 → 09-06 | run reports only |
## Recorded without measurement (Tier 2)
| Game | Why nothing was measured | When | Evidence |
|---|---|---|---|
| HELLO, HELLO WORLD! | A 32-bit game (RPG Maker MV): refused by the guard once, and two sessions with hooking switched off — each recorded with its duration and sensors | 2026-09-23 | database |
| Umamusume: Pretty Derby | Three sessions played with hooking switched off for the game | 2026-09-27 | database |
| Sekiro: Shadows Die Twice | One session played with hooking switched off | 2026-09-25 | database |
| GIRLS' FRONTLINE 2: EXILIUM | One session whose process Windows would not let FrameLedger open, and two recovered after the agent itself stopped mid-session (*interrupted*) | 2026-09-22 → 09-23 | database |
## Refused by the anti-cheat guard
| Game | What was found | When | Evidence |
|---|---|---|---|
| ELDEN RING | Easy Anti-Cheat: its folder, and a process Windows would not let FrameLedger open. Nothing was ever injected; eight sessions recorded without measurement | 2026-09-21 → 09-27 | [CHANGELOG](../CHANGELOG.md), database |
| GIRLS' FRONTLINE 2: EXILIUM | NetEase Yidun (`NEP2.dll`, user mode) — turned hooking off after it had been measured; measured again since 2026-09-26 under the user-mode exception its owner made | 2026-09-25 | [19_SAFETY](19_SAFETY_AND_ANTICHEAT.md) |
| Aniimo | NetEase Yidun with a kernel driver (`NEPKernel.sys`) in the game's folder — never eligible for an exception | 2026-09-25 | [19_SAFETY](19_SAFETY_AND_ANTICHEAT.md) |
| Goose Goose Duck | Easy Anti-Cheat's service running, and its folder | 2026-08-04 | [spike-notes §13](spike-notes.md) |
| Neverness To Everness | Anti-Cheat Expert's kernel driver in the game's folder | 2026-08-04 | [spike-notes §13](spike-notes.md) |
| Counter-Strike 2 | Valve Anti-Cheat — refused by FrameLedger's title list since beta.8. On 2026-08-04 the checks alone allowed it (VAC is invisible to them); nothing was injected | 2026-08-04, beta.8 | [spike-notes §13](spike-notes.md), [19_SAFETY](19_SAFETY_AND_ANTICHEAT.md) |
Also refused before any injection: **Deadly Heart Gambit** — a 32-bit game (2026-08-03).
## Engine version read from the executable only
The Unreal Engine version (beta.10) was checked against ten installed Unreal games without running them: Hell Is Us
5.5.4, Black Myth: Wukong 5.0.0, Clair Obscur: Expedition 33 5.4.4, Lies of P 4.27.2, SILENT HILL 2 5.1, UMIGARI 5.5.4,
AbyssMemory 4.26.1, **Martha Is Dead 4.27.0**; Cronos (demo) and Rune Factory name no version in their executables and
read *not found*. ([spike-notes §15](spike-notes.md), [05_DETECTION §Engine version](05_DETECTION.md))
+3 -1
View File
@@ -2489,7 +2489,9 @@ FrameLedger.Agent --console sessions --last 1
```
**The row half is read — 2026-09-16, the shipped Agent, not the console.** The owner ran the App with its `--serve`
Agent for an afternoon (18 hooked sessions, attach mode, `late_attach = 1`, every one watcher-driven from a Steam
Agent for an afternoon (18 hooked sessions — **count note, 2026-09-27:** `CHANGELOG` 2026-09-17 says *all nine hooked
sessions of 2026-09-16*; neither count was re-made when the other was written, and the ledger as it stands today holds no
session from that day, so the discrepancy is recorded rather than resolved — attach mode, `late_attach = 1`, every one watcher-driven from a Steam
launch rather than the `launch` verb above — a Steam title started from its Shipping executable relaunches through
Steam, so the console recipe is the wrong vehicle for a Steam library and the product's own path is the right one).
`sessions.id = 10`, **Lies of P**, 16:11, 147 s, `d3d12`, 16,221 frames, `guard_ticks_published = 5`, Overlay
+11 -3
View File
@@ -11,7 +11,7 @@
that changes what FrameLedger.Overlay or the capture host does; date the change.
HTML comments are not part of the block.
-->
> ⚠ **What FrameLedger actually measures today — 2026-09-26.** The software is a beta; its latest
> ⚠ **What FrameLedger actually measures today — 2026-09-27.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.9`** (2026-09-26), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
@@ -57,6 +57,14 @@
> 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/A` where the executable names none. Other engines show what their own
> files state.
> - **Video memory:** in use on the whole graphics card, recorded from Windows and GPU-driver telemetry
> and charted. **Not measured at all:** each game's own video-memory use and budget, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
@@ -64,8 +72,8 @@
> - **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 with PawnIO installed, and that reading has not yet been checked on real hardware;
> everywhere else it is `N/A`.
> 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`.
> - **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
+30 -5
View File
@@ -1,6 +1,6 @@
# FrameLedger — Disclaimer
**Version:** 2.7 · **Effective:** {{RELEASE_DATE}}
**Version:** 2.8 · **Effective:** {{RELEASE_DATE}}
> **How this document is kept true.** The statement of what FrameLedger measures (§4) is `legal/ACCURACY.md`,
> embedded here and in `README.md` and bound to its source by `tools/accuracy-check.ps1`, which fails the build when a
@@ -11,7 +11,9 @@
## 0. This is pre-release (beta) software
**FrameLedger is a beta.** Every build published so far is a pre-release. It has been tested on a small number of
machines and games, and **it certainly still contains bugs — some of them not yet known to anyone.** Features can
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.
@@ -112,7 +114,7 @@ Software running inside another process can, in principle, destabilize it. Frame
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**:
<!-- accuracy-block:begin -->
> ⚠ **What FrameLedger actually measures today — 2026-09-26.** The software is a beta; its latest
> ⚠ **What FrameLedger actually measures today — 2026-09-27.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.9`** (2026-09-26), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
@@ -158,6 +160,14 @@ Frame timing is derived from high-resolution timestamps taken at the moment the
> 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/A` where the executable names none. Other engines show what their own
> files state.
> - **Video memory:** in use on the whole graphics card, recorded from Windows and GPU-driver telemetry
> and charted. **Not measured at all:** each game's own video-memory use and budget, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
@@ -165,8 +175,8 @@ Frame timing is derived from high-resolution timestamps taken at the moment the
> - **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 with PawnIO installed, and that reading has not yet been checked on real hardware;
> everywhere else it is `N/A`.
> 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`.
> - **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
@@ -210,6 +220,21 @@ be the difference between a game that runs and one that does not. Turn hooking o
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 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 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.
+5 -3
View File
@@ -1,6 +1,6 @@
# FrameLedger — Privacy Policy
**Version:** 2.4 · **Effective:** {{RELEASE_DATE}}
**Version:** 2.5 · **Effective:** {{RELEASE_DATE}}
**Short version: everything stays on your PC. FrameLedger has no accounts, no telemetry, no analytics, and never uploads your data anywhere.**
@@ -9,7 +9,7 @@
Stored in `%LOCALAPPDATA%\FrameLedger` on your device:
- Your game library entries (names, executable paths, metadata you or the app filled in, and whether each one is recorded).
- Performance sessions: frame timing series, computed statistics, hardware sensor series (temperatures, load, memory usage), session duration, crash flags, the graphics driver's settings the game ran under (NVIDIA only), tags and notes you write.
- Performance sessions: frame timing series, computed statistics, hardware sensor series (temperatures, load, memory usage), session duration, crash flags, the graphics driver's settings the game ran under (NVIDIA only), how the game's window was shown (full-screen, borderless or windowed, for how long, its size and the monitor's), tags and notes you write.
- A hardware snapshot per session (CPU/GPU model, driver version, RAM size, OS build, display mode) used for the "what changed between sessions" feature.
- App settings, logs (rotated daily — the app keeps 7 days, the capture agent 14 — including the logs written by the component loaded into games), and, after a crash of the app itself, crash dump files.
- Which games you enabled code injection for, and when you consented.
@@ -37,13 +37,15 @@ The "Report a bug" feature builds a zip file **on your device**, shows you exact
## 4. What the app can technically observe
To do its job, FrameLedger observes: which of *your tracked* executables — the entries in your library whose recording is on — are running, and their process trees; the parameters your games pass to the graphics APIs it intercepts (presentation, upscaling, ray tracing, pipeline creation); video-memory usage reported by the graphics runtime; loaded module names of a game being captured (for detection and for the anti-cheat safety check); the names of the files in each library game's install folder, the version information of its executable and of the upscaling libraries it ships, and the store files that name it (Steam's and GOG's, on your disk) — to detect its engine and features and to check it for anti-cheat before any injection is possible; the NVIDIA driver's settings for your tracked executables (read only: the DLSS and frame-generation overrides the NVIDIA App set); and hardware sensor values from your graphics driver's own libraries.
To do its job, FrameLedger observes: which of *your tracked* executables — the entries in your library whose recording is on — are running, and their process trees; the parameters your games pass to the graphics APIs it intercepts (presentation, upscaling, ray tracing, pipeline creation); video-memory usage reported by the graphics runtime; loaded module names of a game being captured (for detection and for the anti-cheat safety check); the names of the files in each library game's install folder, the version information of its executable and of the upscaling libraries it ships, the content of its executable file (the markers of the engine and of the graphics libraries it carries, the libraries it imports, and the engine build name an Unreal Engine game carries), and the store files that name it (Steam's and GOG's, on your disk) — to detect its engine, its engine version and its features and to check it for anti-cheat before any injection is possible; the size, position and state of a tracked game's window and the monitor it is on, read from Windows and not from the game, and — for a game FrameLedger injects into — whether the game asked for exclusive full-screen; the NVIDIA driver's settings for your tracked executables (read only: the DLSS and frame-generation overrides the NVIDIA App set); hardware sensor values from your graphics driver's own libraries; and how busy the processor is and how much memory is in use, from Windows' own counters.
It does **not** read game memory outside those API parameters, and does not read game saves, chat, input content, network traffic, or anything unrelated to performance measurement. It records only for programs you added to your library and did not switch recording off for — a program whose recording is off is not watched at all — and injects only into games you individually enabled.
> **History.** Version 2.3 (2026-09-23) adds the per-entry recording switch. Before it, every program in your library was recorded whenever it ran, which recorded a utility that starts with Windows at every boot.
>
> Version 2.4 (2026-09-25, 0.1.0-beta.8) names what the software reads to check every game in your library for anti-cheat — until then it checked only a game you asked to hook — and to name the versions of its files, and the NVIDIA driver's settings for your games. The files of a library game's folder were already read to detect its engine and features; this version is the first to say so.
>
> Version 2.5 (2026-09-27, 0.1.0-beta.10) adds how a tracked game's window is shown — read from Windows — and the engine build name read from an Unreal Engine game's executable. It is also the first version to say two things the software already did: it reads the **content** of a library game's executable (markers in its first 8 MB and its import table, since the detection of engines and features; and, when a session starts, the graphics-library markers in the whole file), and it reads the processor load and the memory in use (since 0.1.0-beta.3). Nothing here leaves your device, as before.
All of this stays on your device. None of it is transmitted anywhere.
@@ -45,6 +45,8 @@
<EmbeddedResource Include="..\..\legal\DISCLAIMER.md" LogicalName="legal/DISCLAIMER.md" />
<EmbeddedResource Include="..\..\legal\PRIVACY_POLICY.md" LogicalName="legal/PRIVACY_POLICY.md" />
<EmbeddedResource Include="..\..\LICENSE" LogicalName="LICENSE" />
<!-- beta.10 (D36): what the whole software cannot do, shown under Help > Limitations; information, not one of FR-11's accepted documents. -->
<EmbeddedResource Include="..\..\LIMITATIONS.md" LogicalName="LIMITATIONS.md" />
</ItemGroup>
<ItemGroup>
+1
View File
@@ -71,6 +71,7 @@
<MenuItem Header="{x:Static res:Strings.Menu_Help_CheckUpdates}" Command="{Binding ViewModel.CheckForUpdatesCommand}" />
<MenuItem Header="{x:Static res:Strings.Menu_Help_ReportBug}" Command="{Binding ViewModel.ReportBugCommand}" />
<MenuItem Header="{x:Static res:Strings.Menu_Help_Documentation}" Command="{Binding ViewModel.DocumentationCommand}" />
<MenuItem Header="{x:Static res:Strings.Menu_Help_Limitations}" Command="{Binding ViewModel.LimitationsCommand}" />
<Separator />
<MenuItem Header="{x:Static res:Strings.Menu_Help_About}" Command="{Binding ViewModel.AboutCommand}" />
</MenuItem>
@@ -0,0 +1,31 @@
using System.IO;
namespace FrameLedger.App.Services;
/// <summary>
/// <c>LIMITATIONS.md</c> (beta.10, owner decision D36): what the whole software cannot do, in the user's terms — embedded at
/// build time from the repository root and shown under Help ▸ Limitations, so the App shows exactly the text this build
/// was reviewed with.
/// </summary>
/// <remarks>
/// <b>Information, not terms.</b> It is NOT one of FR-11's documents (<see cref="LegalDocuments.Keys"/>): the Legal Gate
/// records an acceptance per document it shows, and nothing here is accepted. The Disclaimer points at it instead.
/// </remarks>
public static class LimitationsDocument
{
/// <summary>The embedded resource's name (<c>FrameLedger.App.csproj</c>).</summary>
public const string ResourceName = "LIMITATIONS.md";
/// <summary>The same text in the repository, for the dialog's button.</summary>
public static readonly Uri OnGitHub = new(IssueLink.Repository + "/blob/main/LIMITATIONS.md");
/// <summary>The document's text, authoring comments removed.</summary>
/// <exception cref="InvalidOperationException">The build did not embed it.</exception>
public static string Load()
{
using Stream stream = typeof(LimitationsDocument).Assembly.GetManifestResourceStream(ResourceName)
?? throw new InvalidOperationException($"the build did not embed {ResourceName}");
using var reader = new StreamReader(stream);
return LegalDocuments.StripComments(reader.ReadToEnd());
}
}
+9
View File
@@ -487,6 +487,8 @@ public static class Strings
nameof(Launch_Error_740),
nameof(Launch_Error_Format),
nameof(Launch_Failed_Format),
nameof(Limitations_OnGitHub),
nameof(Limitations_Title),
nameof(Logs_Bundle_Exported_Format),
nameof(Logs_Bundle_Failed_Format),
nameof(Logs_Empty),
@@ -545,6 +547,7 @@ public static class Strings
nameof(Menu_Help_About),
nameof(Menu_Help_CheckUpdates),
nameof(Menu_Help_Documentation),
nameof(Menu_Help_Limitations),
nameof(Menu_Help_ReportBug),
nameof(Menu_Tools),
nameof(Menu_Tools_AgentStatus),
@@ -1801,6 +1804,10 @@ public static class Strings
public static string Launch_Failed_Format => ResourceManager.GetString(nameof(Launch_Failed_Format), Culture) ?? nameof(Launch_Failed_Format);
public static string Limitations_OnGitHub => ResourceManager.GetString(nameof(Limitations_OnGitHub), Culture) ?? nameof(Limitations_OnGitHub);
public static string Limitations_Title => ResourceManager.GetString(nameof(Limitations_Title), Culture) ?? nameof(Limitations_Title);
public static string Logs_Bundle_Exported_Format => ResourceManager.GetString(nameof(Logs_Bundle_Exported_Format), Culture) ?? nameof(Logs_Bundle_Exported_Format);
public static string Logs_Bundle_Failed_Format => ResourceManager.GetString(nameof(Logs_Bundle_Failed_Format), Culture) ?? nameof(Logs_Bundle_Failed_Format);
@@ -1917,6 +1924,8 @@ public static class Strings
public static string Menu_Help_Documentation => ResourceManager.GetString(nameof(Menu_Help_Documentation), Culture) ?? nameof(Menu_Help_Documentation);
public static string Menu_Help_Limitations => ResourceManager.GetString(nameof(Menu_Help_Limitations), Culture) ?? nameof(Menu_Help_Limitations);
public static string Menu_Help_ReportBug => ResourceManager.GetString(nameof(Menu_Help_ReportBug), Culture) ?? nameof(Menu_Help_ReportBug);
public static string Menu_Tools => ResourceManager.GetString(nameof(Menu_Tools), Culture) ?? nameof(Menu_Tools);
+12
View File
@@ -309,6 +309,18 @@
<value>ドキュメント</value>
<comment>review</comment>
</data>
<data name="Menu_Help_Limitations" xml:space="preserve">
<value>制限事項</value>
<comment>review</comment>
</data>
<data name="Limitations_Title" xml:space="preserve">
<value>FrameLedger にできないこと</value>
<comment>review</comment>
</data>
<data name="Limitations_OnGitHub" xml:space="preserve">
<value>GitHub で開く</value>
<comment>review</comment>
</data>
<data name="Menu_Help_ReportBug" xml:space="preserve">
<value>不具合を報告…</value>
<comment>review</comment>
+9
View File
@@ -237,6 +237,15 @@
<data name="Menu_Help_Documentation" xml:space="preserve">
<value>Documentation</value>
</data>
<data name="Menu_Help_Limitations" xml:space="preserve">
<value>Limitations</value>
</data>
<data name="Limitations_Title" xml:space="preserve">
<value>What FrameLedger cannot do</value>
</data>
<data name="Limitations_OnGitHub" xml:space="preserve">
<value>Open on GitHub</value>
</data>
<data name="Menu_Help_ReportBug" xml:space="preserve">
<value>Report a bug…</value>
</data>
+9
View File
@@ -232,6 +232,15 @@
<data name="Menu_Help_Documentation" xml:space="preserve">
<value>Tài liệu</value>
</data>
<data name="Menu_Help_Limitations" xml:space="preserve">
<value>Giới hạn</value>
</data>
<data name="Limitations_Title" xml:space="preserve">
<value>Những điều FrameLedger không làm được</value>
</data>
<data name="Limitations_OnGitHub" xml:space="preserve">
<value>Mở trên GitHub</value>
</data>
<data name="Menu_Help_ReportBug" xml:space="preserve">
<value>Báo lỗi…</value>
</data>
@@ -224,6 +224,36 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
}
}
/// <summary>
/// Help ▸ Limitations (beta.10, D36): <c>LIMITATIONS.md</c> as this build embeds it, read-only and scrollable, with the
/// repository's copy one button away. Information, not terms — nothing is recorded.
/// </summary>
[RelayCommand]
private async Task LimitationsAsync()
{
var text = new System.Windows.Controls.TextBox
{
Text = LimitationsDocument.Load(),
IsReadOnly = true,
TextWrapping = System.Windows.TextWrapping.Wrap,
VerticalScrollBarVisibility = System.Windows.Controls.ScrollBarVisibility.Auto,
MaxHeight = 520,
Width = 680,
};
System.Windows.Automation.AutomationProperties.SetName(text, Strings.Limitations_Title);
var box = new MessageBox
{
Title = Strings.Limitations_Title,
Content = text,
PrimaryButtonText = Strings.Limitations_OnGitHub,
CloseButtonText = Strings.Common_Close,
};
if (await box.ShowDialogAsync().ConfigureAwait(true) == MessageBoxResult.Primary && !_urls.Open(LimitationsDocument.OnGitHub))
{
_snackbar.Show(Strings.Limitations_Title, Strings.BugReport_BrowserRefused, ControlAppearance.Caution, new SymbolIcon(SymbolRegular.Warning24), TimeSpan.FromSeconds(4));
}
}
/// <summary>Help ▸ Report a bug… (P4 PR-3): <c>10_LOGGING</c> §Bug report flow steps 2–4, the same flow the Logs page's button runs.</summary>
[RelayCommand]
private async Task ReportBugAsync() => _ = await _bugReports.RunAsync().ConfigureAwait(true);
@@ -0,0 +1,53 @@
using System.IO;
using System.Text.RegularExpressions;
using FluentAssertions;
using FrameLedger.App.Services;
namespace FrameLedger.App.Tests;
/// <summary>
/// <c>LIMITATIONS.md</c> (beta.10, owner decision D36) rides in the assembly for Help ▸ Limitations, is information rather
/// than one of FR-11's accepted documents, and every repository link in it names a file that exists.
/// </summary>
public sealed partial class LimitationsDocumentTests
{
[GeneratedRegex(@"\]\((?<target>[^)#\s]+)(#[^)]*)?\)", RegexOptions.ExplicitCapture, 1000)]
private static partial Regex Link();
private static string RepoRoot()
{
string dir = AppContext.BaseDirectory;
while (!File.Exists(Path.Combine(dir, "FrameLedger.slnx")))
{
dir = Path.GetDirectoryName(dir) ?? throw new InvalidOperationException("FrameLedger.slnx not found above the test binary");
}
return dir;
}
[Fact]
public void ItIsEmbeddedAsWrittenAndIsNotADocumentTheUserAccepts()
{
string text = LimitationsDocument.Load();
text.Should().StartWith("# What FrameLedger cannot do").And.NotContain("<!--");
text.Should().Be(LegalDocuments.StripComments(File.ReadAllText(Path.Combine(RepoRoot(), "LIMITATIONS.md"))), "the App shows the file this build was made from");
LegalDocuments.Keys.Should().NotContain(static k => k.Contains("limit", StringComparison.OrdinalIgnoreCase),
"the Legal Gate records an acceptance per document it shows; this is information, not terms");
LimitationsDocument.OnGitHub.Host.Should().Be("github.com");
}
[Fact]
public void EveryRepositoryLinkNamesAFileThatExists()
{
string root = RepoRoot();
string[] targets = [.. Link().Matches(LimitationsDocument.Load()).Select(static m => m.Groups["target"].Value)
.Where(static t => !t.StartsWith("http", StringComparison.OrdinalIgnoreCase))];
targets.Should().NotBeEmpty("the page links each limit to the document with its details");
foreach (string target in targets)
{
File.Exists(Path.Combine(root, target.Replace('/', Path.DirectorySeparatorChar))).Should().BeTrue($"LIMITATIONS.md links {target}");
}
}
}