3D engine that AI agents drive
Time the #623 proof with warm kernels, print the still's traced time and tree equality, and reconcile the light choice figures
Nguyen Xuan An18083a7e49ac
diff --git a/bench/reference/progressive-compare.mjs b/bench/reference/progressive-compare.mjsindex b0c05e7d..7c74a03c 100644--- a/bench/reference/progressive-compare.mjs+++ b/bench/reference/progressive-compare.mjs@@ -1,7 +1,9 @@// Draws reference scenes progressively (issue #623) and measures the time against the 64 sample still.// node bench/reference/progressive-compare.mjs <output directory> <scene id or recipe.json>,... [--variant random|uniform|blue|importance|tree|both]-// [--checkpoints 1,2,4,8,16,32,64] [--firefly-clamp 1e9] [--width 960] [--height 540] [--still] [--frames 200]+// [--checkpoints 1,2,4,8,16,32,64] [--firefly-clamp 1e9] [--width 960] [--height 540] [--still] [--warm] [--frames 200]// Files are <scene>@<variant>-<samples>.png, <scene>@still-64.png and timings.json; bench/reference/progressive-score.py scores them against Cycles.+// With --warm every scene first runs a 1 sample still and a 1 sample progressive draw for each variant, so the timed still and the timed+// progressive draw both start with the GPU kernels compiled; the warm-up compile seconds are written to timings.json as <scene>:<variant>:warm.// With --frames the script also prints the median time of one full size sample (1 sample per pixel) for each scene.// Run it behind a GPU lock when other jobs share the GPU: it takes the whole GPU for seconds at a time.import { mkdir, readFile, writeFile } from 'node:fs/promises';@@ -58,6 +60,14 @@ try {const isRecipe = id.endsWith('.json');const source = isRecipe ? JSON.parse(await readFile(id, 'utf8')) : id;const name = isRecipe ? recipeName(id) : id;+ if (argumentsGiven.includes('--warm')) {+ const warmStill = await page.evaluate(([scene, options]) => (typeof scene === 'string' ? window.renderReferencePathTraced(scene, options) : window.renderRecipePathTraced(scene, options)), [source, { ...baseOptions, samples: 1, backend: 'gpu' }]);+ timings[`${name}:still-warm`] = { seconds: Number(warmStill.report.seconds.toFixed(2)), compileSeconds: warmStill.report.gpuCompileSeconds };+ for (const variant of variantNames) {+ const { report: warmReport } = await page.evaluate(([scene, tracerOptions, counts]) => window.renderProgressiveCheckpoints(scene, tracerOptions, counts), [source, { ...baseOptions, ...VARIANT_OPTIONS[variant] }, [1]]);+ timings[`${name}:${variant}:warm`] = { setupSeconds: Number(warmReport.setupSeconds.toFixed(2)), compileSeconds: Number(warmReport.compileSeconds.toFixed(2)) };+ }+ }if (argumentsGiven.includes('--still')) {const still = await page.evaluate(([scene, options]) => (typeof scene === 'string' ? window.renderReferencePathTraced(scene, options) : window.renderRecipePathTraced(scene, options)), [source, { ...baseOptions, samples: 64, backend: 'gpu' }]);await writeFile(`${outputDirectory}/${name}@still-64.png`, Buffer.from(still.image, 'base64'));diff --git a/bench/reference/progressive-proof.mjs b/bench/reference/progressive-proof.mjsindex 546d742e..d9c03091 100644--- a/bench/reference/progressive-proof.mjs+++ b/bench/reference/progressive-proof.mjs@@ -46,7 +46,7 @@ const report = { timedScenes: {}, frameTime: {}, lightChoice: {} };// 1. Time to the still's score, and 2. frame time.for (let runIndex = 1; runIndex <= runCount; runIndex++) {const directory = `${outputDirectory}/run${runIndex}`;- run(process.execPath, ['bench/reference/progressive-compare.mjs', directory, TIMED_SCENES.join(','), '--still', '--variant', TIMED_VARIANTS.join(','), '--checkpoints', CHECKPOINTS]);+ run(process.execPath, ['bench/reference/progressive-compare.mjs', directory, TIMED_SCENES.join(','), '--still', '--warm', '--variant', TIMED_VARIANTS.join(','), '--checkpoints', CHECKPOINTS]);const scores = score(directory);const timings = JSON.parse(readFileSync(`${directory}/timings.json`, 'utf8'));for (const scene of TIMED_SCENES) {@@ -54,8 +54,10 @@ for (let runIndex = 1; runIndex <= runCount; runIndex++) {const still = timings[`${scene}:still-64`];for (const variant of TIMED_VARIANTS) {const reached = CHECKPOINTS.split(',').map(Number).find(samples => scores[`${scene}:${variant}-${samples}`] <= stillScore);- const entry = (report.timedScenes[`${scene}:${variant}`] ??= { stillScore, stillSeconds: [], reachedSamples: [], progressiveSeconds: [], progressiveScore: null });+ const entry = (report.timedScenes[`${scene}:${variant}`] ??= { stillScore, stillSeconds: [], stillTracedSeconds: [], warmUpCompileSeconds: [], reachedSamples: [], progressiveSeconds: [], progressiveScore: null });entry.stillSeconds.push(still.seconds);+ entry.stillTracedSeconds.push(still.tracedSeconds);+ entry.warmUpCompileSeconds.push(timings[`${scene}:${variant}:warm`].compileSeconds);if (reached === undefined) continue;const point = timings[`${scene}:${variant}:${reached}`];entry.reachedSamples.push(reached);@@ -71,16 +73,16 @@ for (let runIndex = 1; runIndex <= runCount; runIndex++) {(report.frameTime.maximumMilliseconds ??= []).push(frame.maximumMilliseconds);}-// 3. Default light choice against forced uniform. Scores do not vary between runs, so one pass.+// 3. Default light choice against forced uniform and forced tree. Scores do not vary between runs, so one pass.const lightDirectory = `${outputDirectory}/light-choice`;-if (lightSceneIds.length) run(process.execPath, ['bench/reference/progressive-compare.mjs', lightDirectory, lightSceneIds.join(','), '--variant', 'uniform,tree,importance', '--checkpoints', LIGHT_SCENE_SAMPLES]);-if (lightSceneIds.length) run(process.execPath, ['bench/reference/progressive-compare.mjs', lightDirectory, lightSceneIds.join(','), '--variant', 'random', '--checkpoints', LIGHT_SCENE_SAMPLES]);+if (lightSceneIds.length) run(process.execPath, ['bench/reference/progressive-compare.mjs', lightDirectory, lightSceneIds.join(','), '--variant', 'random,uniform,tree,importance', '--checkpoints', LIGHT_SCENE_SAMPLES]);const lightScores = lightSceneIds.length ? score(lightDirectory) : {};const files = lightSceneIds.length ? readdirSync(lightDirectory) : [];for (const scene of lightSceneIds) {for (const samples of LIGHT_SCENE_SAMPLES.split(',')) {const defaultPath = `${lightDirectory}/${scene}@random-${samples}.png`;const uniformPath = `${lightDirectory}/${scene}@uniform-${samples}.png`;+ const treePath = `${lightDirectory}/${scene}@tree-${samples}.png`;if (!files.includes(`${scene}@random-${samples}.png`)) continue;report.lightChoice[`${scene}:${samples}`] = {defaultScore: lightScores[`${scene}:random-${samples}`] ?? null,@@ -88,23 +90,25 @@ for (const scene of lightSceneIds) {treeScore: lightScores[`${scene}:tree-${samples}`] ?? null,importanceScore: lightScores[`${scene}:importance-${samples}`] ?? null,defaultEqualsUniform: existsSync(uniformPath) ? fileHash(defaultPath) === fileHash(uniformPath) : null,+ defaultEqualsTree: existsSync(treePath) ? fileHash(defaultPath) === fileHash(treePath) : null,+ treeEqualsUniform: existsSync(treePath) && existsSync(uniformPath) ? fileHash(treePath) === fileHash(uniformPath) : null,};}}writeFileSync(`${outputDirectory}/progressive-proof.json`, JSON.stringify(report, null, 1));-console.log(`\nItem 1: progressive (default options) against the 64 sample still, 960 by 540, ${runCount} runs (seconds: setup, compile, steps and read back)`);-console.log('| Scene | Light choice | Still FLIP | Progressive FLIP | Samples reached | Progressive s | Still s |');-console.log('| --- | --- | --- | --- | --- | --- | --- |');+console.log(`\nItem 1: progressive (default options) against the 64 sample still, 960 by 540, ${runCount} runs (seconds: setup, compile, steps and read back; a warm-up draw compiles every kernel first, so neither timed side pays a compile; the warm-up compile seconds are printed apart. The still time is its whole call, the traced time its GPU part)`);+console.log('| Scene | Light choice | Still FLIP | Progressive FLIP | Samples reached | Progressive s | Still s | Still traced s | Warm-up compile s |');+console.log('| --- | --- | --- | --- | --- | --- | --- | --- | --- |');for (const [key, entry] of Object.entries(report.timedScenes)) {const progressive = entry.progressiveSeconds.length ? range(entry.progressiveSeconds) : 'not reached';- console.log(`| ${key.split(':')[0]} | ${key.split(':')[1] === 'random' ? 'default (uniform)' : 'forced tree'} | ${entry.stillScore} | ${entry.progressiveScore ?? '-'} | ${[...new Set(entry.reachedSamples)].join(', ') || '-'} | ${progressive} | ${range(entry.stillSeconds)} |`);+ console.log(`| ${key.split(':')[0]} | ${key.split(':')[1] === 'random' ? 'default (uniform)' : 'forced tree'} | ${entry.stillScore} | ${entry.progressiveScore ?? '-'} | ${[...new Set(entry.reachedSamples)].join(', ') || '-'} | ${progressive} | ${range(entry.stillSeconds)} | ${range(entry.stillTracedSeconds)} | ${range(entry.warmUpCompileSeconds)} |`);}console.log(`\nItem 2: median frame time at 1 sample per pixel, demo room, ${frameCount} frames, ${runCount} runs: median ${range(report.frameTime.medianMilliseconds)} ms (fastest frame ${range(report.frameTime.minimumMilliseconds)}, slowest ${range(report.frameTime.maximumMilliseconds)})`);-console.log('\nItem 3: default light choice (auto) against forced uniform, FLIP against Cycles (- means no Cycles render given)');-console.log('| Scene | Samples | Default | Uniform | Tree | Importance | Default pixels equal uniform |');-console.log('| --- | --- | --- | --- | --- | --- | --- |');+console.log('\nItem 3: default light choice (auto) against forced uniform and forced tree, FLIP against Cycles (- means no Cycles render given)');+console.log('| Scene | Samples | Default | Uniform | Tree | Importance | Default pixels equal uniform | Default pixels equal tree | Tree pixels equal uniform |');+console.log('| --- | --- | --- | --- | --- | --- | --- | --- | --- |');for (const [key, entry] of Object.entries(report.lightChoice)) {const [scene, samples] = key.split(':');- console.log(`| ${scene} | ${samples} | ${entry.defaultScore ?? '-'} | ${entry.uniformScore ?? '-'} | ${entry.treeScore ?? '-'} | ${entry.importanceScore ?? '-'} | ${entry.defaultEqualsUniform} |`);+ console.log(`| ${scene} | ${samples} | ${entry.defaultScore ?? '-'} | ${entry.uniformScore ?? '-'} | ${entry.treeScore ?? '-'} | ${entry.importanceScore ?? '-'} | ${entry.defaultEqualsUniform} | ${entry.defaultEqualsTree} | ${entry.treeEqualsUniform} |`);}diff --git a/docs/path-tracer.md b/docs/path-tracer.mdindex f9a4ab81..5d8f5e72 100644--- a/docs/path-tracer.md+++ b/docs/path-tracer.md@@ -151,24 +151,38 @@ Measured on the RTX 3060, 960 by 540, FLIP against Cycles of the denoised image,The still of `spot-area` took 60.5 s including 29.9 s of kernel compile. Blue noise alone scored the same as random within 0.0003 at every count on both scenes (it helps the 1 sample image only by 0.001 to 0.002). Median frame time of one sample per pixel, 200 frames, 960 by 540: demo room 69 ms (67 to 71) random and 71 to 73 ms with both options; `lit-interior` 32 ms; `spot-area` 14 ms.-Light choice at equal samples (16 and 64) on the 16 path tracer scenes: 12 scenes have one local light or none and are identical. Better: `lit-interior` 0.0769 to 0.0572 at 64 (0.1318 to 0.0884 at 16), `spot-area` 0.0262 to 0.0224, `light-linking` 0.0291 to 0.0273 at 16. Not better: `brick-room` 0.2587 to 0.2686 at 64 and `light-linking` 0.0213 to 0.0217 at 64. In `brick-room` both choices score worse at 64 than at 16 (0.2491 and 0.2499 at 16), so the converged image is further from Cycles and the score cannot judge the noise; the criterion "no worse on every scene" is therefore not met by this measure, which is why the option stays off. `bench/reference/progressive-compare.mjs` and `progressive-score.py` made the numbers.--The light tree on the same 16 scenes (FLIP against Cycles, 16 and 64 samples, one run each, 960 by 540, denoised; `--variant random,importance,tree`): 12 scenes have one local light or none and are identical to uniform. Better or equal to uniform: `lit-interior` 0.1318 (uniform) to 0.0885 at 16 and 0.0769 to 0.0574 at 64 (importance 0.0884 and 0.0572), `spot-area` 0.0415 to 0.0340 and 0.0262 to 0.0221 (importance 0.0345 and 0.0224), `light-linking` 0.0291 to 0.0280 at 16. Worse: `brick-room` 0.2491 to 0.2506 at 16 and 0.2587 to 0.2692 at 64 (importance 0.2499 and 0.2686), and `light-linking` 0.0213 to 0.0220 at 64. So the tree is not the default: it loses on `brick-room` and by 0.0007 on `light-linking`, as the flat importance choice does. In `brick-room` the score rises with the sample count for both draws (uniform 0.2587 at 64 and 0.2751 at 256, tree 0.2692 and 0.2796), so the error against Cycles there is a difference the sampling does not fix, and the gap between the draws shrinks from 0.0105 to 0.0045 as the noise goes; that is why the tree's loss is read as the denoiser blurring noise that happened to land nearer Cycles (inferred, not isolated). `light-linking` ignores its light masks when it picks.--The scene that shows the gain is `many-lights` (`bench/reference/scenes.js`, issue #623): a 36 m corridor lit only by 24 ceiling lamps, 16 point and 8 spot. FLIP against Cycles at 960 by 540, 16 and 64 samples: uniform 0.1926 and 0.1471, importance 0.0594 and 0.0688, tree 0.0710 and 0.0617. One full size sample (median of 20 on the RTX 3060, shared machine) takes 72 ms with the uniform draw, 88 ms with importance (it sums every light at every hit) and 38 ms with the tree, because the first hit traces one shadow ray instead of 24; 64 steps took 15.7 s, 11.5 s and 12.4 s including the kernel compile and the read back of the checkpoints. Importance wins at 16 samples, the tree at 64, and the tree costs about half the time per sample.--Proof of the three checks of issue #623 on 2026-11-11 (`node bench/reference/progressive-proof.mjs <directory> --cycles <directory with the Cycles .npy files> [--runs 3]`, behind the GPU lock; it prints the tables below from `progressive-compare.mjs` and `progressive-score.py`). RTX 3060, 960 by 540, denoised, three runs, machine shared with other jobs, times are ranges. Progressive time is the setup, the steps and one read back; the still time is the whole `renderReferencePathTraced` call, kernel compile included.--| Scene | Light choice | Still FLIP | Progressive FLIP | Samples reached | Progressive s | Still s |-| --- | --- | --- | --- | --- | --- | --- |-| `lit-interior` | default (uniform) | 0.0769 | 0.0769 | 64 | 5.7 to 5.8 | 82.1 to 165.8 |-| `lit-interior` | forced tree | 0.0769 | 0.0724 | 24 | 80.0 to 134.0 | 82.1 to 165.8 |-| `spot-area` | default (uniform) | 0.0262 | 0.0262 | 64 | 4.0 to 4.4 | 3.9 to 4.3 |-| `spot-area` | forced tree | 0.0262 | 0.0239 | 48 | 3.8 to 4.2 | 3.9 to 4.3 |--- Reached sooner: `lit-interior` by a factor of 14 or more, and mostly because the still takes 82 to 166 s here. Not reached sooner: `spot-area` at the default options needs the same 64 samples as the still and takes the same time within the noise (the kernel was compiled before, so the still has no compile to hide). With the tree it needs 48, which is inside the noise too. The tree kernel compiles slowly (most of the 80 to 134 s on `lit-interior`).-- Frame time at 1 sample per pixel on the demo room (`tests/fixtures/demo-room.recipe.json`), median of 200 frames, three runs: 79.2 to 80.9 ms (fastest frame 75.8 to 77.0 ms, slowest 84.6 to 86.1 ms).-- Light choice at equal samples, FLIP against Cycles (one pass, 16 and 64 samples, all 17 path tracer scenes including `many-lights`). The default (`auto`) draws the same bytes as forced uniform on every scene but `many-lights`, which has 24 lamps (more than 8) and picks the tree: 0.0753 against 0.1926 at 16 and 0.0593 against 0.1471 at 64. With the tree forced, no scene with a Cycles render scores worse than uniform at either count: `brick-room` 0.1409 against 0.1699 and 0.0985 against 0.1166, `light-linking` 0.0220 against 0.0291 and 0.0212 against 0.0213, `lit-interior` 0.0854 against 0.1318 and 0.0569 against 0.0769, `spot-area` 0.0340 against 0.0415 and 0.0221 against 0.0262. The 12 other scenes have no Cycles render at hand; they have at most one local light, so uniform and tree draw the same pixels (the script prints whether the default image equals the uniform one). The earlier `brick-room` loss (0.2587 to 0.2692) no longer shows (the cause is not isolated; the Cycles file of this scene was taken at an earlier commit, so treat it as inferred that #813 fixed it).+The light choice was first measured when the importance draw and the tree were new, against an older Cycles render of `brick-room` and with an earlier version of the tree. Those figures (for example `brick-room` 0.2587 to 0.2692 at 64) and the verdict drawn from them, that the option stays off, are replaced by the table of the proof below: it scores uniform, importance and the tree of the current code against one set of Cycles renders in one pass, and is the only table to read. The two Cycles renders of `brick-room` are not the same image (uniform scores 0.2587 at 64 against the old one and 0.1166 against the current one, which is why the old and the new figures cannot be compared). Why the older render differed is not known, and the claim that a later change (#813) removed the loss is dropped, since nothing here tests it. `light-linking` ignores its light masks when it picks. `bench/reference/progressive-compare.mjs` and `progressive-score.py` made the numbers.+++The scene that shows the gain is `many-lights` (`bench/reference/scenes.js`, issue #623): a 36 m corridor lit only by 24 ceiling lamps, 16 point and 8 spot. FLIP against Cycles (the Blender 5.2 Cycles render of the same scene, `many-lights-cycles.npy`) at 960 by 540, 16 and 64 samples: uniform 0.1926 and 0.1471, importance 0.0594 and 0.0688, tree 0.0753 and 0.0593. The tree scores here were 0.0710 and 0.0617 in an earlier measurement; uniform and importance repeat to four digits, so the Cycles file and the noise did not change and the tree code did (inferred: the tree was tuned after that run). The default (`auto`) picks the tree on this scene, and its images are byte-identical to the forced tree's (the proof script prints that). One full size sample (median of 20 on the RTX 3060, shared machine, measured before the tree tuning) takes 72 ms with the uniform draw, 88 ms with importance (it sums every light at every hit) and 38 ms with the tree, because the first hit traces one shadow ray instead of 24; 64 steps took 15.7 s, 11.5 s and 12.4 s including the kernel compile and the read back of the checkpoints. Importance wins at 16 samples, the tree at 64, and the tree costs about half the time per sample.++Proof of the three checks of issue #623 on 2026-11-11 (`node bench/reference/progressive-proof.mjs <directory> --cycles <directory with the Cycles .npy files> [--runs 3]`, behind the GPU lock; it prints the tables below from `progressive-compare.mjs` and `progressive-score.py`). RTX 3060, 960 by 540, denoised, two runs, machine shared with other jobs, times are ranges. The Cycles renders are the five files of `brick-room`, `light-linking`, `lit-interior`, `many-lights` and `spot-area`, rendered by the Blender reference script between 2026-11-09 and 2026-11-11; the other 12 scenes have none. Every kernel is compiled by a warm-up draw before anything is timed, because the GPU kernels are cached in the page: the first draw of a page pays the compile, and the earlier timing of this proof did not account for that. Progressive time is the setup, the steps and one denoised read back (3.4 s of it); the still time is the whole `renderReferencePathTraced` call and the traced time its GPU part.++| Scene | Light choice | Still FLIP | Progressive FLIP | Samples reached | Progressive s | Still s | Still traced s |+| --- | --- | --- | --- | --- | --- | --- | --- |+| `lit-interior` | default (uniform) | 0.0769 | 0.0769 | 64 | 5.7 to 6.2 | 5.5 to 6.2 | 2.1 |+| `lit-interior` | forced tree | 0.0769 | 0.0724 | 24 | 4.3 to 4.4 | 5.5 to 6.2 | 2.1 |+| `spot-area` | default (uniform) | 0.0262 | 0.0262 | 64 | 4.3 to 4.5 | 4.1 to 4.4 | 0.9 |+| `spot-area` | forced tree | 0.0262 | 0.0239 | 48 | 4.0 to 4.7 | 4.1 to 4.4 | 0.9 |++- Item 1 is not met. With the kernels compiled on both sides, the default progressive draw reaches the still's score only at the still's 64 samples and takes the same time within the noise (`lit-interior` 5.7 to 6.2 s against 5.5 to 6.2 s, `spot-area` 4.3 to 4.5 s against 4.1 to 4.4 s). The earlier 5.7 s against 82 to 166 s for `lit-interior` compared unlike things: the still ran first in the page and paid the kernel compile (a one sample still, the warm-up, took 106.8 s in the first run, of which the kernel compile was 60.0 s and the rest of the first call, about 47 s, was not isolated; the compile was 44.2 s in the second run), and the progressive draw that followed reused the cached kernel. At the same 64 samples and the same score the still path is not faster or slower than the progressive path. With the tree forced the progressive draw reaches the still's score earlier in samples (24 on `lit-interior`, 48 on `spot-area`) and is faster on `lit-interior` (4.3 to 4.4 s against 5.5 to 6.2 s; the ranges do not overlap in two runs), inside the noise on `spot-area`. That gain needs the tree kernel, which compiled in 56.0 to 58.4 s in the warm-up of each run, once per page, and is not the default.+- Frame time at 1 sample per pixel on the demo room (`tests/fixtures/demo-room.recipe.json`), median of 200 frames, two runs: 79.3 to 80.3 ms (fastest frame 76.2 to 77.5 ms, slowest 84.0 to 84.4 ms).+- Item 3 is met on the five scenes that have a Cycles render and by identical pixels on the other 12. Light choice at equal samples, FLIP against Cycles (one pass, 16 and 64 samples, all 17 path tracer scenes including `many-lights`, uniform, tree and importance forced, and the default `auto`):++ | Scene | Samples | Default | Uniform | Tree | Importance | Default equals uniform | Default equals tree | Tree equals uniform |+ | --- | --- | --- | --- | --- | --- | --- | --- | --- |+ | `brick-room` | 16 | 0.1699 | 0.1699 | 0.1409 | 0.142 | yes | no | no |+ | `brick-room` | 64 | 0.1166 | 0.1166 | 0.0985 | 0.0991 | yes | no | no |+ | `light-linking` | 16 | 0.0291 | 0.0291 | 0.022 | 0.0273 | yes | no | no |+ | `light-linking` | 64 | 0.0213 | 0.0213 | 0.0212 | 0.0217 | yes | no | no |+ | `lit-interior` | 16 | 0.1318 | 0.1318 | 0.0854 | 0.0884 | yes | no | no |+ | `lit-interior` | 64 | 0.0769 | 0.0769 | 0.0569 | 0.0572 | yes | no | no |+ | `spot-area` | 16 | 0.0415 | 0.0415 | 0.034 | 0.0345 | yes | no | no |+ | `spot-area` | 64 | 0.0262 | 0.0262 | 0.0221 | 0.0224 | yes | no | no |+ | `many-lights` | 16 | 0.0753 | 0.1926 | 0.0753 | 0.0594 | no | yes | no |+ | `many-lights` | 64 | 0.0593 | 0.1471 | 0.0593 | 0.0688 | no | yes | no |++ The default draws the same bytes as forced uniform on every scene but `many-lights`, which has 24 lamps (more than 8) and picks the tree; there the default and the forced tree are byte-identical and the scores agree (0.0753 and 0.0593), which is the one figure for the default and the tree. With the tree forced, no scene with a Cycles render scores worse than uniform at either count (`light-linking` at 64 is 0.0212 against 0.0213, a tie). The 12 scenes without a Cycles render (`brick-flat`, `brick-graph`, `brushed-film`, `car-paint`, `character`, `fog`, `foliage`, `glass`, `long-street`, `material-spheres`, `metal`, `outdoor-hdri`) have no score; the script compared the image files of the forced tree and the forced uniform draw at 16 and 64 samples and they are byte-identical on all 12, as are the default and the forced uniform draw. "Better on the scene with the most lights" rests on `many-lights` against its Cycles render (0.0593 against 0.1471 at 64). The `brick-room` loss of the earlier measurement (0.2587 to 0.2692) does not show against the current Cycles render; the two renders differ, so the old figures are not comparable and are not read as fixed.## Real-time hybrid view (issue #624)