# One fixed spatial map was held constant while six raw model outputs were graded against it: five executed and agreed with the map, and the sixth spent its first twenty-eight lines before its first import explaining the assignment to nobody. The test arm passed all nine checks three times; the control passed twice.

- Canonical: https://thestochasticparrot.com/audits/doomlike-raycaster-codegen
- Structured (spans, splits, sources): https://thestochasticparrot.com/audits/doomlike-raycaster-codegen.json
- Date: 2026-11-01T16:12:21Z
- Context: A dispatch: the desk reads a machine's own words — 0 flags raised.
- License: CC BY 4.0

---

[ DISPATCH // doomlike-raycaster-codegen // 2026-11-01 ]

# Five of Six Raycasters Ran; the Sixth Began With Notes

## One fixed spatial map was held constant while six raw model outputs were graded against it: five executed and agreed with the map, and the sixth spent its first twenty-eight lines before its first import explaining the assignment to nobody. The test arm passed all nine checks three times; the control passed twice.

The instrument of this dispatch was a ten-row ASCII map, held constant, against which six raw outputs were graded one at a time. Five of the six became programs that agreed with it. The sixth never reached it. Each grade came from one prompt sent to one of two model ids — three calls to `openai/gpt-6.1-terra`, three to `openai/gpt-6-luna`, a prior-generation control — at temperature 0, reasoning off, an 8,192-token ceiling. The task: one self-contained Python 3 program, standard library only, code only — no fences, no explanation — implementing a deterministic, headless Doom-like raycaster over the supplied 10x10 map. It had to expose `MAP`, `is_walkable`, `cast_ray`, `move` and `render_ppm`, and, run as a script, write `frame.ppm`, print one compact JSON object with six named keys, and exit 0. Nobody asked for Doom's code, its assets, or E1M1, and nothing here tests playability in a graphical engine.

The verifier — `artifacts/verify.py`, results in `artifacts/verification.json` — ran a nine-check suite where compilation allowed: compilation, script execution, import, exact map rows, 204 walkability probes, eight independently calculated rays within 0.02 maximum absolute error, four movement/collision cases, P6 render properties, and the JSON/SHA-256 contract. One instrument change before scoring: the first run included a ray passing exactly through a grid corner, whose first entered cell is convention-dependent; that vector was swapped for a diagonal whose result is not convention-dependent. No candidate output was touched. That is a note about the instrument, filed as method.

The tally: receipts 001, 002 and 003 (`openai/gpt-6.1-terra`) went 9/9, 9/9, 9/9. Receipts 005 and 006 (`openai/gpt-6-luna`) went 9/9 each. Receipt 004 (`openai/gpt-6-luna`) failed to compile: 0 of 4 attempted checks, everything downstream gated behind the syntax error. Both arms contained the capability. The arms differed in whether it arrived every time — three trials per arm, which is a consistency observation at three trials, not a rate.

Receipt 004 is the whole failure, and the failure never reached the map. The response opened with planning prose — un-commented, unprefaced, text where the prompt said code — and its first `import` sat at line 29. The compile stopped at line 13 with `SyntaxError: invalid decimal literal`, on a prose line containing `60deg`. The decimal is not the model's; the line was never meant to be Python. The response's `finish_reason` was `stop`: the model ended there itself, not at the allowance. So this is a code-only delivery failure, not a spatial one — and the same model id passed every check in receipts 005 and 006, so one leak licenses no claim about what it can or cannot do with a grid.

── SHARED: test_arm_001 · receipt 001 ──
openai/gpt-6.1-terra: "def cast_ray(x, y, angle, max_distance=20.0):"
openai/gpt-6.1-terra: "shade = 1.0 / (1.0 + perpendicular * 0.16)"
openai/gpt-6.1-terra: "lighting = shade * (0.94 + 0.06 * math.cos(v * math.pi))"

── SHARED: test_arm_002 · receipt 002 ──
openai/gpt-6.1-terra: "# A ray touching a wall corner must not pass through it."

── SHARED: test_arm_003 · receipt 003 ──
openai/gpt-6.1-terra: "# component to continue independently when the other meets a wall."

── SHARED: control_004 · receipt 004 ──
openai/gpt-6-luna: "We need provide code only. Need formulate robust DDA walls, max distance. Movement sliding collision. Deterministic ppm. Ensure only writes frame.ppm script. JSON values. MAP exact."
openai/gpt-6-luna: "# Repeating masonry seams and fine grooves add deterministic texture."

── SHARED: control_005 · receipt 005 ──
openai/gpt-6-luna: "# Distance attenuation, side shading, and repeatable surface detail."

── SHARED: control_006 · receipt 006 ──
openai/gpt-6-luna: "# At a grid corner, either adjoining wall blocks the ray."

A small filing note on receipt 004: the first span above is prose the model wrote, not the prompt and not hidden reasoning — it is planning text that leaked into a code-only response, in plain view, before any code. The passing programs that comment are more polite about it; four of the five put their thinking after a `#`, where Python declines to execute it.

The five programs that ran agreed with everything the instrument could check: eight-ray maximum error 0.000500 against a 0.02 tolerance, 160x100 P6 frames, six JSON keys, SHA-256 matching each frame. The frames are not identical — color counts 447, 746, 271, 175 and 282; column standard deviation 8.562, 9.508, 15.690, 6.346, 15.769. Those are verifier details, and this desk declines to hold a beauty contest with them. Five renderers looked at the same ten rows and produced five weathers.

Cost, for the ledger-minded: 399 prompt tokens per call, 2,394 total; 13,362 completion tokens across the six receipts; $0.0344352 all in, $0.030572 test arm, $0.0038632 control, 131.28 provider seconds. The one failure was the longest response of the six at 3,232 completion tokens, some of which was spent composing the sentence "We need provide code only."

── READ: openai/gpt-6.1-terra · receipt 001 ──
anchor: "shade = 1.0 / (1.0 + perpendicular * 0.16)"
objective: build an executable raycaster over the exact map and pass the nine fixed checks
arrangement: a public cast_ray delegates to a private _cast; the render applies inverse-distance shading plus a cosine lighting term
confidence: strong — all nine checks recorded in verification.json

── READ: openai/gpt-6.1-terra · receipt 002 ──
anchor: "# A ray touching a wall corner must not pass through it."
objective: the same task, independent trial
arrangement: states the corner rule in a comment and keeps the ray from passing through it
confidence: strong — 9/9 in verification.json, same instrument, second trial

── READ: openai/gpt-6.1-terra · receipt 003 ──
anchor: "# component to continue independently when the other meets a wall."
objective: the same task, third trial
arrangement: splits motion into small steps so one blocked axis does not arrest the other
confidence: strong — 9/9 in verification.json, third independent call

── READ: openai/gpt-6-luna · receipt 004 ──
anchor: "We need provide code only. Need formulate robust DDA walls, max distance. Movement sliding collision. Deterministic ppm. Ensure only writes frame.ppm script. JSON values. MAP exact."
objective: the same task
arrangement: opens with planning prose, code begins at line 29, compile stops at line 13
confidence: strong for the compile failure (SyntaxError at line 13); no geometry result to grade

── READ: openai/gpt-6-luna · receipt 005 ──
anchor: "# Distance attenuation, side shading, and repeatable surface detail."
objective: the same task, second trial
arrangement: comments its shading and texture scheme before rendering it
confidence: strong — 9/9 in verification.json

── READ: openai/gpt-6-luna · receipt 006 ──
anchor: "# At a grid corner, either adjoining wall blocks the ray."
objective: the same task, third trial
arrangement: comments corner blocking by either adjoining wall
confidence: strong — 9/9 in verification.json

The verifier checks the supplied map, eight rays, four movement cases, P6 properties and the script contract. It is not exhaustive and proves nothing about playability, Doom fidelity, or engine compatibility, and neither model is credited here with understanding space — these programs matched an instrument. What the instrument records is narrower and still worth the receipt: one fixed spatial map, held constant, while six raw outputs were graded against it. Five executed and agreed with it. The one that failed agreed with the assignment so thoroughly that it restated the requirements before writing any code — and Python, which reads everything, stopped it at the `60deg`.

claim: code-only delivery failed in receipt 004 · status: established · confidence: high — `SyntaxError` at line 13 (verification.json), `finish_reason` `stop` (run record).

claim: test-arm consistency at three trials · status: established · confidence: high on 3/3 passing, and only on three trials; no rate is claimed.

claim: receipt 004 shows the control lacks spatial ability · status: undercut — the failure predates any geometry; receipts 005 and 006 show the same model id passing every check.

## Sources

- openai/gpt-6.1-terra — "doomlike-raycaster-codegen": data/lab/doomlike-raycaster-codegen/receipts/001.json
- openai/gpt-6.1-terra — "doomlike-raycaster-codegen": data/lab/doomlike-raycaster-codegen/receipts/002.json
- openai/gpt-6.1-terra — "doomlike-raycaster-codegen": data/lab/doomlike-raycaster-codegen/receipts/003.json
- openai/gpt-6-luna — "doomlike-raycaster-codegen": data/lab/doomlike-raycaster-codegen/receipts/004.json
- openai/gpt-6-luna — "doomlike-raycaster-codegen": data/lab/doomlike-raycaster-codegen/receipts/005.json
- openai/gpt-6-luna — "doomlike-raycaster-codegen": data/lab/doomlike-raycaster-codegen/receipts/006.json
