Measured, archived, reproducible

Benchmarks

This page summarizes recorded repository evidence. The raw reports remain the source of truth because a clean headline without its machine, runtime, warmup, workload, allocations, and caveats is just marketing with decimals.

Report families38Checked-in archives through October 7
Strategic backendSDL3 GPUCompared directly with WindowsDX
Aspect visual diff0 pxTwo 1600 x 900 Aspect scenarios, August 27
Honest frame gateREDLatest SDL3 16.6667 ms target remains red
01 / Historical renderer evidence

SDL3 GPU versus WindowsDX

This historical comparison predates the MonoGame/WindowsDX removal and is not a current migration benchmark. The same retained Prism command list rendered a 256 x 144 scene with Gaussian blur, emboss, and hue/saturation. Each backend warmed for 12 frames and measured 96 submitted and presented frames on the same machine.

WindowsDX CPU frame6.9028 ms96 measured frames
SDL_GPU CPU frame6.8673 ms0.9949x WindowsDX
SDL_GPU allocation+7.1%229,163 B/frame
Fallbacks0Both backends
Presented retained workload

Backend comparison

Lower is better for time, allocation, and resource use. Counters explain the work; they do not magically make different backend pipelines identical.

MetricWindowsDXSDL_GPUSDL_GPU / WindowsDX
CPU frame time6.9028 ms6.8673 ms0.9949x
Managed allocation214,037 B/frame229,163 B/frame1.0707x
Peak Prism GPU resources2,359,056 B3,047,144 B1.2917x
Last retained-frame Prism passes122.0000x
Last Prism CPU submit126.2 us284.2 us2.2520x
Active transient surfaces after frame00Equal
AssessmentNo end-to-end CPU regression in this run

The 0.9949x CPU-frame ratio is below the plan's 1.25x investigation threshold. SDL_GPU still used one extra presentation pass, 688,088 more peak Prism-resource bytes, and 7.1% more managed allocation. Those costs stay recorded instead of disappearing behind the headline.

02 / Real application evidence

Frame budget and Aspect migration

The August Aspect comparison used the real SDL3 Presentation tour, eight cycles, 45 frames per chapter, and a 16.6667 ms target. The target was RED before and after the migration, so the valid claim is comparative, not a fake pass.

Aspect warm p990.0726 ms0.44% of frame target
Aspect maximum0.1766 msFinal SDL3 run
Allocation/frame-0.7%643,430 B to 638,750 B
Visual changes0 pxTwo 1600 x 900 captures
Overall targetREDBefore and after migration
Same SDL3 Presentation workload

Aspect migration comparison

The higher processed count proves generated markup moved onto the canonical Aspect engine. Absolute scheduled Aspect cost remains visible beside that architectural change.

MetricBaselineFinal
Warm scheduled Aspect mean0.000381 ms0.001877 ms
Warm scheduled Aspect p990.0005 ms0.0726 ms
Scheduled Aspect maximum0.0889 ms0.1766 ms
Processed Aspect elements56172
Mean allocation per frame643,430 B638,750 B
Visual conformance

Application-owned captures

Both images were captured through Window.SaveScreenshot.

ScenarioPixelsChangedResult
Aspect Studio1,440,0000GREEN
Build-Time Markup1,440,0000GREEN
Earlier WindowsDX gate

July frame-budget repair

This is a different backend and run. It must not be substituted for the later SDL3 result.

StateGlobal maximumOver budget
RED baseline52.880 ms113 frames
Final WindowsDX run14.763 ms0 frames
03 / Build-time and editor paths

Language core and Visual Studio

The language baseline measures parsing, local edits, semantic binding, and warm queries. The Visual Studio archive uses a hidden Community Experimental Instance and records cold activation, editor latency, soak memory, and resilience.

21,123-character real document

AspectChapterView.crn

Forty measured iterations after eight warmups, Release, .NET 8.

Operationp95MaxAllocated
Parse cold1.386 ms5.505 ms285,384 B
Parse warm1.447 ms8.017 ms279,296 B
Incremental edit1.534 ms1.925 ms369,984 B
Semantic bind14.923 ms15.999 ms2,479,080 B
Warm query0.062 ms2.076 ms464 B
Visual Studio Community 18.0

Cold and full-solution observations

Cold gates apply where a budget is shown. Warm editor presentation rows are recorded observations, not relabeled server-only passes.

WorkspaceMetricValueBudgetResult
FixtureProvider activation CPU15.625 ms100 msGREEN
FixtureServer ready cold833.196 ms2,000 msGREEN
FixtureFirst completion cold1,357.454 ms2,500 msGREEN
Cerneala.slnxServer ready cold964.291 ms2,000 msGREEN
Cerneala.slnxFirst completion cold1,922.658 ms2,500 msGREEN
Cerneala.slnxEditor completion p95228.241 msNoneGREEN
Visual Studio result30 in-process checks and 4 resilience checks GREEN

The soak covered 100 document open/close cycles and 1,000 editor changes. The resilience matrix covered server restart, solution reload, extension disable, unavailable server, and process cleanup. Raw JSON is stored beside the report.

04 / Retained runtime

RenderSurface2D, queues, Relay, and cache reuse

These reports cover different layers and different dates. The numbers stay separated by workload. The shared contract is that idle and reusable work should not quietly become tree scans, command storms, or allocation churn.

RenderSurface2D drawing API

Accepted August 24 baseline

BenchmarkDotNet ShortRun. Relative command-count and allocation invariants are the primary gates for the shortest manually invoked methods.

ScenarioMeanManaged allocationEvidence
1,000 individual point commands544.217 us0 B observedBaseline
Immutable 1,000-point batch1.767 us0 B observed0.003x command time
Build 1,024-point polygon56.984 us234,130 BBaseline
Record reusable path114.1 ns0 BAbout 0.002x rebuild time
Rebuild text layout41.594 us39,009 BBaseline
Reuse immutable text layoutBelow measurement floor0 BZero-cost reuse result
Queue Engine idle5.216 ns10,000-node tree, 0 B after warmup
UiRelay drain 1,02456.575 usInitial archive, 120 B/frame
WPF drain comparison97.78x9,361.66 us versus 95.74 us
Prism common instances-80.9%CPU cache-on delta, 0 B/frame

These are historical same-run results, not universal multipliers. Queue Engine 2.0 removed the tree-size dependency from warmed idle checks. The WPF comparison covers a deliberately narrow scheduling and drain contract, not the complete WPF Dispatcher feature set. Prism cache wins apply to stable retained scenes; dynamic scenes correctly record misses and their cost.

Complete recorded index

Thirty-eight report families, with their raw context

The website is a readable index. The checked-in Markdown, JSON, CSV, logs, screenshots, and BenchmarkDotNet output are the durable evidence.

Repository archiveJuly 13 through October 7, 2026
  • 01

    Queue Engine 2.0
    Idle checks, sparse snapshots, shared order, drain, rebuild, and detach.

  • 02

    UiRelay
    Scheduling, bounded drain, concurrent producers, and binding coalescing.

  • 03

    WPF Dispatcher comparison
    Two complete controlled runs and raw BenchmarkDotNet reports.

  • 04

    Presentation frame budget
    RED baseline, allocation investigation, three-run gate, and human visual confirmation.

  • 05

    Prism filter catalog
    Optimizer, passes, transient surfaces, CPU submission, and warm allocation.

  • 06

    Prism cache-off baseline
    Reference workload before retained pixel-cache reuse.

  • 07

    Prism retained cache
    Static wins, dynamic misses, deterministic counters, and memory budgets.

  • 08

    Prism integration hardening
    Timing matrix, preview scaling, eviction, failure behavior, and dogfood gate.

  • 09

    Language core
    Parsing, local edits, semantic binding, warm queries, and allocations.

  • 10

    Visual Studio Community extension
    Cold startup, warm editor paths, soak memory, and resilience.

  • 11

    RenderSurface2D drawing API
    Batches, shapes, state, strokes, paths, and text-layout reuse.

  • 12

    SDL_GPU Prism comparison
    Same-machine WindowsDX comparison with CPU, allocation, passes, and resources.

  • 13

    Aspect unification
    BenchmarkDotNet, deterministic metrics, frame budget, pixel diffs, API diff, and final verification.

  • 14

    Cerberus
    Whole-frame and planner allocation microbenchmarks. Homogeneous merge and index rebasing (1,024 ops): 165.1 ns, 0 B.

  • 15

    Servo API compatibility
    Strict ApiCompat against a detached baseline: exactly 119 approved differences.

  • 16

    RenderSurface2D scene foundation API
    Strict ApiCompat: exactly the 12 additions frozen by the plan.

  • 17

    Collision stage 0
    Algorithm market and gates. Large-sparse query P95: 62,568.8 us exhaustive, 172.9 us sparse grid.

  • 18

    Collision stage 2
    Production spatial runner. Large-sparse update P95 107.6 us, query P95 268.6 us, PASS; all three scenarios PASS.

  • 19

    Collision stage 5
    Door collision captures: 5,600 changed pixels on WindowsDX, 8,775 on SDL_GPU, collision and coordinate checks PASS.

  • 20

    Sprite animation stage 0
    RED contract before the capability existed: core 7/7 and SourceGen 5/5 tests fail.

  • 21

    Sprite animation stage 2
    Test counters only (TRX): core 11/11, SourceGen 507/507 passed.

  • 22

    Sprite animation stage 3
    10,000 active animations: temporal P95 7,825.3 to 5,818.1 microseconds; allocation 2,720,008.96875 to 8.96875 bytes/tick.

  • 23

    Sprite animation stage 4
    Visual conformance and final gate: 4,468 passed, 0 failed, 0 skipped, one test excluded by waiver. The manual visual check was not performed by a human.

  • 24

    TileMap2D baseline
    Before optimization: warm static P95 CPU 3495.2 us, 2,910,116 B allocated per operation.

  • 25

    TileMap2D stage 3
    Chunk cache and culling captures: 258 chunks, at most 4 candidates, exactly 1 visible chunk.

  • 26

    TileMap2D stage 4
    Optimized: warm static P95 458.8 us against a 875 us gate; all 19 archived gates pass.

  • 27

    TileMap2D stage 5
    WindowsDX vs SDL_GPU pixels: 8,525 / 8,525 / 8,235 pixels over channel tolerance, all accepted as one-pixel edge differences, 0 unresolved.

  • 28

    Text characterization
    Raster-blob cache baseline, not a gate: 40 PASS / 1 intentional RED; a saturated cache reuses 0/255 repeat requests.

  • 29

    Timbre core stage 0
    Frozen surface and baseline: characterization 103/103, new harness 15/15 passed.

  • 30

    Timbre core stage 1
    Sink, reader, and transport: 84/84 GREEN; full Cerneala.Tests 4195 passed, 0 failed, 2 skipped.

  • 31

    Timbre core stage 2
    DSP and tails: 117/117 passed; the full corpus ran 50 times in a row with 0 failed runs.

  • 32

    Timbre core stage 3
    Cost campaign, five processes: verdict PASS, P99 max/min variation 1.22x.

  • 33

    Timbre decoding stage 0
    Streaming heap footprint: MP3 22.05 kHz mono 177 592 B (VBR) and 181 624 B (CBR 64k); Vorbis 644 728 B.

  • 34

    Timbre decoding stage 1
    Decoder selection: 250/250 passed; NLayer MP3 defect at 7.89 dB, 26.02 dB with the pinned local patch.

  • 35

    Timbre decoding stage 2
    Streaming decode memory per codec: 299/299 passed three times in a row.

  • 36

    Timbre decoding stage 3
    Cost campaign: verdict PASS on every process, P99 max/min 1.33. An earlier disturbed run failed on process 5 with 919 device underrun frames.

  • 37

    Timbre motion stage 3
    Two campaign runs disagree: campaign FAIL (3712 underrun frames on one process), campaign-2 PASS. No file says which run is authoritative.

  • 38

    Timbre SDL3 stage 3
    SDL WASAPI cost: PASS 5/5, mixer P99 0.35-0.45 ms; full solution 6981 pass, 0 fail, 7 skip.

How to read this

Evidence has boundaries.

These numbers describe recorded workloads on recorded machines. They are useful baselines and regression evidence, not hardware-independent promises about every game or application.

Archive families38Each linked above
Latest recorded evidenceOctober 7, 2026Timbre audio
Primary runtime target.NET 8SDK and machine vary by report
Timing harnessesBDN + runtime runnersNot every workload belongs in one harness
Visual captureWindow.SaveScreenshotApplication-owned screenshots
Raw evidenceRepository-ownedMarkdown, JSON, CSV, logs, and images
Comparison rule

Compare within the recorded experiment

Before and after values are meaningful when machine, runtime, configuration, workload, and warmup are controlled. Do not combine unrelated reports into one fake leaderboard.

Warmup rule

Cold and retained work are different

JIT, shader creation, uploads, cache promotion, and first-use resource work must remain visible. A warmed zero-allocation path does not prove cold startup is free.

Correctness rule

Timings do not replace invariants

Tests separately guard idle traversal, exact-once dispatch, bounded backlogs, cache invalidation, resource cleanup, draw purity, and visual conformance.

Regression rule

Noise is not a root cause

Short runs can have broad confidence intervals. Reproduce on equivalent hardware, inspect counters and allocations, and only then assign ownership to a subsystem.