Render it here.
This is the 0.4.0 renderer running in your browser. Pick a camera and it draws the frame, lights it both ways and writes the certificate, the same as the command line. If your browser has WebGPU, the frame is drawn on your GPU, and the same camera is drawn again on the CPU to check it: a second certificate says whether the two agree. Without WebGPU, the CPU build draws the frame on one thread, and the status lines say why. Your browser checks each module against its published SHA-256 before running it.
- Needs JavaScript and WebAssembly.
The certificate from this render. Save it to keep the full record, including the SHA-256 of every file the render wrote.
Run it now.
See how it works, step by step: both occlusion estimators, the reconcile against the tolerance and the verifier, animated with values from the repository.
Download the binary for your system from the 0.4.0 release, check it against the published hashes, and point it at an empty folder. A 256 by 256 frame takes about a quarter of a second.
# check the download, then render the default view sha256sum -c SHA256SUMS raw_native_cli --out ./out raw_native_cli verify ./out # recompute the error from the written files # move the camera; a previous camera adds motion vectors raw_native_cli --out ./out --width 512 --height 512 --eye 0,9,3 --target 0,0.5,0 raw_native_cli --out ./out --prev-eye 4.3,4,5.7 # or build it: CMake 3.24+ and any C++23 compiler cmake -S . -B build -DCMAKE_BUILD_TYPE=Release cmake --build build --config Release ctest --test-dir build -C Release --output-on-failure
Two views of one scene, and what each certificate says.
Every image here came out of the 0.2.0 command line at 512 by 512. The scene is a box on a ground plane under one light. The first panel is the shaded frame. The next two are the reference and the shortcut, where white means open sky and dark means occluded. The last is the error between them.
{"claim":"screen-space AO matches ray-traced ground truth within tolerance",
"verdict":"refuted", "oracle":"raw-rt-ao-v1",
"evidence":[["pixels","151984"],["rmse","0.1349"],["maxError","0.6406"],["tolerance","0.1200"]],
"channels":{"ao_fidelity":0.881125,"motion_coherence":1,"hdr_headroom":0.875542}}
The shortcut misses the soft halo almost entirely. Its error is 0.135 RMSE against a tolerance of 0.12, so the certificate says refuted. That is the check working: a picture that looks fine at a glance came back with a measured reason not to trust its shading.
{"claim":"screen-space AO matches ray-traced ground truth within tolerance",
"verdict":"verified", "oracle":"raw-rt-ao-v1",
"evidence":[["pixels","239854"],["rmse","0.0827"],["maxError","0.6250"],["tolerance","0.1200"]],
"channels":{"ao_fidelity":0.923585,"motion_coherence":1,"hdr_headroom":0.875542}}
From above, most covered pixels are open ground where both methods agree, so the average error drops to 0.083 and the same check passes. The worst pixel is still off by 0.63. The certificate carries both numbers, so you can see that a pass on the average does not mean every pixel is right. Raw certificates: default, high.
The certificate
A certificate is a JSON file with a claim, a verdict, the oracle that judged it and the numbers behind the verdict. The verdict is verified, refuted or unverifiable. A channel with no data is written as null.
You can check one in two ways. From 0.3.0 the run writes its ambient occlusion as 32-bit floats beside a coverage mask, and raw_native_cli verify recomputes the error from those files alone. Or run the same command yourself, because the output is deterministic: the default frame and its certificate hash the same with MSVC 19.50 on Windows, with GCC 13.3 on Ubuntu and from the WebAssembly build, locally and on GitHub’s build runners. The renderer also measures exactly how many bytes the frame needs, renders again inside that budget, and refuses any allocation past it. A second certificate records whether the budget held.
The same scene gives different verdicts from different cameras:
| View | Camera flags | Covered pixels | RMSE | Verdict |
|---|---|---|---|---|
| Default | none | 151,984 | 0.1349 | refuted |
| High | --eye 0,9,3 --target 0,0.5,0 | 239,854 | 0.0827 | verified |
| Low | --eye 6,1.5,2 --target 0,1,0 | 140,838 | 0.1659 | refuted |
| Close | --eye 2,2.5,3 --target 0,0.8,0 --fovy 0.7 | 214,043 | 0.2167 | refuted |
| Wide | --eye 5,5,8 --target 0,0.5,0 --fovy 1.2 | 88,869 | 0.0882 | verified |
512 by 512, tolerance 0.12 RMSE. Each row is one run of the 0.2.0 binary with the flags shown.
Scope and speed
- There is one built-in test scene and no model loader yet.
- The ray-traced reference uses 64 samples per pixel, so it shows visible grain.
- The screen-space method is a simple one, which is why most views come back refuted.
- The default tolerance is 0.12 RMSE.
--tolerancechanges it, and the certificate records the value used. - A full render with the ray-traced reference takes about 0.26 seconds at 256 by 256 and 1 second at 512 by 512 on one thread of an Intel Core i7-13700KF, natively or in WebAssembly. Times on this page depend on your machine.
- On an NVIDIA RTX 4090 in Chrome, the GPU draws a 512 by 512 frame with every channel in about 14 milliseconds, and all 16 GPU certificates in the release evidence say verified. The CPU reference that checks each GPU frame still takes its full time, so a GPU render on this page is not faster end to end.
- Without WebGPU this page runs the single-threaded CPU build. The threaded WebAssembly build ran about eight times faster on the same machine, but browsers allow it only on pages sent with cross-origin isolation headers, and GitHub Pages cannot send them.
- Matching hashes were checked on x86-64 with two compilers and the WebAssembly build. Other processors and compilers are untested.
Where it came from.
RAW began as a Direct3D 11 effects platform for Skyrim SE: a proxy library that took over a closed game’s frame and added its own lighting passes mid-picture. That taught me how a frame is built and how quickly an effect can look right while being wrong. The new RAW keeps the lesson and drops the game. It owns its whole frame, and every frame carries a check against a reference. The Skyrim code stays public. Work on it is paused, and I plan to return to it.
Read the source.
C++23, built from the standard library and its own headers. The rasterizer, both ambient occlusion methods, the reconcile step, the certificate writer, the verifier and the bounded memory arena each have their own tests, 32 in all. From 0.3.0 the license is FSL-1.1-MIT, and each version becomes MIT two years after its release. Version 0.2.0 stays MIT, as released.