009 — First Milestone: ARAL Against Blender, and the Steam Deck Becomes the Reference
The first-level milestone: the reference scene rendered by ARAL next to Blender, a full Steam Deck measurement with shadows, filtered PCF, MSAA ×4 by default, and why the Deck is now the target platform
2026-11-14 → 2026-11-15
Devlog 003 set the goal: the reference scene made in Blender, seen from the same camera, rendered by ARAL at least as well as Blender. Level 1 was "match": materials, sun, shadows. With the shadows of the previous post, everything level 1 needed was there. This step checks it, on two sides: the image against Blender, and the cost on the Steam Deck.
The game's camera, the game's sky, the same sun. ARAL on the left, Blender on the right — and that's how every comparison in this post is laid out. Click an image to see it full size.
A change of reference: the Steam Deck
Until now, two machines framed every decision: the Steam Deck as the minimum console, and the Switch 2 as the
platform some defaults were tuned for (the maxObjectPerCmdBuffer of devlog 007, for example).
Nintendo currently doesn't give new developers access to its SDK and development environment. Without it, there is no Switch 2 to measure on, and no way to know when there will be. So the Steam Deck becomes the reference: the budgets, the defaults and the "is it fast enough?" are now judged on the Deck, measured, not estimated. The Switch 2 numbers written in earlier posts were estimates and stay estimates; nothing in the engine is closed to it, it just stops being the target.
Against Blender
Same scene, same sun, same camera
Comparing two renderers by eye only works if everything else is identical. ProjectO got a few launch options for it (the Profile build has no console):
--blender-ref: the sun direction, the World color and the camera are read from the.blendof the reference scene; the fill light is off, the sky is a uniform color in the four keyframes, the sun disk is hidden;--cam <eye target fovV>for a fixed camera,--shot <path>for one screenshot at 10 s;--no-mannequin, for a comparison under the game's lighting without the character that Blender doesn't have.
The camera of the game itself was also added to the .blend, so both views exist on both sides.
What matches, what doesn't
A word before the pictures: these comparisons are indicative. Blender is the work of experienced teams over many years; a solo developer is not going to beat it, and that's not the point. The point is that at a quick glance, the difference shouldn't jump out — that ARAL holds up next to it in a game. Zoom in, and Blender's shadows are clearly better: smoother edges, a softer penumbra, more contact in the corners.
First, Blender's own camera, with the plain grey World of the .blend — the original capture of devlog 003, now
lit on both sides:
Then the camera of the game, imported into Blender:
These ARAL captures use the highest settings, to compare what the renderer can do rather than its defaults: an 8192² atlas, MSAA ×8, 16-tap PCF, shadows up to 300 m.
Then the same two cameras with the game's sky (time of day 0.40) instead of the grey World — the sky ambient of devlog 005 against Blender's:
- Framing, shape and direction of the shadows: identical. The columns, the slabs, the rocks — every cast shadow lands in the same place, with the same shape.
- Lit surfaces: equal (175 and 178 on a 0–255 scale).
- Dark tones are lighter in ARAL (59 in Blender, 71 in ARAL on the background). That's not the lighting: ARAL's AgX is the three.js approximation (devlog 003), and its toe is not exactly Blender's. A LUT taken from Blender would close it.
- Shadow edges, in the first captures: stairs in ARAL, smooth in Blender. Not a fair fight: Blender's Eevee accumulates 64 samples and uses virtual shadow maps. But it pointed at a real weakness — and that one got fixed (below).
Is Blender a target at all?
The original plan said "beat the Blender capture". After putting the two side by side, that goal is replaced by a more honest one: for this kind of scene — one sun, plain materials, no reflections — ARAL at a glance is close enough to Eevee in real time (physical sky, fast GI, horizon scan, screen-space ray tracing, 1.6 ms per sample in 1080p on the RX 6800) that the difference isn't obvious. Up close, Eevee still wins on quality.
Its two most visible advantages are already on the plan: occlusion in the corners (AO) and a penumbra that widens with the distance to the occluder (PCSS), both level 2. So Eevee stops being the target to beat. What it gave was a ruler.
The same scene in the old engine, again
Devlog 008 compared the cost of ARAL and greydog on greydog's demo scene. The milestone asked something else: does ARAL lose any shadow where greydog lost them? Same scene, same camera, frame 300 on both sides:
Every shadow greydog has is there: the cube, the four spheres, the street lamps down to the far end, and the pole in the foreground whose top is out of the picture. Same with ARAL's own defaults (3 × 2048², 100 m):

And the hard case, from a camera greydog can't be given: a street lamp entirely outside the image, whose shadow crosses the whole frame. That's the caster between the sun and the cascade that devlog 007's "pull the near plane back" was about — it stays:

The ground is lighter and the shadows bluer in ARAL: that's the sky ambient (which got brighter when the spherical harmonics moved to radiance), not the shadows.
The biases stay
The default biases from devlog 008 (depth 1.25, slope 1.75, normal offset 1.5 texels) were checked on the reference scene with the sun grazing (time 0.27) and higher (0.40), PBR and 9-tap PCF: no acne, no peter-panning. They stay.
The toon mode isn't re-checked yet.
One API cleanup came out of preparing the milestone: since the per-view shadows of devlog 008, the cascade count
passed to setAstroShadow was silently ignored — only the views' cascades were read. It's settled:
setAstroShadow(bool castShadow) alone, SAralCreateInfo::mainViewCascades for the main view at creation, and
setViewCascades(view, n) afterwards.
Filtered PCF: no more stairs
The PCF of devlog 008 was a grid: n × n hardware comparisons, averaged. Each read is already bilinear, but when a point moves across a texel the weights don't follow it, and the edge goes in steps.
It's now the filtered PCF described by Ignacio Castaño (The Witness): a tent kernel, read with the same number of hardware bilinear comparisons, but weighted by the position of the point inside its texel. As the point moves, the weights move with it, and the stairs disappear.
shadowPcfTaps | kernel | hardware reads |
|---|---|---|
| 1 | bilinear 2×2 | 1 |
| 4 | filtered 3×3 | 4 |
| 9 | filtered 5×5 | 9 |
| 16 | filtered 7×7 | 16 |
The CPU side follows: the tile rectangle is shrunk and the cascade sphere grown by the half-width of the kernel (1.5 / 2.5 / 3.5 texels), so a kernel never reads the neighbour tile.
On the Blender view the stairs are gone from 9 taps. The cost, measured on the Deck (below): gpu.aral.scene goes
from 1024 to 1158 µs between 4 and 9 taps, +0.14 ms. Softness bought with ALU instead of resolution — an 8192²
atlas would cost 128 MiB. The default is now 9.
MSAA ×4 by default
Also decided during the comparison: ARAL now starts with MSAA ×4 (SAralCreateInfo::msaaSamples = 4). ×4 is
guaranteed by Vulkan for color attachments, so it's safe everywhere; an unsupported count still falls back to 1 with
a warning. The Deck measurement below includes it, and shows what it costs.
Closing step 12: triangular dithering
Devlog 003 left a note: rectangular dithering for now, triangular "when the sky gradients are there to judge it". Devlog 005 brought the sky; this step finally judged it — measured, not by eye.
With the camera aimed at the horizon of the reference scene, the noise left in the sky gradient was measured locally
and sorted by where the true value falls between two 8-bit levels (its fractional part f). The rectangular
dither (±0.5 level) has a noise of standard deviation √(f(1 − f)): 0.22 of a level close to an 8-bit value,
0.50 halfway between two. Along a slow gradient, that alternates: a smooth band, a grainy band, a smooth band —
banding again, just a subtler kind.
Triangular dithering (±1 level) has the same standard deviation everywhere. It usually takes two random draws; here it's one, the same interleaved gradient noise, remapped through the inverse of the triangular distribution (Jorge Jiménez's IGN, the remap from Mikkel Gjøl):
float triangularNoise(float u) // u uniform in [0, 1) → triangular in [-1, 1)
{
float v = u * 2.0 - 1.0;
return sign(v) * (1.0 - sqrt(1.0 - abs(v)));
}
Measured again: standard deviation 0.50 in every bin, image mean unchanged (to 0.001 of a level).
ditherStrength keeps its meaning: 1 = ±1 level, triangular.
Cost on the Deck, checked after the milestone: the tonemap goes from 250 to 261 µs, +11 µs — one run, estimated at ~5 µs before measuring. With that, step 12 is closed.
The Steam Deck measurement
How
The Profile build has no console, so the measurement is scripted: tools/deck/jalon16_run.sh launches ProjectO three
times on the Deck — shadows off, sun with 1 cascade, sun with 3 cascades — at a frozen time of day, and refuses to run
unless the GPU clock is forced high (a GPU time is only a cost if the clock isn't dropping because there's room to
spare, see devlog 004). tools/jalon16_stats.py takes the medians and the difference against "shadows off".
The same three runs on the RX 6800, at the same 1280×800, give the Deck / desktop ratios.
Reference scene, 1280×800, MSAA ×4, PCF 4 taps, Release Profile. Medians in µs:
| zone | shadows off | 1 cascade | 3 cascades | cost of 3 cascades |
|---|---|---|---|---|
gpu.aral.shadow | 0 | 390 | 488 | +488 |
gpu.aral.scene | 840 | 1037 | 1024 | +184 (the PCF reads) |
gpu.aral.sky | 122 | 121 | 121 | — |
gpu.aral.resolve | 158 | 159 | 159 | — |
gpu.aral.tonemap | 250 | 250 | 250 | — |
| GPU total | 1.37 ms | 1.96 ms | 2.04 ms | +0.67 ms |
aral.flush.shadow (CPU) | 1 | 57 | 75 | +74 |
| CPU frame work | 0.30 ms | 0.32 ms | 0.34 ms | +0.04 ms |
A catch, found afterwards: a 4K monitor at 30 Hz was plugged into the Deck during these runs, next to its own screen,
and the frame pacing followed both (90 fps instead of 60). So everything was measured again with the internal
screen alone, at 60 Hz, without touching the controls, with the new defaults (PCF 9, triangular dithering), against
the same settings with the monitor: GPU total 2.17 against 2.19 ms, gpu.aral.shadow 474 against
488 µs, gpu.aral.scene 1157 against 1159 µs, CPU 0.33 against 0.34 ms. Differences of 3 % at most — the numbers
hold. At 60 fps, every 2-second report stayed under 17.9 ms per frame, no missed vsync.
What it says
- Shadows on the Deck: 0.67 ms of GPU for the sun with 3 cascades — 0.80 ms with the new 9-tap default. The target of devlog 007 was "≤ 3 ms, CSM 3 cascades ~1–2 ms". It's well under. The budget table gets its first "real Deck" number.
- The whole frame: 2.04 ms of GPU, 0.34 ms of CPU, with sky, shadows, MSAA ×4, tonemap and LUTs. At 60 fps that's an eighth of the frame.
- MSAA ×4 costs ~0.34 ms on the Deck (shadows off: 1.03 ms without MSAA, 1.37 ms with it), of which 158 µs is the resolve. Kept.
- CPU is not the issue. The whole recording of the frame is 0.34 ms; the CPU spends 10.7 ms waiting for the
next screen image (
vk.acquire). - On the RX 6800 a test run had shown 1 cascade more expensive than 3. Not on the Deck: 390 against 488 µs, as expected.
The scale factors, measured again
The debug overlay shows Deck estimates on the desktop using two factors. They were measured in devlog 004 on a much lighter scene (unlit, no shadows, no MSAA). Same scene on both machines now:
- GPU: ×7.1 to ×9.3 per zone, ×7.6 to ×9.3 for the total →
gpuScalegoes from 12 to 9; - CPU: ×3.2 →
cpuScalestays 3.
The old ×12 was too pessimistic once the frame does real work.
Next step
Step 17: a fixed render resolution per window, decoupled from the window size, with an intermediate LDR image — tonemap at the game's resolution, then one upscale to the screen, and the overlay and UI drawn sharp at the screen's resolution. It's also the image FXAA and FSR1 will work on later.











