The owner ran the installed 0.1.0-beta.26 (sessions 64-71) and asked for the results to be checked, the two flaky tests fixed, bugs fixed, and a release if there were bugs. Read from a backup copy of the ledger and the logs (docs/spike-notes/23-owner-runs-2026-10-20.md). - FgWindow.IsNearWholeMultiplier: a window is a state's only within 10 % of a whole multiplier of two or more (FgSlices.Slice.IsActive); FgMixRecord.Parse reads stored rows by the same rule. Silent Hill 2 under Dynamic MFG listed x2.52 for 12.8 s - windows where the multiplier stepped; it now reads x2.0, x3.0, none and 7.36 % not classified. - NgxDriverState / CaptureSession: the driver is not asked after the game has gone, and CREATED | EVALUATE stand once a reading carried them. The last NGX reading, taken after the target exited, replaced every in-game one: none of the 14 answered sessions kept the two bits, so DLSS (driver-reported) and the NVIDIA App's mode (D63) never showed on an NGX-direct title. - CaptureOrchestrator: a launch says it ended on its own (Recorded) with the pids it recorded (Targets), so a process turned away while it ran - the game Steam starts after Lies of P hands itself over - is recorded when it ends; the launch's own process never is. - SessionSummaryOpener: one window per session; opening it again brings it forward. - DisplayTally: the sizes are the mode's last sample that saw the window (a game leaving exclusive fullscreen closes it first; five sessions stored none). - DlssText.Line: no line that says only "DLSS". - Tests: the guard's scan set includes the test host above the harness, which under a full gate releases modules while it starts its other classes - ModuleScanFailed (reproduced 1 run in 12 of the assembly with coverage; 15 of 15 green after), ProcessUnreadable on 2026-10-19. ShmDrainIntegrationTests.InjectAsync asks again on those two reasons only (4 times at most, 250 ms apart); the pause case waits for READY; every injection suite waits for the harness's flushed "presenting" line instead of 800 ms (tests/Shared/HarnessReady.cs). - Docs: 03_METRICS (the mix, the driver-reported rung, display sizes), 04_CAPTURE, 06_DATA_MODEL, 08_UI, 14_TESTING, 18_GPU_VENDOR_APIS, 19_SAFETY (direct starts counted by the crash safety - measured, the policy unchanged), LIMITATIONS, guide (troubleshooting, results), spike-notes section 23, HANDOFF items 20 and 21, CHANGELOG. Then, on the owner's word about Steam games (Play > Start directly says a Steam game may hand itself to Steam - the notice, the tooltip and Settings (en/vi/ja); why a note rather than a fixed Steam rule (beta.27 PR-1)): The owner, 2026-10-20: Steam games hand themselves to Steam; a note in the UI, or a fixed setting that Steam's games always go through the Steam client - the choice left open. The note: - GamePlayer: PlayResult.SteamGame - the game the agent starts (Start directly, or an App running as administrator, or a Steam record with no link) is one Steam's own records name; the notice then reads Play_Started_Steam_Format / Play_Elevated_Steam_Format. Store records are read once a press. - Strings: Play_ToolTip_Direct and Settings_PlayMode_Body say a Steam game may hand itself to Steam and the game Steam then starts is recorded; Settings adds that a few will not start outside Steam at all. en/vi/ja, ja marked review; Strings.Designer regenerated. - Why not the fixed rule: three of the five Steam games started directly on 2026-10-20 ran and were measured from their first frame, and a Vulkan game is measured only when FrameLedger starts it (Everhex Demo) - recorded in 08_UI. - Docs: 08_UI, guide/08-settings, LIMITATIONS, CHANGELOG. - Tests: GamePlayerTests (Steam started directly and elevated say it; a loose or GOG game does not). Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
94 KiB
03 — Metrics
Single source of truth for every number FrameLedger displays. Implement in Implemented in FrameLedger.Domain.Metrics with golden tests (14_TESTING).FrameLedger.Domain.Metrics since 2026-09-09 (P2 PR-A), with the goldens 14_TESTING names: FrameTimeSeries (frame times from QPC, gaps excluded), Percentile (linear), FrameStatistics (median / lows / min / max / σ with the sufficiency guards), RollingMedian + StutterDetector, FgWindow + FgRefusal (the factor and every refusal, as facts — the English lives with the report), UpscaleExtent, SegmentBuilder, RtVerdict / HdrVerdict (the tri-states), VramAggregates / LatencyAggregates / SeriesAggregates. They consume FrameSample and WriterFacts — Domain's own types, since Domain references nothing — and Application.Metrics.FrameSampleMapper is the one place a shared-memory record becomes one; the Domain enums are pinned to FrameLedger.Shared's in both directions by MetricEnumMirrorTests. The frame-generation LADDER (rung 0 / 1 / 3 / 4 as a verdict, and the withheld none) is not yet a Domain type: it is still the capture host's prose in (Corrected 2026-10-04: it landed with PR-D on 2026-09-10 as MeasuredFacts, and lands with the recorder that stores fg_mode (PR-D).Application.Recording.FgLadder — in Application, not Domain. The session row (SessionAggregator), the live card (SessionProgressCalculator) and the capture host's report all read it; MeasuredFacts keeps only the host's strings.)
Every metric declares which capture tier it requires (01_ARCHITECTURE §Capture tiers). A Tier-2 session simply has N/A where Tier-1 data is missing — never a silently degraded estimate presented as fact.
Inputs
Tier 1 — FlFrameRecord stream from the ring (17_HOOK_ENGINE §Ring writer), which is the authoritative field list. Every field is consumed except the two protocol fields seq and reserved, which are named here so "every field is consumed" does not have to be read as a promise about them: qpc, frameIndex, presentFlags, syncInterval, renderW/H, outputW/H, api, upscaler, upscalerQuality, upscalerSharpness, fgMode, fgEvaluations, rtFlags, featureFlags, dispatchRaysVolume, maxTraceRecursionDepth, psoCreatedThisFrame, vramUsedMb, reflexLatencyUs, colorSpace, measuredMask, swapchainId. Plus, from FlWriterState: vramBudgetMb for budget_exceeded_pct, rtTier and hooksInstalledMask for the RT tri-state, and rtStateObjectsCreated / rasterPsoCreated for pt_confidence.
Renamed in layout v3 (2026-08-05):
vramUsedBytes→vramUsedMb(MiB, matching thevramBudgetMbit is compared against and thevram_mbthis document already exported), andhdr→colorSpace(a bool had no third state).measuredMaskis 16-bit.
Tier 2 — PresentMon CSV. THERE IS NO TIER-2 INPUT, 2026-08-28. PresentMon was dropped (§S31 row P2) and no mechanism replaced it (§G), so Tier 2 produces no frames and parses nothing. Everything below that is marked tier 2 is Tier-1-only until a mechanism exists. The version-pinning and header-map reasoning this line carried is preserved in spike-notes §11 and 20_OPEN_QUESTIONS §M2, where the measurements that retired it also live.
Both — 1 Hz GpuSample (18_GPU_VENDOR_APIS) + optional CPU sample.
Frame times
Frame time ft[i] = (qpc[i] - qpc[i-1]) / qpcFreq × 1000 ms, measured at present entry (Tier 1) — consistent, low-jitter, and unaffected by driver-side frame pacing.
Let D = session duration (first → last present), F_app = frames the game presented, F_disp = frames actually shown.
Core definitions
| Metric | Definition | Tier |
|---|---|---|
| Native FPS (avg) | count(F_app) / D |
1 |
| Displayed FPS (avg) | count(F_disp) / D |
1 |
| Presented FPS (avg) | presents / D — numerically Displayed FPS; the name for the one number that stands alone. "Native" and "Displayed" are printed only together (rule 6); when frame generation is not measured, this is the headline, with a mandatory qualifier (§Frame Generation, rung 0's qualifier) |
1 |
| FG factor | DisplayedFPS / NativeFPS, shown ×N.N; — when FG inactive; N/A when FG is not measured — and N/A when FG was identified but the count refused (fg_mode a technology, fg_factor NULL, fg_refusal the reason — schema 0003, 2026-09-14 — and fg_refusal_detail its numbers: the bucket that departed, its ratio and the window's — schema 0005, 2026-09-16): the one number is then Presented FPS with a warning chip naming the technology, exactly rung 0's third row, because the identity says generated frames may be in the presents and the count cannot say how many. Never ×0.0, never "Native". Since 2026-09-17 a session refused as non_uniform publishes its STEADY STATE instead — fg_factor_scope = steady, the share beside it (§The steady state, below) |
1 |
| Avg FPS (headline) | = Native FPS when fg_mode is measured (api rung) or none; = Presented FPS, labelled, when fg_mode is N/A. Time-based, not the mean of instantaneous FPS values |
1 |
| Median FPS | 1000 / p50(ft_app) |
1 |
| 1% Low | 1000 / p99(ft_app) |
1 |
| 0.1% Low | 1000 / p99.9(ft_app) |
1 |
| Min / Max FPS | 1000 / max(ft_app) / 1000 / min(ft_app) |
1 |
| Frametime σ | population stddev of ft_app (ms) |
1 |
| Stutter count | ft_app[i] > 2 × rollingMedian(ft_app, 19) (centered, window in frames) |
1 |
| Stutter time % | Σ ft_app[stutter] / Σ ft_app × 100 |
1 |
| PC latency | mean/p95 of reflexLatencyUs when Reflex reports it |
1 only |
| PSO stutter % | share of stutter frames with psoCreatedThisFrame > 0 |
1 only |
| Time below 30 / 60 FPS (beta.14) | share of Σ ft_app in frames that count as below X — ft > 1.10 × 1000/X, or the nine-frame rolling median > 1.02 × 1000/X (§Pacing) |
1 |
| Time below refresh (beta.14) | the same over presents, X = display_monitor_hz — the display's rate, so over what the display received |
1 |
| Frame to frame (beta.14) | mean |ft_app[k] − ft_app[k−1]| over neighbouring intervals, ms |
1 |
Percentile method: sort ascending, linear interpolation between closest ranks (NumPy linear / Excel PERCENTILE). Document it, test it — tools differ and users will compare numbers.
Rolling-median edges. The 19-frame window is centered and measured in
frames, so the first and last 9 frames have no full window. They use a
truncated symmetric window (the largest centered odd window that fits), not a
padded or partial-shifted one — the alternatives either invent data or silently
bias the first samples. A session shorter than 19 application frames reports
stutter_count = N/A; it is already below the 30 s minimum session length
(FR-3.6) and would be discarded anyway. Golden tests pin both edges.
Data gaps. Where the drain recorded a gap (a torn record, 07_IPC
§Protocol rules), the interval spanning the gap is excluded from ft_app
entirely rather than counted as one long frame. Including it would fabricate a
stutter — the exact artifact these metrics exist to detect honestly. Gaps count
toward the session's data-quality warnings.
Since beta.8 a pause is a gap, and a gap is not time either. The Overlay records nothing while FR-3.9's pause holds, so the first record after the resume is QPC-apart from the last one before it by the whole pause: counted, a fabricated minutes-long frame in every statistic — the Overlay's own comment on its pause check (
MayObserve) names that artefact — and paused minutes in every average.CaptureSessionreads the QPC as it tells the ring to resume and marks a gap before the first record stamped at or after it (CaptureSessionTests.TheFirstRecordPresentedAfterAResumeFollowsAGap, red before the fix). AndD, the time base of every average, is the time the kept intervals span — first to last present less every interval a gap sat in (FrameTimeSeries.MeasuredSeconds,FgWindow.Seconds): Presented FPS is the kept intervals over the seconds they span, and Native / Displayed leave the gaps out of their seconds too. For lost records this reads the survivors' rate (a drop is the Agent falling behind, not the game) where it read the survivors spread over the lost time — a rate nobody measured; with no gap nothing changes.
Lows use application frames only. Generated frames smooth display cadence but do not represent simulation stalls; mixing them hides real stutter. A secondary "Displayed 1% Low" is stored for the Displayed chart series but never replaces the headline.
And since beta.8 (2026-09-25) they are computed that way — until then they were not. Where generated frames were counted (
fg_modea technology, oractive),SessionAggregatortook the median, the lows, min / max, σ and the stutter rule over every present of the dominant stream: the 1% low of a ×2 session sat above its native average, and on the owner's Onimusha demo capture (DLSS FG ×3, which submits each generated frame half a millisecond after its application frame) the stored median read 2,073 FPS on a 60 FPS game.ft_appis nowDomain.Metrics.FrameTimeSeries.ApplicationFrames: the interval between two consecutive presents that carried an application frame's token, the generated presents between them adding no interval of their own; a gap or a present that does not claim the count breaks the chain. The segments' lows follow; the Displayed 1% low stays over every present. A technology named and no application frame counted (no_evaluations,not_counted) has no frame statistic at all — N/A rather than a low over presents that include generated frames. Per-present attribution is accurate to one present (§Frame Generation); it was measured regular — application, generated, generated, repeating — on that capture. Rows written before beta.8 keep their stored numbers, as with the steady state (#198); their charts are drawn from the blob with the new rule.
When frame generation is NOT measured, the lows are taken over presents and labelled
(presented)— added 2026-09-03 with Presented FPS. On a title with no in-process frame generation that is exactly the application-frame low; on one that generates frames through a path this writer does not hook it is smoother than the truth, which is why the label stays on untilfg_modeis measured ornone. An unlabelled low is a claim about application frames, and a present-only writer cannot make it.
Sufficiency guards (FR-4.8): 0.1% Low needs ≥ 10,000 application frames, 1% Low ≥ 1,000; otherwise N/A.
Pacing (beta.14, D49)
Time below 30 / 60 FPS and below the refresh rate are shares of the measured time — Σ ft (counted) / Σ ft — so a long
hitch weighs what a player sits through, not one frame among many. Frame to frame is the mean change from one frame
time to the next over neighbouring intervals (FrameTimeSeries.FollowsBreak: a pair with an interval left out between —
a gap, a pause — is not a pair); it is low when pacing is even whatever the rate.
Which frames count as below X — and why not "longer than 1000 / X". The present-to-present interval of a game held
at X jitters around 1000 / X by a few tenths of a millisecond, half of it on the long side. Measured on a copy of the
owner's ledger (2026-10-06): a GIRLS' FRONTLINE 2 session capped at 60 (median 16.63 ms, 296,380 frames) reads 50.0 %
of its time "below 60" under the plain rule, and a rolling mean does not help — the local average of a game held at 60
sits on the threshold. So a frame counts when it is itself more than 10 % longer than 1000 / X (a long frame, never
jitter) or the median of the nine frames around it (RollingMedian, the stutter rule's centered window and edges) is
more than 2 % longer (a rate that stays below X). The same session reads 9.6 % (its time below 30 alone is 4.7 %); with
a 0.4 ms jitter a steady 58 FPS reads 93 %, a steady 60.2 reads 0.7 %, and a 100 ms hitch counts its own 100 ms and no
neighbour's. The cost, stated: a rate less than 2 % under X (58.8–60 FPS for 60) reads partly as at X — a steady 59
reads 40 %. Domain.Metrics.FramePacing; FramePacingTests pins each of these.
Which series. 30, 60 and frame to frame are over ft_app — application frames where generated frames were counted
(rule 6: generated frames do not make a game run at 60), the presents otherwise, labelled (presented) as every
present-only statistic is. The refresh share is over the presents, generated ones included: it is the display's rate,
and what matters there is what the display received — a ×4 frame-generation session on a 240 Hz display reads near 0 %,
and over its application frames it would read 100 % whatever the pacing. It needs display_monitor_hz (the display
tally's, §Display mode): a session recovered from its crash file has none, and reads N/A. Sufficiency: the 1 % low's
1,000 frames; below it every value is N/A.
Sync — what the presents asked for (beta.14, D49)
vsync_present_pct is the share of the dominant stream's presents with a sync interval of one or more (the game asked
to wait for the display), tearing_allowed_pct the share with DXGI_PRESENT_ALLOW_TEARING. Both arguments were in every
Direct3D record since P1 (FL_MEASURED_PRESENT_ARGS) and read by nothing; sessions.sync_interval_mode (0001) gets its
first writer with them — on (every present), off (none), mixed. Asked, not obtained: a driver setting or a
variable-refresh display can override the request, and nothing in the process says which won. OpenGL's
wglSwapBuffers and Vulkan's vkQueuePresentKHR carry neither argument: N/A, never 0 %. Tier 1 only.
Frame Generation — ground truth (Tier 1)
This is the metric the rewrite exists for. Resolution ladder, highest confidence first; the winning rung is stored in fg_source:
api(authoritative). An NGXFrameGenerationfeature (or StreamlineDLSS_G, or an FFX frame-interpolation context, orxess_fg) was created and evaluated this frame → FG is on, and we know which technology by name, from the vendor's own API call. This is a fact, not an inference.RUNG REMOVED 2026-08-28. It read "PresentMon 2.xetw(Tier 2).FrameTypecolumn reports generated frames directly"; §S31 measured that column classifying every frame of a ×4 capture as an application frame, PresentMon was retired, and then dropped. There is no Tier-2 rung and no Tier 2 to put one on. The ladder is now rungs 0, 1, 3 and 4 — renumbering them would break every reference in this file and infl_shm.h'sfg_source, so the gap is left visible instead.cadence(last resort,both tiersTier 1 only — Tier 2 has no frames to find a cadence in). SustainedDisplayed/Native ≥ 1.5→Detected (unknown).- Otherwise
fg_mode = none, factor—. Reachable since 2026-09-04 by counting: a publishedpresents / tokensat or below 1.05 over a uniform window (§The source, below). Never from a hook that merely saw nothing (rung 0), and never from the census.
Displayed may be DXGI-COUNTED — measured 2026-09-05 on Dying Light: The Beast
F_disp = presents observed by the hook(§Counting, below) assumed every present reaches thePresent/Present1bodies the Overlay inline-patches. On Streamline 2.8.0 with DLSS Frame Generation ×4 it does not: the hook timed 4,392 presents whileIDXGISwapChain::GetLastPresentCount, read on the same chain at every hooked present, moved by 17,133 — 2.90 unseen presents per hooked one (2.95 on the second capture) — against 0.00 on Streamline 2.7.3 (Hell Is Us, ×3.86) and 2.10.3 (the Onimusha demo, ×3.67), where the generated presents come through the patched bodies. So the record carriesdxgiUnseen(@52, underFL_MEASURED_DXGI_PRESENTS) and the consumer's window countsF_disp = hooked presents + Σ dxgiUnseen (DXGI-COUNTED when the sum is > 0)When the sum is above zero the report says so on its own line — "Displayed is DXGI-COUNTED" — because the number is then a count DXGI made, on the hooked chain, of presents this hook never timed. It may stand in the rule-6 trio and in
presents/batch; it may NOT stand in a frame-time distribution, which has no timestamps for those presents. The uniformity buckets take the same numerator, so a session whose pacer stopped mid-way refuses exactly as one whose tokens stopped. A saturated byte (255) is refused like a saturatedfgEvaluations, and a present the hook saw and declined (a paused session) is not unseen — the resume's first record differences nothing.Landed 2026-09-06 (
spike-notes§9):Native FPS: 70.52 -> Displayed FPS: 282.08 (x4 FG) over 16516 present(s)on Dying Light: The Beast, 12,387 of them DXGI-counted,frame generation: DlssG— the rule-6 trio on the title that could not print it. And the counter decidesnoneon that shape. Leg 0 the same morning (frame generation off, twice) read presents = tokens withunseen=0over 3,659 and 4,519 samples, census unchanged (sl.dlss_g.dllis a startup-time load), so the withheld gate is narrowed rather than withdrawn: a countednonebeside a READ counter with zero unseen prints asnonewith DXGI's agreement on the line; only a session where the counter was not read withholds. A writer state that counted unseen presents the records do not carry is a contradiction and is refused as neither.20_OPEN_QUESTIONS§H5 keeps the rows this landed on; which body the 2.8.0 pacer presents through is unlocalised and does not need to be for the count.RUNG 2 IS CONDITIONAL ON THE VENDOR, measured 2026-08-20, and this list read as though it were not.
--track_frame_typeis a beta option in PresentMon 2.5.1 and its own help says it "requires application and/or driver instrumentation using Intel-PresentMon provider". SoFrameTypeis a report of events an application or a graphics driver chose to emit through Intel's provider — not a classification of any present from first principles. Which vendors instrument it is unmeasured — including Intel's own. It is Intel's provider and Intel ships XeFG, so the obvious reading is that XeFG is covered; that reading is not a measurement, and this block exists precisely because the rung was written as though availability were settled. The one that decides P0 is NVIDIA's DLSS-G driver, and it is unmeasured too.The parser must therefore report a capability loss rather than fall through to rung 4. §Inputs already says so about a missing
FrameTypecolumn, and the same now applies to a column that is present and classifies nothing: every row spelledApplicationwhile frame generation is on is an ABSENCE, and rung 0 turns an absence intoN/A. A rung-4nonethere would be the affirmative negative this whole ladder exists to prevent, reached from a new direction.§S31 carries the pre-committed decision table, including the two rows that retire the rung outright.
tools/frametype-oracle.ps1was what produced the input — deleted 2026-08-27 with the tool it parsed — and also the reasonspike-notes§11 now records that the console binary will not run unelevated on the dev box at all.🔴 MEASURED 2026-08-27, AND THE RUNG IS NARROWED: NVIDIA DLSS-G IS NOT COVERED
§S31 ran — three legs, three game launches, Cyberpunk 2077 at off / ×2 / ×4 — and landed on row P2.
FrameTypeis present and every row of all three legs readsApplication: 1,937 / 6,488 / 10,881 rows, no other value anywhere. Meanwhile the two instruments agree on the present rate to within 0.3% per leg, so PresentMon SAW the generated presents — at ×4 roughly three in four cannot be application frames — and classified all of them as application frames.So for NVIDIA frame generation this rung yields nothing on this driver and this build. It is not "unreliable" here; it produces an ABSENCE, and rung 0 turns an absence into
N/A. A consumer must never reach rung 4 from it.What is still unmeasured is WHICH vendors it does cover. Intel's own remains untested despite being the obvious reading — the reading this document was already corrected once for asserting — and AMD is untestable on the only machine that exists (§R5/§R6). The honest scope of rung 2 today is therefore: no vendor is known to instrument this provider, and one is now known NOT to.
One sub-question does not change the above and is recorded in §S31 rather than here: whether
--track_frame_typewas in effect at all. If the column ships by default the legs measured a default rather than an absence. Either way the rung produced no classification, which is why §S31 landed on P2 without waiting for it.
Rung 0, added 2026-08-06, and it has to come before rung 4 or rung 4 is a lie. If
FL_MEASURED_FGis clear the answer isN/A, notnone: no hook capable of answering was live, andnonemeans "a hook ran and there was genuinely no frame generation" — the only one of the three states that may be aggregated as a negative (fl_shm.h, layout v3). Applied to today's present-only writer, rung 4 as written turns "nobody looked" into a measured absence about every title, which is the affirmative negative the whole of layout v3 exists to make impossible.Likewise
fg_factorisN/AunlessFL_MEASURED_FG_COUNTSis set, and never1.0. With the counts unmeasuredΣ fgEvaluationsis zero, and a consumer that treated that as "no frame generation" would publishF_app == F_disp— CLAUDE.md rule 6's forbidden number, reached by counting nothing. Zero is a data gap here, never a measurement, and the mask bit is what tells the two apart.The same holds one level down: a present that drained no evaluation carries
fgEvaluations = 0with the bit set, which is a real measurement of that present. A consumer must not filter those records out — doing so leavespresents == Σand recovers the forbidden 1.0 from honest data.
Rung 0's qualifier: the runtime census (2026-09-03, owner decision)
The problem rung 0 left. With this writer, rung 0 is where every title lands: no non-Streamline title sets
FL_MEASURED_FGat all, and on every Streamline title measuredΣ fgEvaluationsis 0. So a 2D title with no upscaler and Black Myth: Wukong running DLSS-G through a path this writer does not hook printed the same line — "FG factor not measured" — and the reader had no way to know that the first number was a frame rate and the second might be twice one.The census.
FlWriterState.runtimeCensus(fl_shm.h§FlRuntimeCensus) is taken on the Overlay's watchdog once a second: for each module name inFL_RUNTIME_CENSUS, ask the loader whether it is present. OR-only, so monotonic;FL_CENSUS_RANsays the census ran at all. The names are the measured ones invendor-exports.json, gated byhookinventory-checkPass D. It is not a hook and not a measurement: a set bit says a module of that name was loaded, a clear bit says the loader had none of that name.What it may say. The line under Presented FPS, one of three:
Census Line did not run not measured, and the census did not run — whether presents include generated frames is unknown ran, no FG family bit no known frame-generation runtime was loaded, so this number cannot include in-process generated frames (statically linked FSR3-FG and driver-level AFMF are outside what this can see) ran, FG family bit(s) WARNING: a frame-generation runtime was loaded ( nvngx_dlssg.dll) and no evaluation was observed — this number may include generated frames; read it as Displayed, not Nativeand, for the upscaler, the difference between no hook ran and no runtime was loaded and a runtime is loaded and no hook installed (the Streamline 1.5.6 case).
A module that MAY generate frames counts as a frame-generation runtime:
amd_fidelityfx_dx12.dll, the FSR 3.1 facade, dispatches both upscaling and frame generation behind one export set (H11), and Lies of P ships it alone while generating frames — so it warns rather than reassures. Since 2026-09-04 that module is also HOOKED (§The AMD source below), so on such a title the count is measured and the trio prints; the WARNING is what remains for a title whose ffx-api dispatches never arrive.What it may NOT say, and this is the whole design: the census never produces
none.FL_FG_NONEandFL_UPSCALER_NONEmean "a hook ran and saw the alternative" — the only negative this document lets a consumer aggregate. A census-derivednonehas two holes, both structural: FSR2/FSR3 are routinely linked statically, so an FSR3-FG title has no module for the census to see while its proxy swapchain still calls the realPresent, and anonethere would publish presents as native — the inflated number rule 6 forbids — with a confident label on it; and driver-level or out-of-process generation (AFMF, Lossless Scaling) is invisible to any in-process list. The census may narrow an N/A's reason and may raise a warning. It may not close the question.And the other direction is just as closed. Streamline loaded + zero
slEvaluateFeaturecalls does not mean upscaling off: Wukong loadssl.interposer.dll, runs DLSS-G, and never calls it. So a title with upscaling switched off in its settings and a title driving DLSS through an unhooked path are indistinguishable to this writer, and the upscaler line now says so — three causes, named, rather than "our coverage is short". Three of five titles now (2026-09-03): Hell Is Us with DLSS on and frame generation ×4 drained zero batches —spike-notes§9.
Counting native vs displayed frames at Tier 1
Application-generated and FG-generated frames both go out through the swapchain
we hooked, so our present hook sees them all — the present count alone is
F_disp, not F_app. The separation comes from the FG feature itself:
F_disp = presents observed by the hook
F_app = Σ fgEvaluations (APPLICATION frames, counted at the source)
The source is
slGetNewFrameToken— decided 2026-09-03, HANDOFF item 3's producerStreamline hands a title one frame token per application frame, and the title has to ask for it:
slGetNewFrameToken(sl_core_api.h: "obtain unique instance" per frame; everyslSetTag/slEvaluateFeaturetakes the token). The Overlay detours that export — module-scoped, lazily installed, an inventory row like the other two — andfgEvaluationsis the number of new frame indices — above every index seen before — the tokens handed out between two presents carried. New indices, not distinct objects and not "different from the last": measured 2026-09-03, Cyberpunk asks for a token three to four-and-a-half times per frame, from more than one thread, and receives a different object each time (§S31 row P4).fg_factor = presents / Σ tokenstherefore needs no premise about Ray Reconstruction batches and works on the titles whereslEvaluateFeatureis never called at all (Wukong, Rune Factory, Hell Is Us), which the previous producer could not reach on five titles out of five.The one premise it carried, and how it was retired. From inside the process, "no frames were generated" and "the DLSS-G plugin requested a token for every frame it generated" are the same ratio: 1.0. So until the owner's run landed,
FgWindowrefused any ratio below the cadence threshold. It landed on row P1 on 2026-09-04 — Cyberpunk 2077 off / ×3 / ×4 at 1.00 / 2.99 / 3.99, Hell Is Us ×4 at 4.00 — which excludes the second explanation on the title that would have shown it. Rung 4'snoneis therefore reachable by counting: a published factor ≤ 1.05 (FgWindow.NoneCeiling) is the measured statement that every present carried an application frame. A factor ≥ 1.5 (ActiveThreshold, the cadence rung) is active; the band between is refused as a configuration no vendor ships. Andtokens/batch = 1.00on every leg with batches answered §S31's own question — a drained Streamline batch is an application frame on that title — with a second count rather than an oracle.And one shape on which the counted
noneis WITHHELD, measured 2026-09-04/05. Dying Light: The Beast ships Streamline 2.8.0; five captures at DLSS with DLSS Frame Generation ON readpresents = tokens(1.00), and the owner's reading settled it: the title runs at ×4, the frames this hook records are the native ones, the generated presents never reach thePresentbodies the Overlay patches (20_OPEN_QUESTIONS§H5 case 3). On that shape the count is right about the application frames and wrong about the presents, and anonecomputed from it is the affirmative negative this document forbids. So the consumer withholdsnone— and prints Presented FPS with a qualifier saying the number counts application frames and the Displayed rate is unknown — whensl.dlss_g.dllis in the census beside an interposer whose file version (read out of process by the capture host, never by the hook) is ≥ 2.8.0 or unreadable. The key is the Streamline plugin, notnvngx_dlssg.dll: every validatednoneabove has the NGX module loaded and the plugin bit clear, so the gate leaves each of them byte-identical. It is interim: §H5 pre-commits the session that keeps, narrows or withdraws it.What
fgModestill is. Identity —DLSS_Gwhen akFeatureDLSS_Gevaluation drained,UNKNOWNotherwise — from the evaluate detour, unchanged. And since 2026-09-05,DLSS_Gwhen the present drained a HUD-less or UI tag (kBufferTypeHUDLessColor,kBufferTypeUIColorAndAlpha,kBufferTypeUIAlpha) on any of the three tag routes the Overlay already hooks: Streamline's DLSS-G programming guide §5.0 requires a title running frame generation to tag those buffers every frame, and nothing else a title evaluates through Streamline that generates frames consumes them. Read off the argument of an API already hooked (rule 4), zero new hooks — the identitykFeatureDLSS_Gevaluations were supposed to give and gave on no measured title. Identity only. A title may tag the inputs with frame generation switched off in its menu, so the consumer's rule is: the count decidesnone, identity decides the name — an active count beside the mark printsDlssG; a counted 1.0 beside it printsnonewith the inputs noted; the withheld shape (§H5) keeps its N/A with the tags reported in the census line — narrowed 2026-09-06 to sessions where DXGI's counter was not read (§Displayed may be DXGI-COUNTED).FsrFgkeeps precedence over the count, because a drained FRAMEGENERATION dispatch is a generated batch.FlWriterState.slTagCensuscarries which types arrived on which route for the session (fl_shm.h§slTagCensus).Refused, with the reason written:
slDLSSGGetState, the API the DLSS-G guide §14.0 names for "the actual number of frames presented". ItsnumFramesActuallyPresentedis "the number of frames presented since the lastslDLSSGGetStatecall" — the call RESETS the plugin's counter, so a measurement tool calling it would corrupt the very number a title reads for its own FPS display; andsl_dlss_g.hmarks it "NOT thread safe". Observing is the whole posture; a query with a side effect on the host is not observing. A factor ≥ 1.5 withUNKNOWNidentity is frame generation active, technology not identified, which on a UE5 title with both Streamline and FidelityFX loaded is the honest answer.
The AMD source is the ffx-api PREPARE dispatch's
frameID— built 2026-09-04, HANDOFF item 7cAn FSR title routes every per-frame piece of work through one export,
ffxDispatch, and the descriptor it passes says which: an UPSCALE dispatch once per application frame, a frame-generation PREPARE once per application frame carryingframeID(documented by the vendor as "must increment by exactly one for each frame"), and a FRAMEGENERATION dispatch per generated batch, sent back through the same export from the title's own callback. The Overlay detoursffxDispatchon the four modules a game calls — the SDK 1.1.x monolith, the two SDK 2.x effect DLLs, and the SDK 2.x loader, which turned out to be the entry on loader-shipping titles with the effect DLLs' exports silent behind it (measured the evening the leaf-only build shipped; §H11 row R6) — and:
fgEvaluationsis the number of newframeIDs the PREPARE dispatches carried between two presents — this vendor'sslGetNewFrameToken, keyed the same way (a monotone maximum, so a re-issued prepare counts once). A title that has never prepared counts UPSCALE dispatches instead, one per application frame; the choice is a one-way latch per process, because choosing per present would double-count a frame whose two dispatches straddle a present.fgModeisFSR_FGon a present that drained a FRAMEGENERATION dispatch;UNKNOWNotherwise.noneis still the consumer's verdict from the count, exactly as on the Streamline route.- Two vendors in one process (UE5 loads Streamline and the AMD leaves whatever the menu says): Streamline's token count keeps precedence once it has ever issued a token, so every title validated on §S31 is byte-identical to before; a process where Streamline is loaded and idle falls through to the AMD count.
- The second count. UPSCALE dispatches are counted separately in the same drain word, and the consumer prints
frames/upscale-drainedbesidepresents/frame— the AMD twin oftokens/batch:1.00when the two per-frame counts agree,2.00when one of them is doubled (a hook on the loader as well as the leaf, or two upscale contexts per frame). Build the second count before trusting the first is 7c's own rule, and this is it.The acceptance table for the owner's three launches is pre-committed in
20_OPEN_QUESTIONS§H11. What this route does NOT reach: statically linked FSR (§Scope decisions) and Intel (closed at the census). The FSR 3.0 host DLL is reached since 2026-09-05 — a fifth AMD target,ffx_fsr3_x64.dll!ffxFsr3ContextDispatchUpscale(Cyberpunk 2077's copy; named export, its own descriptor, tagfsr3-v3.0.4), whose UPSCALE feeds the same drain word: identityFSR3as a fact,renderSizeas the extent, and the count from its upscales when neither Streamline nor a PREPARE has ever spoken. On Cyberpunk the count stays Streamline's andFsrFgstays the monolith's; the host adds the identity the leaf-only build printed asN/A.
MEASURED 2026-08-15, AND IT CHANGES WHAT THIS SECTION CAN PROMISE. On the one title measured — Cyberpunk 2077, SL 2.7.1 —
slEvaluateFeature(kFeatureDLSS_G)is never called: 0 evaluations across ~14,000 Streamline batches at four frame-generation settings, while frame generation was demonstrably active. DLSS-G on Streamline 2.x is not driven through the feature-evaluation entry point, soΣ fgEvaluationsis 0 andfg_factoris correctlyN/Arather than wrong.presents / batch— presents per Streamline evaluation drained — reads 1.000 / 2.000 / 4.000 against that title's own off / ×2 / ×4, but a batch is not an application frame: they coincide only because Ray Reconstruction is evaluated once per application frame there, which no independent oracle has confirmed. Do not promote that proxy tofg_factorwithout attaching the premise.docs/HANDOFF.mditem 3 carries the routes to a real producer.The proxy is PRINTED, and it now has a guard of its own — which the factor's could not be.
FgWindow.BucketFactorssplits the window into buckets and refuses a factor when one bucket departs from the whole; it divides byΣ fgEvaluations, zero on every record on this route, so every bucket matched, the check passed vacuously, andRefusalForreturned at the data-gap clause before uniformity was ever considered. Measured 2026-08-16: an alt-tab mid-capture produced an achievedpresents / batchof 1.84 against a title configured for ×2 — wrong by 8%, with nothing in the report saying so.FgWindow.BatchRefusalis the per-bucketpresents / batchcheck §S30 named as a prerequisite, andSessionReportprints its verdict on the line under the ratio so the number cannot be read without it. A guard keyed on a quantity that is zero on the route that runs is not a guard.The steady state — owner decision 2026-09-17
The refusal was right and its consequence was wrong. A session that ran its menus at ×1 and its gameplay at ×4 averages to a number no configuration had (Black Myth: Wukong, 2026-09-16: 2.22 over a session whose gameplay read ×4.1 for two thirds of it), so the session-level factor is refused — and until this date the gameplay's own number was thrown away with the average. Every real play session opens with a splash, a menu or a loading screen, so on the owner's machine the shipped Agent published a factor on one hooked session in nine while the live card, which looks at five seconds at a time, showed it throughout; the owner read that as a broken data path. It was not: the nine sessions' stored per-frame counts read 2.00 / 3.00 / 4.00 to two decimals inside gameplay.
The rule. When — and only when — the session-level factor is refused as
NonUniform,FgSteadyStatecuts the claimed span into five-second windows (the live card's own), classifies each by its ownpresents ÷ tokens, and takes the set of ACTIVE windows (≥ 1.5) agreeing within 10 % that holds the most time. It is published when it covers ≥ 10 s and ≥ 10 % of the presenting time:fg_factor,native_fpsanddisplayed_fpsare that state's own (counted over its windows, independently),fg_factor_scope = 'steady',fg_steady_sharethe fraction, andfg_refusal/fg_refusal_detailstay set as the reason the number is not session-wide. ×3 and ×4 are 25 % apart and never pool; a factor that wanders forms no state and the refusal stands alone; any other refusal (unattributed, saturated, interleaved streams) gets no steady state — slicing does not make a record set trustworthy. Never a session average, and never shown without its share. Replayed over the nine sessions: eight publish (Onimusha ×4.00 60 → 240, Lies of P ×2.00, Hell Is Us ×3.03, Cronos ×2.00 225 → 451, Wukong ×4.11), the ninth had nine seconds of gameplay.Two constants moved with it.
BucketToleranceis 10 %, the steady state's own, down from 25 %: at 25 % a session that ran ×3 then ×4 published 3.69, and the owner's one published session read ×2.04 because its opening bucket (2.35) sat inside the tolerance while its gameplay read 2.00 — tightening was unaffordable while a refusal meant no number, and is free now. AndMultipleStreamsrefuses only when the chains' samples INTERLEAVE: the hazard is a process-wide drain word with two chains presenting at once, and Onimusha recreates its swapchain on entering gameplay — chain 1 for the menus, chain 2 after, not one sample interleaved in three sessions — which is one stream at a time and was refused as two.This also leaves §RT/PT/RR without a settled denominator.
rt_frame_pct,rays_per_pixeland the≥ 5% of framesgate are per-APPLICATION-frame quantities, and dividing them by presents dilutes each by the frame-generation factor — at ×4 a title that path-traces every application frame reports 25%. Whoever writes the RT hooks must choose a denominator and state it here.(Settled 2026-08-20 with the RT hooks — §RT/PT/RR, "The denominator":
rt_frame_pctis a share of presents and says so, and the tri-state is unaffected. Marked here 2026-10-04.)
The mix — owner decision 2026-10-19 (D62)
The steady state names one state; a session can hold several. A player who tries ×2, ×3 and ×4 in one session, or whose NVIDIA App runs frame generation as Dynamic, got the longest state alone. Since beta.24 every state is stored beside it:
Domain.Metrics.FgMix, over the same five-second windows the steady state is read over (one cut,FgSlices.Cut), from whereFgWindowstarts (the claimed suffix).The rule. Each window is classified by its own
presents ÷ tokens: active (≥ 1.5, with ≥ 8 samples and tokens), no frame generation (≤ 1.05, with ≥ 8 samples and tokens — and only where a countednoneis allowed: not on the shapeFgLadder.WithholdNonewithholds, §Frame Generation), else not classified (too few samples, no tokens, the band between 1.05 and 1.5, or a withheldnone). The active windows are grouped by repeating the steady state's own extraction on what is left — the ±10 % cluster holding the most time, pooled, redrawn once — until no cluster remains; a cluster under 10 s returns its windows to not classified. A state's factor, Native and Displayed are its own (Σ presents ÷ Σ tokens over its windows; each rate over its own seconds); a row's share is its seconds over every window's, so the rows sum to 100 % and the longest state's share isfg_steady_sharewhen the session has one. Rows: the states by rising factor, then no frame generation, then not classified. Never an average across states (CLAUDE.md rule 6), and ×5 and ×6 are 20 % apart and never pool.Amended 2026-10-19 (beta.26): a window needs application frames, and a ratio frame generation can produce. "≥ 8 samples and tokens" was built as eight presents and ONE token, and the owner's Silent Hill 2 session listed a ×1336.0 state — the session's first ten seconds, the game compiling its shaders, presented with one token per window (
spike-notes§22); the DLSS line cited it. A window is now read only with ≥ 8 presents AND ≥ 8 application frames (FgSlices.Slice.IsReadable, both active and no frame generation), and is active only up to ×8 (FgWindow.GenerationCeiling: no shipping technology generates more than five frames per application frame, DLSS 4.5's ×6); every other window is not classified. The steady state reads the same windows, so it can no longer pick such a stretch either. A session-wide or live ratio that held above ×8 is refused asbeyond_generation(after uniformity: a session that changed state staysnon_uniformand keeps its steady state and its mix). A stored mix is read by today's rule (FgMixRecord.Parse): a row above ×8, or whose windows averaged fewer than eight application frames, joins the not-classified time — so the session stored with the ×1336.0 row reads ×2.0, ×3.0, ×6.1, no frame generation and 30 s not classified, and its shares still add up.Amended 2026-10-20 (beta.27): a state is near a whole multiplier. Every frame generation that ships multiplies by a whole number — ×2 for FSR, XeSS and DLSS 3, up to ×4 for DLSS 4, up to ×6 for DLSS 4.5 — and its windows read near one: 1.98, 3.01, 6.06. The owner's Silent Hill 2 session of 2026-10-20 under the NVIDIA App's Dynamic mode listed a ×2.52 state for 12.8 s: windows in which the multiplier stepped between ×2 and ×3 read ×2.21–×2.70 — at 135 s, 251 application frames followed by one generated frame and 270 by two — and three of them pooled into a state nobody held (
spike-notes§23). A window is now active only within 10 % of a whole multiplier of two or more (FgWindow.IsNearWholeMultiplier: ×1.8–×2.2, ×2.7–×3.3, … ×5.4–×6.6); a window between two is not classified, and the steady state reads the same windows. A stored mix is read by the same rule (FgMixRecord.Parse): that session reads ×2.0 27.30 %, ×3.0 62.41 %, no frame generation 2.93 % and 7.36 % not classified. Of the 70 sessions in the owner's ledger copy it was the only stored row between two multipliers.When there is a mix. Only where the session's frame generation was named (
Named/ActiveUnidentified) and the session-wide count either stood or was refused asNonUniform/AmbiguousBand— a change of state is exactly what a mix describes. Every other refusal (not counted, unattributed, interleaved streams, either saturation, no evaluations, too short, no batches, and since beta.26 a ratio beyond any frame generation) gets none — slicing does not make a refused record set trustworthy, the steady state's rule — and so does a session in which no state formed.Stored, never replayed.
sessions.fg_mix(schema 0020) holds the rows as JSON (FgMixRecord), written by the recorder's aggregation beside the steady state. A session recorded before has none and is not rebuilt:frame_blobskeep one Generated bit per frame and lose the presents only DXGI counted, so a mix rebuilt from them would be wrong on exactly the titles that need one. The summary says so in one line for a session that counted frame generation and has no mix.What it shows, and what it cannot. The summary's block (
08_UI§Session summary): a bar of the shares, then a row per state —×4.0 frame generation · 35.33% · 70 → 282 FPS · 2m 05s—, No frame generation with its one rate, Not classified with its time; shown when the mix has two rows or more (one state throughout is the readout's own number). Frame generation that changes faster than the five-second windows — the NVIDIA App's Dynamic mode can — reads partly as not classified rather than as a factor nobody held. Above the rows, how frame generation was SET: the NVIDIA App's Frame Generation Mode from the driver profile stored with the session (Dynamic, up to ×6, target: max refresh rate; Fixed ×4), or that the profile sets none — the game's own menu chose (NvidiaOverrides.FrameGenerationContext). That line is configuration, never one of the rows. The multiplier chosen in a game's menu is not read — it reaches the runtime throughsl::DLSSGOptions, the routeHANDOFF§2b refused — so the measured row is its evidence. The dynamic ceiling (NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX) is decoded asNGX_DLSSG_MULTI_FRAME_COUNTis (frames generated per rendered frame) and the automatic target as "max refresh rate"; NVIDIA's header names neither, and owner-only item 20(a) checks both against the App.
fgEvaluations is recorded per present by the NGX/Streamline/FFX/XeSS FG hooks the slGetNewFrameToken
detour; where Streamline never issued a token, by the FidelityFX dispatches — new PREPARE frameIDs, else UPSCALE
dispatches, the FSR 3.0 host's included (corrected 2026-10-04: NGX and XeSS have no hook)
(17_HOOK_ENGINE §Upscaling / frame generation). fg_factor = F_disp / F_app.
fgEvaluationscounts EVALUATIONS, not generated frames — owner ruling, 2026-08-14 — and this block said the opposite until the producer was written. The subtraction form above (F_app = presents − Σ fgEvaluations) needs the count to be of generated frames, and nothing can produce that number in policy:slEvaluateFeature(kFeatureDLSS_G)fires once per application frame and yields N−1 generated ones, where N lives insl::DLSSGOptions— set out of band throughslDLSSGSetOptions, which is the routeHANDOFF§2b refused on five separate grounds. Counting the evaluations themselves needs no multiplier and no vendor header at all, and the two forms are not interchangeable: on the one real title measured they differ by a factor of four.What it costs, stated rather than discovered. The per-frame
native_or_generatedbit below is now "this present carried an application frame's evaluation" rather than "this present was generated", and its polarity is inverted accordingly. Because the drain attributes a batch to the next present, that classification is exact in aggregate and approximate per frame — a generated present and its application frame are adjacent, and which of them carries the bit is decided by thread timing. Aggregates (Native FPS, the FG factor, the lows) are unaffected; a per-frame timeline coloured by that bit is accurate to one frame.And
fgEvaluationssaturates at 255 rather than wrapping. A wrapped count reads LOW and is the denominator here, so it would inflate the factor without bound. No configuration evaluates frame generation 255 times between two presents, so a consumer seeing 255 must refuse to publish a factor rather than divide by a floor.
What this replaces, and why. An earlier revision derived generated frames from
IDXGISwapChain::GetFrameStatistics().PresentCountminus our hooked present count, and claimed that difference exposed driver-level FG such as AMD AFMF. It does not.PresentCountcounts presents the application submitted through that swapchain — the same events our hook intercepts — so the difference is structurally zero, and a metric that is always zero reads as "no frame generation" rather than as a failure. The rung was not conservative; it was silently wrong.
Driver-level frame generation (AMD AFMF, driver-injected interpolation) is not
detectable in v1 and must not be implied to be. It happens after present, in
the driver or the compositor, invisible to both an in-process hook and
GetFrameStatistics. Where the UI cannot distinguish it, the honest answer is
N/A, exactly as elsewhere in this document. Whether PresentMon 2.x's
FrameType can see it at Tier 2 is a P0 question — closed by decision: there is no Tier 2 to see it at (§M1, §G).
fg_factor is always the measured ratio F_disp / F_app regardless of which
rung identified the mode — only the identification comes from the ladder.
Display rule (product requirement, CLAUDE.md rule 6): wherever FPS appears and FG is active, render "{native} → {displayed} FPS (×{factor} FG)". Cards show Native large, Displayed + factor secondary. Charts default to Native with a Displayed toggle. Exports contain all three.
Rung 3's line carries its exclusions (2026-09-06, HANDOFF 7b / §H11). Active (technology not identified) is printed by elimination among what this session saw: not DLSS-G when the NVIDIA
driver's FG word reports no feature created and no HUD-less / UI tag was sent (or "not excluded"
when the driver did not answer); no FSR frame-generation dispatch reached a hooked module; the
frame-generation runtime modules the census names, or that none is loaded; and the vendor SDK
strings the executable FILE carries. Never a vendor named as measured — XeFG cannot be hooked or
declared (licence), a compiled-in FSR 3 has no module — and the line says a frame generator compiled
into the executable would read the same.
And the census's "cannot include generated frames" is now second-witnessed by the executable
file (2026-09-06). A frame generator compiled into the exe loads no module (Rune Factory, Wukong),
so the capture host scans the executable on disk for the SDK strings (ffxFsr3,
ffxFrameInterpolation, xefgSwapChain, and the non-FG ones for the reader) and the clear-census
qualifier reads MAY include generated frames when a frame-generation-capable marker is in the
file. A marker is code or a symbol name in the file, never proof it ran, and never an identity.
And when FG is not measured (2026-09-03): render the one number as Presented FPS —
144 FPS with a qualifier chip chosen by the census above, never the word "Native", never
a factor, never — (which means none, a measured negative). The chip is muted when no
frame-generation runtime was loaded and a warning when one was. 08_UI §FPS display rule
carries the three shapes.
Upscaling — measured, not guessed (Tier 1)
The NVIDIA driver's overrides are a configuration, not a measurement (beta.8, 2026-09-25). A session now also stores the driver profile its executable ran under (
sessions.driver_profile: the NVIDIA App's DLSS, Ray Reconstruction and frame-generation overrides, read from the driver's settings store — never from the game's process or memory, CLAUDE.md rule 4) and the driver's own per-process override report in full (ngx_driver_words: preset, mode, ratio beside the masks). Both are shown as what the driver was set to do and what it says it did — "NVIDIA profile …: DLSS override (preset K, Quality)" — and neither changes a measured value, a rung of the upscaler ladder or the frame-generation factor: those stay what the hooks saw.A profile override the hooks contradict is two true statements about different things, and the page shows both.(Struck 2026-10-19 for the quality mode only — the amendment below; render size, ratio and the frame-generation factor are unchanged.)Amended 2026-10-19 (owner decision D63): the override is the standard for the quality MODE — when the driver confirms it applied. The owner, shown the note above: an NVIDIA App override is what the game ran at, so it is the mode a session states.
Application.Recording.QualityResolver, read at display time from what every session already stores (ngx_driver_wordssince P2,driver_profilesince beta.8 — so a session recorded before reads alike): when DLSS super resolution ran (a hook named it, or the driver reports the feature created and evaluated) and the driver's per-process report says the override applied (ENABLEDwithPERF_MODE,SR_DLAA_MODEorSCALING_RATIO), the mode is the profile'sNGX_DLSS_SR_MODE(documented: 0 Performance, 1 Balanced, 2 Quality, 4 DLAA, 5 Ultra Performance, 6 a custom ratio withNGX_DLSS_SR_OVERRIDE_SCALING_RATIO), checked against the report'sperformanceMode; DLAA from its bit. The report is in NGX's own numbering, not the profile's — measured on the owner's ledger: Silent Hill 2 (2026-10-13) under the App's Ultra Performance (profile 5) was reported as 3, NGX's Ultra Performance, where the profile's 3 is "the game's own" (Expedition 33's Quality was 2 in both). When the two disagree, or the report alone carries a value that does not settle, the session reads as overridden with no mode — never the game's own value, which the override replaced. Otherwise the mode the game passed to a hooked call (the Streamline byte); otherwise none. Every surface says it the same way (Formats.UpscalerOf): DLSS (driver-reported) Quality · NVIDIA App, DLSS · NVIDIA App override, DLSS Quality. The live card names what the report settles by itself (upscalerQualityOverride,07_IPC). Nothing infers a mode from the render scale (HANDOFF§7a). Silent Hill 2's own session reads no mode: its word lacksCREATED | EVALUATE, so no super resolution ran that the driver saw. (Corrected 2026-10-20: it lacked them because the word stored had been read after the game closed — §The driver-reported rung. A session recorded from beta.27 keeps them; one recorded before, on a title no hook names, never reads the override's mode.)
From the upscaler hooks we get, per frame:
-
upscaler: the technology actually executing (dlss,fsr2,fsr3,fsr4,xess,nis,none;fsrsince 2026-09-04 — FSR through the SDK 2.x upscaler DLL, version not named) — from the API that was called, not from a DLL sitting on disk. (Corrected 2026-10-04:fsrwas missing here;fsr4is reserved and no writer produces it.)dlss_rris NOT a value of this field, and this line listed it until 2026-08-06. Layout v3 retired it and reserved the slot rather than reusing it, because it made Ray Reconstruction mutually exclusive with DLSS super-resolution — and the two run together. RR is an independent tri-state axis (§RT/PT/RR below, and CLAUDE.md rule 7's trio), carried asFL_FEAT_RAY_RECONSTRUCTIONinfeatureFlagswith its own OBSERVED bit. A consumer written from this line would have decoded the reserved value 2 asdlss_rrand resurrected the conflation the record had already removed. -
renderW × renderHvsoutputW × outputH→ exact upscale ratio:sqrt((outW×outH)/(renW×renH)), reported both as a ratio (1.50×) and a percentage (67% render scale). -
upscalerQuality: the vendor's own quality enum (DLSS Performance/Balanced/Quality/DLAA, XeSS quality setting, FSR preset), mapped to a display name per vendor inDomain.UpscalerNames.Domain.Metrics.UpscalerNamesexists since 2026-09-21; this line promised it from the start and the UI printed the raw integer until then. It holds ONE table because one producer exists:sl::DLSSModeas the title chained it intoslEvaluateFeature(1 Performance · 2 Balanced · 3 Quality · 4 Ultra Performance · 5 Ultra Quality · 6 DLAA;eOffand anything pasteCountnever reach a row). The ffx-api dispatch carries no quality and XeSS has no hook, so there is nothing of theirs to name. A value the table does not know is shown as stored. It names the MEASURED byte only — a label derived from the render/output ratio isHANDOFF§7a's owner decision, still not taken. (Corrected 2026-10-19, beta.25: the ffx-api dispatch still carries no quality, and FSR's mode now comes from the vendor's own query — the next note. XeSS still has no hook.)A second producer since beta.25 (2026-10-19, owner decision D65): FSR's mode, from the vendor's own query.
FfxApiUpscaleQualityModeis an input toffxQuery, which a title calls before it sizes its targets — "what render size (…GETRENDERRESOLUTIONFROMQUALITYMODE) or ratio (…GETUPSCALERATIOFROMQUALITYMODE) does this mode give at this display size?" — never to the per-frame dispatch, which carries the size alone. The Overlay hooksffxQueryon the four modules it hooksffxDispatchon (17_HOOK_ENGINE§Hook inventory), keeps each answer the vendor returned (one slot per mode), and an UPSCALE dispatch whoserenderSize(andupscaleSize, where the title states it) fits exactly ONE kept answer — a size answer exactly, a ratio answer within one pixel ofdisplay / ratio, the vendor truncating and an engine perhaps rounding — publishes0x10 + mode: 16 Native AA · 17 Quality · 18 Balanced · 19 Performance · 20 Ultra Performance (offset so FSR's Native AA, 0, can never be read as Streamline'seOff). No fit, two fits, or no query seen →0xFF. A session, its segments and the live card read one rule (Domain.Metrics.QualityByte): the most common told byte, and for FSR none when any FSR record was rendered at a size no FSR-named record has. A dynamic resolution still matches an answer at the top of its range, so the plain modal would name a mode the session mostly did not render at;legal/ACCURACY.mdpromises none ("FSR at a dynamic resolution among them — no mode is shown"). A "not told" record at a named size — a present that drained a frame-generation PREPARE alone, a frame before the title asked — is not that evidence. A title that sizes its targets without asking, or asked before the Overlay was loaded, reads none: the honest answer, not a gap.Domain.Metrics.UpscalerNamesdecodes the byte for thefsr,fsr3andfsr4tokens. Measured on the hook harness with the vendor stub answering as the SDK documents (fl_guard"FSR's quality mode", by size through the SDK 2.x loader and by ratio through the 1.1.x monolith); a real title is owner-only item 21 (Lies of P at Quality, then Performance). -
Resolution changes mid-session (user changed settings, or dynamic resolution scaling) produce segments: the session stores a segment list
(startFrame, renderW/H, outputW/H, upscaler, quality). Aggregates report the dominant segment plus a "settings changed during session" flag — averaging across a settings change is the classic way benchmark numbers become meaningless.Two segmentation axes exist, they compose in ONE order, and neither document said so until 2026-08-06. This one splits on a settings change;
fl_shm.h§swapchainIdsays the Agent "segments by this value and reports the dominant stream". Stream first, settings second. Patching a vtable slot patches the shareddxgi.dllclass vtable, so one hook sees every swapchain in the process — a title with a separate UI or video swapchain interleaves two streams in one ring, and splitting on resolution first cuts a new segment every time the two alternate, i.e. one segment per present.swapchainId == 0is "one undifferentiated stream", never a valid id, and must not be reported as the dominant stream while a real one exists — it is what the writer publishes when it could not identify the swapchain.A gap within a stream cannot be detected from
frameIndex.dllmain.cppassignsg_frameIndex++once per accepted present for the WHOLE PROCESS, four lines before it assignsswapchainId, so within one stream of an interleaved pair consecutive records' indices differ by however many streams are running. An interval rule keyed on "index advanced by exactly one" excludes every interval in any multi-swapchain title. Gaps come from the drain's own accounting (07_IPC§Protocol rules), which is where they are known.
Tier 2 has none of this: upscaler = unknown, ratio N/A.
The driver-reported rung — owner decision 2026-09-06, identity only
Three NGX-direct titles (Lies of P, Hell Is Us, Expedition 33) evaluate DLSS super resolution through a path no hook of this build sees, and printed
upscaler: N/Aon every capture. The NVIDIA driver keeps per-process bookkeeping of the feature —NvAPI_NGX_GetNGXOverrideState(R570+, MIT NVAPI,18_GPU_VENDOR_APISL3) returns a feedback word per feature — and measured 2026-09-06 (driver 616.64) itsCREATED | EVALUATEbits are set for a process with NO NVIDIA-app override on both no-override titles (20_OPEN_QUESTIONS§H5). So the capture host probes it out of process beside each module snapshot (in-process throughFrameLedger.NvapiBridge.dllsince 2026-09-10, P2 PR-E2;fl-probe-nvapi --ngx-state <pid>spawned before that — no injection, no consent either way), and theupscaler:line has a rung between the hooks andN/A:upscaler: Dlss (driver-reported: the NVIDIA driver reports an NGX super-resolution feature created and evaluated in this process - not counted by this hook)What it may claim: the vendor and the feature, attributed to the driver. What it may NOT claim, each one measured: a quality (
performanceMode/renderPresetare populated only under an NVIDIA-app override and are then the OVERRIDE's values — which is why, since 2026-10-19 (D63), the override's mode IS the session's mode where the report says it applied: §Upscaling's amendment above), a ratio or render size (scalingRatiois 0 even under the override), a frame-generation multiplier (FG_MODE/FG_MULTI_FRAMEstay clear andframeGenerationCountis 0 at ×4 — it is the override target). Corrected the same day, on the loop's own readings: the FG word DOES follow DLSS-G once the feature exists —CREATED | EVALUATEon Hell Is Us, Onimusha and DL:TB at ×4, the word CHANGING between the session's readings; the morning'sINITIALIZED | DLL_EXISTSwas read before creation. So the FG word is a second witness for the DLSS-G IDENTITY, printed besideframe generation:as agreement or a printed disagreement, and promoted toDlssG (driver-reported: …)only where the count is active and no tag named the technology. The COUNT is never the driver's. A hook's name always outranks it, and beside a hook's name the driver's word is printed as agreement, or as a disagreement printed rather than resolved. Beside anN/Awith the bit clear it prints the driver's negative, attributed, which says nothing about FSR or XeSS. The negative is owed (§H5): a title with DLSS switched off should read the bit clear; if it does not, the rung is withdrawn.The App states the rung since 2026-09-21; until then only the capture host's console did. The Agent has written
sessions.upscaler_driver_reportedsince P2, and nothing underFrameLedger.Appread it, so every NGX-direct DLSS title read "Unknown upscaler" in the library while FSR — whose dispatch the hook does see — was named (the owner's report).Formats.Upscaler(token, quality, driverReported)is the ladder in one place: a hook's name outranks everything and takes its measured preset; where no hook named one (unknown, or no claim) and the driver reports the feature, the text isDLSS (driver-reported)— attributed, identity only, never a quality even when a byte is on the row; otherwise the token's own text, andunknownnow reads "Upscaler not identified" (a hook ran and saw nothing — which is what it means — rather than "Unknown upscaler", which read as a product). The live card gets the same word throughSessionProgress.upscalerDriverReported(07_IPC). Segments carry no driver word: the driver's bookkeeping is per process, not per settings change. Nothing native changed and no NGX hook was added: the licence bar in20_OPEN_QUESTIONSstands.Corrected 2026-10-20 (beta.27): every stored word had lost the rung. The loop asked the driver once more after its last drain — on a session that ended because the game closed, after the game had gone — and that answer, the last, was the state (
NgxDriverState: "the last ANSWERED reading is the state"). The driver still answers for the pid, withCREATED | EVALUATEcleared: Expedition 33 read0x8067Fwhile it ran (2026-09-06) and its stored sessions0x8007F, the same word without the two bits. Of the 14 sessions in the owner's ledger copy in which the driver answered, none kept them — so no stored session reads DLSS (driver-reported), and none on an NGX-direct title under an NVIDIA App override reads its mode (D63). Since beta.27 the driver is not asked once the game has gone, and the two bits stand once a reading carried them: a game releasing its features on its way out no longer unsays them, and every other bit is still the last reading's. Sessions recorded before keep what they stored (spike-notes§23).
The render scale over time (beta.14, D49). The session summary draws 100 × √(render pixels / output pixels) — the
per-axis scale, 100 / upscale_ratio — as steps over the session: from the render_res blob where the resolution
varied (the finalizer stores it only then), a flat line at the row's extent where it did not, and a sentence where the
upscaler's parameters were never measured (App.Charts.RenderScaleSeries). The Trend and Compare read the row's
upscale_ratio, the dominant extent.
RT / PT / RR — evidence-based tri-state
Tri-state Yes | No | N/A per session with source (measured | manual | inherited).
| Flag | Tier-1 evidence | Result |
|---|---|---|
| Ray Tracing | BuildRaytracingAccelerationStructure called, or DispatchRays called, in ≥ 5% of frames |
Yes |
All three of: FlWriterState.rtTier ≥ 10 (an RT-capable device — rtTier is FlRtTier, and it has three states, not two: 0 not queried, 1 queried and this device cannot, and otherwise D3D12_FEATURE_D3D12_OPTIONS5's own tier value, which is already ×10); hooksInstalledMask contains RtAsBuild; and no AS builds and no dispatches for the whole session |
No |
|
| No RT-capable API in use (D3D11/OpenGL), or evidence inconclusive | N/A |
|
| Ray Reconstruction | NGX RayReconstruction feature created and evaluated (or Streamline DLSS_RR) |
Yes / No if DLSS is active without it |
| Path Tracing | heuristic only — see below | usually N/A |
Honest limits, documented in the UI tooltip:
-
Hooking
BuildRaytracingAccelerationStructureis what makes inline ray tracing (DXR 1.1RayQuery) detectable at all — those shaders never callDispatchRays, so dispatch counting alone would reportNofor a game that is very much ray tracing. AS-build activity catches both paths. This is why both hooks exist. -
Ray Reconstruction is decided over the presents that DRAINED a Streamline batch, not over every present, and the difference was the whole answer on a frame-generating title. The writer sets
FL_FEAT_RAY_RECONSTRUCTION_OBSERVEDunderseen != 0— deliberately, so an NGX-direct title running DLSS-RR does not collect a fabricatedNo— which at ×4 is roughly one present in four. A consumer that required the bit on every record was therefore asking for something that cannot hold above ×1, and reportedN/Aabout a title that answered the question 2,523 times out of 2,523. The population is the batch-carrying presents: none of them ⇒N/A(nothing looked, and the lazy-install prefix drops out with it), any of them carrying the fact bit ⇒Yes, batches with none ⇒No. This is also the one RR negative that may be aggregated, for the same reasonFL_UPSCALER_NONEis: a hook ran and saw the alternative. -
The row above says NGX and the producer is Streamline-only.
nvngx_dlssd.dllis a static hint (05_DETECTION) and never a runtime fact; the NGX runtime route is licence- blocked (18_GPU_VENDOR_APIS§Checklist step 3 forbids vendoring the RTX SDKs headers and forbids re-declaring them), so an NGX-direct title yields no batch at all andN/Ais the true answer there rather than a coverage excuse. -
Why
rtTierhas a third state, recorded because the two-state version was written down first and was wrong.D3D12_RAYTRACING_TIER_NOT_SUPPORTEDis 0, andrtTier's 0 already meant not queried — so a writer that stored the vendor enum verbatim would have published "nobody looked" about every machine without an RT-capable GPU.FlRtTiersubstitutes1for that one value. Both still fail≥ 10and both still yieldN/A, so the table above is unchanged; what changes is that the two are now distinguishable, which is what lets a future reader tell a capability gap from a coverage gap. -
The
Nobranch needs all three conjuncts, and the second is the one that is easy to drop. The AS-build hook is what makes inlineRayQueryvisible; a writer that installed onlyDispatchRayssees nothing on a RayQuery-only title, and its silence is indistinguishable from a real negative. RequiringRtAsBuildto have been installed — not merely for RT to have been "measured" — is what stops that becoming a confidentNoabout a title that ray-traces every frame. Where any conjunct fails the answer isN/A. -
Path tracing has no API-level signature. The heuristic combines three inputs: rays dispatched per output pixel ≥ ~1.0,
MaxTraceRecursionDepthfrom the RT PSO config, and the number of distinct RT state objects (FlWriterState.rtStateObjectsCreated). It produces a confidence score, and only ≥ 0.8 offers a suggestion in the UI ("looks like path tracing — confirm?"). It never setsYeson its own. Manual override remains the authoritative path, per game, inherited by future sessions.A fourth input — "the ratio of RT to raster work" — was listed here and is removed, 2026-08-05. It has no cheap denominator: counting raster work means a per-draw hook, which is a hot-path cost this project will not pay, and
§H6records that a command-list count measures recorded rather than executed work anyway.rays_per_pixelalready carries the intent. Removing an input weakens a score that may only ever suggest; it cannot produce a fabrication, which is why it is a removal and not a blocker.FlWriterState.rasterPsoCreatedis kept as the cheapest available proxy should anyone revisit it. -
A game can also enable RT for a subset of effects only;
Yesmeans "rays were traced", not "everything is ray traced". The UI says so.
Derived extras (Tier 1): rays_per_pixel (mean dispatch volume ÷ output pixels), rt_frame_pct (share of frames with RT activity), rt_pso_count.
The denominator, decided 2026-08-20 with the PR that wrote the hooks, because
§Counting native vs displayedleft it open and the hooks could not land without one.
rt_frame_pctis a share of PRESENTS, and it says so. Under frame generation that dilutes it by the FG factor — at ×4 a title that ray-traces every application frame reports ~25%. The tri-state is unaffected, and that is the whole reason this choice is safe: theYesgate is ≥ 5% of frames, and 25% clears it by a factor of five. The number that is diluted is the reported percentage, not the verdict, and the label carries its unit.
rays_per_pixelis taken over the RT-ACTIVE presents, not over all of them, and is therefore undiluted: the writer drains its accumulator at every present, so a frame's whole dispatch volume lands on one present, and generated presents contribute zero volume and are not in the denominator. This needs no application-frame count — which is fortunate, becauseHANDOFFitem 3 could not produce one.The falsifier, written before the run rather than after it: on a ×4 capture,
rt_frame_pctshould read ≈ 25% and not ≈ 100%. If it reads ≈ 100%, generated presents ARE carrying recorded work, the premise above is wrong, andrays_per_pixelover RT-active presents is wrong with it. Record the number and say so rather than reinterpreting it.The unit is RECORDED, not executed (§H6). Both hooks sit on command-list methods, so they count work recorded between two presents — possibly on several threads, possibly re-executed, possibly never executed at all. Aggregates derived from them inherit that word. The concurrency model is relaxed atomics written by any recording thread and drained once per present with
exchange(0), the same shapeg_slSeenalready uses.
dispatchRaysVolumesaturates atUINT32_MAXrather than wrapping, because it is the NUMERATOR ofrays_per_pixeland a wrapped value under-reports exactly the titles the path-tracing heuristic exists to recognise. A consumer seeing the ceiling must refuse to publishrays_per_pixelrather than divide by a floor. This is the mirror offgEvaluations' 255, which saturates for the opposite reason — that one is a denominator.And
FL_MEASURED_RTsays a hook family was live, not that all three of its fields have producers. Which ofrtFlags,dispatchRaysVolumeandmaxTraceRecursionDepthmay be read comes fromhooksInstalledMask, exactly asFL_MEASURED_UPSCALERandFL_MEASURED_UPSCALER_PARAMSsplit the upscaler's identity from its parameters. As of 2026-08-20maxTraceRecursionDepthhas no producer:CreateStateObjectis a separate PR, andpt_confidencereads it, which is one of the reasons Path Tracing is stillN/A.
Display mode — both tiers (beta.10)
Owner request, 2026-09-27: "detect the game's window size and whether it runs full-screen, borderless or windowed,
and how much of the time". Schema 0016 (06_DATA_MODEL), shared-memory region 4 (07_IPC, layout 4), the Agent's
Application.Capture.DisplaySampler, Domain's Display.DisplayModeClassifier and Display.DisplayTally.
Two witnesses, and neither reads the game.
- The swap chain's own answer — Tier 1, DXGI only. The Overlay asks
IDXGISwapChain::GetFullscreenStateandGetDescon the chain the game passed toPresent, at most twice a second per chain, and publishes the chain with the largest back buffer in region 4: its window, back buffer, swap effect, and whether it is exclusive (17_HOOK_ENGINE§Hook inventory — polled, not aSetFullscreenStatehook). OpenGL publishes its window and client area with no exclusive answer; the Vulkan layer publishes nothing yet. - The window from outside — both tiers. The Agent asks user32 about the game's top-level window: minimised or not, the
client area in screen coordinates, the monitor it is on and that monitor's refresh rate — per-monitor DPI aware while it
asks, because the Agent runs DPI-unaware and Windows would otherwise scale another process's coordinates
(
Infrastructure.Display.WindowGeometryProbe). The window is the one region 4 names when it still belongs to the game (a handle is reused once its window is gone), else the largest visible, uncloaked, non-tool top-level window of any process running the game's executable — found by image path in the watcher's snapshot for a Tier-2 session that never opened the process. This is the focus sample's class of question: CLAUDE.md rule 4 is about game memory, and no handle to the game's process is opened for it.
The ladder, per sample (DisplayModeClassifier):
| Mode | When | Column (ms) |
|---|---|---|
| No window | no window could be read and the chain did not say exclusive | display_nowindow_ms — outside every share |
| Minimized | the window is minimised | display_minimized_ms |
| Exclusive fullscreen | a region-4 sample under 2 s old in which the swap chain SAID exclusive | display_exclusive_ms |
| Borderless | the client area covers its monitor (±1 px each edge) and the chain said not exclusive | display_borderless_ms |
| Fullscreen or borderless | the client area covers its monitor and nothing could say which — OpenGL, Vulkan, every Tier-2 session | display_covers_ms |
| Windowed | anything else | display_windowed_ms |
Time, not ticks. A sample stands for the wall time until the next: every drain tick (100 ms) hooked, every hold tick
(1 s) at Tier 2 — so the two add up in one unit, milliseconds. An interval that ends on a paused tick is dropped, which
excludes a pause to within one tick at each edge, as the frame series' gap does. A mode's share is its milliseconds
over the observed time (every mode but No window). display_changes counts samples whose mode differs from the one
before, no-window samples skipped. The sizes — display_window_* (client area), display_buffer_* (back buffer),
display_monitor_* and display_monitor_hz — are the ones seen in the mode that lasted longest (corrected 2026-10-20,
beta.27: the last ones a sample of that mode SAW — a game leaving exclusive fullscreen closes its window while its swap
chain's last word is under 2 s old, and those last samples, exclusive with no window, had replaced every size: two Lies
of P and three Dark Souls III sessions stored none. A mode no sample of which saw its window keeps the back buffer
alone); display_source is the
strongest witness any sample had (swapchain > opengl > window). sessions.swap_effect, a column since 0001 with no
writer, is written from region 4.
What it cannot say (the user-facing list is LIMITATIONS.md):
- Exclusive is what the game asked DXGI for. Windows may still present such a game through the compositor ("fullscreen
optimizations"), and a flip-model borderless window may be promoted to independent flip; neither is visible without a
trace session, which FrameLedger does not have (
20_OPEN_QUESTIONS§G). - A game's menu may call a borderless window "Fullscreen"; the swap chain's answer is what is reported.
- A minimised game issues only occlusion probes, which the hook drops before sampling: a region-4 sample older than 2 s keeps its window and loses its exclusive bits.
- Tier 2, OpenGL and Vulkan can never tell exclusive from borderless. Their covering time is Fullscreen or borderless, and the trend draws no exclusive or borderless point for a session with any of it.
- A session recovered from its
.partialfile has no display facts — the tally is not in the crash file — and reads N/A. The focus pair, which the partial carries, is the precedent this does not follow.
A side effect of region 4's poll (layout 4). GetDesc every 500 ms also refreshes the chain's output size, which
catches a ResizeBuffers1 the hook inventory does not have: a title that resizes through it now splits its segments at the
change and reads "settings changed mid-session" (FR-6.4), which is what it was.
Where it is shown (08_UI): the session summary's Display card and line, the game page's last measured session and
its Sessions column, three Trend metrics — Exclusive fullscreen share %, Borderless share %, Windowed share %, every
tier, and a mode switch is not a mid-session change for them (switching resizes the swap chain; the share is what that
switch was) — three Compare rows, never ranked, and the CSV's # display: line (§Export schema) and the JSON's aggregates.
Game process memory — both tiers (beta.12, owner decision D43)
What is measured since 2026-10-03: the game process's own memory, read from OUTSIDE the game once a second by the
Agent through FrameLedger.ProcessStats.dll (18_GPU_VENDOR_APIS §The game process's memory) — never from the game's
memory (CLAUDE.md rule 4):
| Figure | Source | What it is |
|---|---|---|
Dedicated GPU memory (game_vram_dedicated) |
PDH \GPU Process Memory(pid_<pid>_luid_…_phys_<n>)\Dedicated Usage, every instance naming the pid summed |
the number Task Manager's Details tab shows under that name |
Shared GPU memory (game_vram_shared) |
the same counter set's Shared Usage |
system memory the GPU uses on the game's behalf |
Memory — private working set (game_ram_private) |
GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS_EX2.PrivateWorkingSetSize |
Task Manager's "Memory" column; N/A on a Windows that predates EX2 (Windows 10 22H2 / 11 22H2 without the September 2023 update) |
Working set (game_ram_ws) |
WorkingSetSize |
the whole working set, shared pages included; what the card falls back to where the private working set is N/A |
Commit (game_commit) |
PrivateUsage |
private memory committed, resident or not |
Which process. A hooked session — and any session refused after the loop pinned the process — reads the pinned pid
through the handle the session already holds (SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION). An unpinned Tier-2 hold
(hooking off, blocked, unresolved, cannot pin) reads every process running the game's executable in the watcher's
snapshot, each opened for the read with PROCESS_QUERY_LIMITED_INFORMATION and closed after it, and SUMS them; a process
whose creation time is not the snapshot's (a reused pid), or that refuses even that right, is left out of both halves.
game_memory_processes says how many were summed. Child processes of another executable (a launcher, a crash handler, a
web view) are not counted.
Dedicated is not the DXGI budget model's "local usage". dwm.exe read 858 MB dedicated against 310 MB local at an idle
desktop, and a test process holding a buffer read 4.5 MiB more dedicated than its own QueryVideoMemoryInfo(LOCAL) at
both 8 MiB and 512 MiB (spike-notes §16, M3) — a constant per-device amount, not one that grows with the game's
allocations. So dedicated is defined as Task Manager's column and is never compared with a budget: the budget and
budget_exceeded_pct stay unmeasured (20_OPEN_QUESTIONS §M11), and vram_proc_* / vram_budget_exceeded_pct /
FlFrameRecord.vramUsedMb stay reserved for that in-process figure.
Aggregates (schema 0018): dedicated avg / median / max, shared max, private working set avg / median / max, working
set max, commit max, the process count, the sources (counters,ex2,ex,held,opened), and every series' n / mean / median /
min / max in sensor_stats_json (§Sensor aggregates). MiB stored; shown in GB as Task Manager does (1 GB = 1024 MiB).
The paragraph below is the design that was never built, kept as it stood (struck 2026-10-03: the Overlay never called
QueryVideoMemoryInfo—dllmain.cpplistsFL_MEASURED_VRAMas unproduced, §H10 never settled where in the game to call it — and D43 chose the outside read instead).
vramUsedMb from IDXGIAdapter3::QueryVideoMemoryInfo(LOCAL) inside the game = this game's usage and budget. MiB, truncating, and it must use the same divisor as vramBudgetMb — the two are compared, and mismatched rounding would put a systematic bias into budget_exceeded_pct. Residual: a flip within 1 MiB of the budget, 0.004% of a 24 GiB card. Stored as its own series and clearly labelled apart from the adapter-wide figure from 18_GPU_VENDOR_APIS. Aggregates: avg, max, and budget_exceeded_pct (share of samples where CurrentUsage > Budget, i.e. the driver was likely evicting — a genuinely useful stutter explanation).
Sensor aggregates
Per session over 1 Hz samples: avg (mean of non-null), max — and since beta.12 the median (the linear-interpolation
50th percentile: the middle sample of an odd count, the mean of the two middle ones of an even count) and the min
(Domain.Metrics.SeriesAggregates). Every stored series' n / mean / median / min / max is written once at finalize to
sessions.sensor_stats_json, so the summary's statistics read stored values and outlive a retention sweep of the raw
series. Sensor timeline aligned to the frame timeline via the shared QPC epoch captured at session start. Fields with no
data are N/A, never 0.
The card's clocks and limits (beta.14, D49), both tiers. The core and memory clock (MHz), the fan (RPM) and the
memory temperature were in the samples before (L2 reads them, L3 too) and stored nowhere; they are series now
(gpu_core_clock, gpu_mem_clock, gpu_fan, gpu_mem_temp) with avg_gpu_core_clock_mhz, avg_gpu_mem_clock_mhz,
avg_gpu_fan_rpm and max_gpu_mem_temp. What held the card back is NVAPI's perf-decrease reasons
(GpuSample.ThrottleReasons, L3 only): gpu_power_limit / gpu_thermal_limit read 100 on a tick whose reasons include
the power limit (0x2) / thermal slowdown (0x1) and 0 on one whose reasons do not, so their mean — power_limit_pct,
thermal_limit_pct — is the share of ticks held back. A card no layer reports reasons for (every card but NVIDIA's) has
no answer: N/A, never "not limited". throttle_pct (any reason) is unchanged.
Efficiency (beta.14, D49)
app_frames_per_joule = the application frame rate ÷ the card's average board power — FPS per watt, frames per joule.
Never the displayed rate (rule 6): a generated frame costs the card a fraction of a rendered one, and counting it would
sell frame generation as efficiency. The application rate is known when frame generation was counted over the session
(Native FPS; a counted none makes it the presented rate), or when no frame-generation runtime was loaded
(presented_qualifier = no_fg_runtime). Null for census_not_run, fg_runtime_loaded and none_withheld, for a
session whose generation changed state (its steady state covers a share of the session, and the power is the whole
session's), without a power reading, and at Tier 2 (no frames). The power is the graphics card's — not the
processor's, not the whole PC's — averaged over the session's sensor ticks. Domain.Metrics.EnergyEfficiency,
SessionAggregator.ApplyEfficiency.
Accuracy budget (shown in Help → About metrics)
(Corrected 2026-10-04: no such page exists. Users read these limits in LIMITATIONS.md (Help ▸ Limitations) and in
legal/ACCURACY.md, which it links.)
| Quantity | Tier 1 | Tier 2 |
|---|---|---|
| Frame times / FPS | < 0.05% (direct QPC at the present call) | not available |
| Native vs Displayed / FG factor | exact counts when rung 1 resolves; N/A otherwise, with the runtime census qualifying the presented figure — the census cannot see a statically linked FSR or any out-of-process generation, so its "cannot include generated frames" is bounded by those two holes and says so |
not available |
| Upscaler + render resolution | exact (vendor API arguments) | not available |
| RT active | measured per frame | not available |
| Path tracing | heuristic, confidence-scored, never asserted | not available |
spike-notes §16); private working set equal to Windows' own counter; read from outside the game |
||
| PC latency | as reported by Reflex | not available |
| Display mode (beta.10) | per 100 ms sample: exclusive fullscreen as the swap chain answers it (DXGI; OpenGL and Vulkan cannot say), borderless, windowed, minimised; the window's size from user32 | per 1 s sample, from the window alone: windowed, minimised, or fullscreen or borderless — never split |
| GPU temp / load / power | vendor API accuracy, ±1 s sampling | same |
| GPU clocks / fan / memory temperature (beta.14) | vendor API accuracy, ±1 s sampling | same |
| GPU power / thermal limit (beta.14) | NVAPI's perf-decrease reasons once a second — a limit that came and went between two ticks is not seen; NVIDIA only, N/A on every other card | same |
| Time below 30 / 60 / refresh (beta.14) | from the frame times above, with the margins of §Pacing — a rate less than 2 % under the threshold reads partly as at it | not available |
| Efficiency (beta.14) | the application rate's accuracy over the board-power sensor's; N/A wherever the application rate is not known | not available |
| CPU temperature | sensor-inherent ±1–2 °C, needs LHM + PawnIO + elevation. Read since 2026-09-21 (Telemetry.LhmCpuTemperatureReader: the package sensor, else the hottest core) and unmeasured on real hardware — no elevated run with PawnIO has been taken (20_OPEN_QUESTIONS §CPU) |
same |
| CPU load | time busy over elapsed, every logical processor (GetSystemTimes, 1 Hz, unprivileged; since 2026-09-21). Not Task Manager's "utility", which is frequency-scaled and exceeds 100 under turbo — the two are different numbers and this one is stated as what it is. Null on a session's first tick (no interval yet), never 0 |
same |
| System memory in use | physical memory in use machine-wide, MiB (GlobalMemoryStatusEx, 1 Hz, unprivileged; since 2026-09-21). The machine's, not the game's |
same |
The Tier-2 column is now "not available" for everything except sensors, and that is the whole change. It previously claimed frame times within 0.1% without injection. Nothing produces them.
Export schema (per-frame CSV, FR-9.1)
frame_index,qpc_ms,frametime_ms,native_or_generated,render_w,render_h,output_w,output_h,upscaler,upscaler_quality,fg_mode,rt_flags,dispatch_rays,pso_created,vram_mb,reflex_latency_us
Every column above must have a stored source. The export is written from
frame_blobs after the session ends, not from the live ring, so a column is
only exportable if the finalize step (04_CAPTURE §Finalizing) persisted it.
The blob set in 06_DATA_MODEL is defined to cover exactly this list — when
adding a column here, add its series there in the same change, or the exporter
will emit a column it cannot fill.
Per-column sources, and what a Tier-2 export does instead:
| Column | Tier-1 source | Tier 2 |
|---|---|---|
frame_index, qpc_ms, frametime_ms |
frametimes blob + session qpcEpoch |
|
native_or_generated |
frame_flags generated bit — set where fgEvaluations == 0, i.e. the presents that carried no application-frame evaluation. Inverted from the pre-2026-08-14 reading, and accurate to one frame per the note in §Frame Generation |
FrameType (2.x) |
render_w/h, output_w/h |
render_res blob — two uint16 pairs per frame, not one; ResizeBuffers is hooked precisely because output resolution changes mid-session |
N/A |
upscaler, upscaler_quality, fg_mode |
segment table, joined by frame index | N/A |
rt_flags |
rt_flags blob, one byte per frame preserving all three bits (asBuildObserved, dispatchObserved, psoCreatedEver) — collapsing them to a single "rt-active" bit loses the inline-RayQuery distinction this project exists to measure. The third was rtPsoAlive until layout v3 renamed it: creation is observed at CreateStateObject and destruction is COM Release, which is not in the hook inventory and must not be added, so the bit latches and could only ever mean "created ever" |
N/A |
dispatch_rays |
dispatch_rays blob (uint32[], the volume) |
N/A |
pso_created |
pso_created blob (uint16[], the count, not a flag) |
N/A |
vram_mb |
vram_proc per-frame blob. 17_HOOK_ENGINE §Memory) so it is a held sample, not a per-frame measurement — the header block says so# game_memory: header line (beta.12, §Game process memory) |
N/A |
reflex_latency_us |
latency_us blob; finalize must write it |
N/A |
Plus a #-prefixed header block: game, date, capture tier, api, present mode, swap effect, the display line (beta.10: # display: with each mode's milliseconds, the changes, the source and the window / back buffer / monitor sizes, or N/A for a session recorded before — §Display mode; a mode is the session's, not a frame's, so it is not a column), hardware snapshot, segment list, the tri-state flags with their sources, and the note that the game's memory (beta.12: vram_mb is 1 Hz-sampled# game_memory: with the dedicated GPU memory's mean / median / max, the shared max, the private working set's mean / median / max, the working set's and the commit's max — MiB, invariant — the process count and the sources, or N/A for a session recorded before or one where nothing answered; the session's figure, read once a second, so a header line like the display's), and the note that vram_mb is the in-game figure this build does not produce. The tier belongs in the header because a Tier-2 export is missing whole columns and anyone reading it later must know why.