Unreal-family demo installers
Status: verified locally on 2026-09-13. These are proprietary demos and remain
localOnly candidate-corpus fixtures. No host Wine was used.
Sources
| Candidate | Archive.org item | File | Size | SHA-1 |
|---|---|---|---|---|
| Unreal Special Edition | unreal-special-edition.-7z |
UnrealSpecialEdition.7z (was Unreal Special Edition.7z until ~2026-10; same bytes) |
128,609,961 | f3f25896a51cbf37dcdb94833198b86f394d8853 |
| Unreal Tournament | unreal-tournament-demo-version-348 |
UTDEMO348.EXE |
55,647,232 | faf2c18852a1a53c59db490e044e0d3e100e8fed |
| Unreal Tournament 2003 | UT2K3Demo |
UT2003Demo2206.exe |
148,976,640 | 372a8b712cb7f2b1539af72430923d290a67e701 |
| Unreal Tournament 2004 | UnrealTournament2004Demo |
Ut2004-NewDemo.exe |
296,049,152 | 5e224a3de711da9085cddd9929499789690043c7 |
| Unreal Tournament 3 | setuput3demo |
setuput3demo.exe |
777,027,962 | 86d4bad740d0c25438a65c48939ee6dcfc88bb02 |
The host archive reader only unwraps the outer 7-Zip/WinZip container. Candidate
preparation then executes the original setup program inside Wine Assembly,
exports the VFS it wrote, and boots the installed game. This distinction is
enforced by tools/install-unreal-demo.js.
Installer and launch results
| Candidate | Authentic setup result | Installed payload | Installed-game result |
|---|---|---|---|
| Unreal Special Edition | InstallShield bootstrap launched _INS*.MP; license and destination flow completed |
191 MB, System/Unreal.exe SHA-256 5fbc5853a8669a802446ac12e102351053bc6a5ce9f554b03483eb634269f408 |
Software launch loads SoftDrv, opens WindowsViewport0, initializes the game engine/player, and renders the playable intro |
| Unreal Tournament 348 | Unreal System/Setup.exe completed |
104 MB, System/UnrealTournament.exe |
--app=ut348_demo: first-run wizard, UWindow menu, DM-Morpheus practice match on SoftDrv with walk + mouse-look (see "UT 348 route" below) |
| UT2003 2206 | Unreal System/Setup.exe completed with the shipped MSVCR70.dll |
344 MB, System/UT2003.exe SHA-256 97e027dc9765f048beacfa461bc93c71ba1831cd3e8dff0cd7d71c1b478f88a2 |
The D3D8 wrapper renders textured first-person Antalus gameplay; an authentic dedicated server and direct-connect client exchange the native protocol over vln/1 |
| UT2004 new demo | Unreal System/Setup.exe completed with the shipped MSVCR71.dll |
525 MB, System/UT2004.exe SHA-256 2a95e2fa8c22ae94eb1c361fdb49ea8ec44c5e2a93faa00831308c01e951db8d |
Uses the same pre-renderer D3D8 probe; further post-probe launch diagnosis remains |
Seeding the bundled Visual C++ runtimes matters. Without MSVCR70.dll, the
UT2003 setup appears to require unimplemented CRT imports beginning with
wcschr; with its own runtime loaded, setup completes without any new emulator
API. The same rule applies to UT2004 and MSVCR71.dll.
OpenGL and software-renderer attempts
UT2003 and UT2004 both ship OpenGLDrv.dll. (Historical: the installer no
longer selects OpenGLDrv. See "--app from a fresh candidate fetch" below.)
Their installed and default INIs
were changed locally to OpenGLDrv.OpenGLRenderDevice, fullscreen was disabled,
and the browser launch used -opengl -window with a real WebGL context through
SwiftShader. This still does not bypass D3D8: both main executables import and
call Direct3DCreate8 during startup hardware detection, before either render
driver is loaded.
Direct3DCreate8 now returns a deliberately narrow, non-rendering
IDirect3D8 capability object. It preserves the complete 16-slot factory ABI,
implements COM lifetime, one adapter, one display mode, identifier and caps
queries, and deliberately returns D3DERR_NOTAVAILABLE from format/device
creation checks. An authentic UT2003 run successfully called
GetDeviceCaps, CheckDeviceFormat, GetAdapterIdentifier, and Release, so
the old missing/null-factory branch is gone. It still throws later, before
OpenGLDrv loads; this does not establish that an IDirect3DDevice8 is needed.
Unreal Special Edition does not ship OpenGLDrv.dll; it has SoftDrv.dll,
GlideDrv.dll, and SglDrv.dll. Its former startup exception was an encoded
resource-submenu mismatch in DeleteMenu. With resource-menu deletion and
compaction implemented, a five-minute authentic software-renderer run loaded
SoftDrv.dll, opened WindowsViewport0, logged Game engine initialized, and
sustained the render loop. Its gray viewport was a separate USER delivery bug:
the viewport is a secondary top-level window, but ShowWindow only queued an
initial WM_SIZE for children. Extending first-show sizing to non-main
top-level windows made WinDrv allocate its 514x386x32 DIB and produced 159
successful BitBlt frames in a 65-second authentic run. The captured intro is
rendered and prompts PRESS ESC TO BEGIN. A subsequent controlled run traversed
Game -> New Game -> Easy -> player setup, entered the first-person level with
HUD active, and produced distinct before/after movement frames, so interactive
gameplay is verified rather than inferred from the intro.
The initial capability facade has since grown into a deliberately bounded D3D8
translation layer over the D3D9 backend. It preserves the exact 97-slot device
and 19-slot texture ABIs, translates D3D8 presentation parameters, textures,
vertex/index buffers and fixed-function declarations, retains D3D8's
BaseVertexIndex from SetIndices for indexed draws, and adapts the implicit
swap-chain argument of GetBackBuffer. Unsupported methods remain explicit
failures rather than silent successes.
An authentic -d3d -window -nosound run now reaches textured first-person
gameplay on DM-Antalus. The no-sound flag isolates graphics from the separate
missing Vorbis ov_open import. test/test-ut2003-vlan-candidate.js runs the
game's own non-rendering dedicated-server mode beside a direct-connect client.
It verifies native UDP in both directions over vln/1, waits for D3D device
creation before taking a PNG, rejects the loading screen and spectator join
prompt, and rejects the flat-pale weapon signature that exposed the rendering
bug.
Getting the textured materials working had two layers. D3D8 sampler controls
are texture-stage states 13--21 and 25, but D3D9 moved them into sampler-state
slots 1--10. Forwarding
the D3D8 numbers directly to the D3D9 texture-stage bank returned
D3DERR_INVALIDCALL, leaving filter and address state at defaults. Translating
those states activates the mip-atlas shaders; the native headless desktop GLSL
1.10 compiler then rejected their ESSL-only
GL_OES_standard_derivatives : require directive even though dFdx/dFdy
are core there. The desktop port now removes only that directive. The corrected
capture has a textured dark-metal/green assault rifle and textured terrain
rather than the former nearly uniform white weapon inside the native GL frame.
The remaining pale-rifle CLI capture was a headless presentation bug, not a
D3D8 material bug. WebGL requests an opaque default framebuffer with
alpha:false, but the native desktop GL context still stores fragment alpha;
the readback path passed those low alpha bytes to the software compositor and
blended otherwise-correct rifle RGB toward white. Headless readback now honors
the requested WebGL contract by forcing alpha to 255. The focused regression
draws RGB with alpha zero and verifies opaque readback, while the frozen VLAN
replay verifies the textured rifle survives composition and that held movement
changes the first-person scene.
The final acceptance was repeated from a clean worktree at commit fecc3e2f.
The authentic dedicated server entered DM-Antalus, the client and server
exchanged native UDP through vln/1, the client created its D3D viewport, Fire
transitioned it from the join prompt to an owned pawn, and the captured frame
showed the HUD plus textured weapon and terrain. Both emulator processes exited
cleanly. The committed wall-clock test proves join and rendered gameplay;
deterministic held-key movement was additionally proved with a frozen
tools/ctl.js replay.
A fixed-wall-time profile of the map-load window (batches 6000--12000) retired
938 million handler operations. Raw x87 instructions were 26.85% of them, with
no single block over 2.23%, so the load is broad Unreal transform/material
work rather than one stuck loop. Enabling the existing experimental x87 fold
executed 27.3 million fused regions and advanced 25,179 batches in 140 seconds
versus 20,818 without it, about 21% farther on this run. The CLI candidate uses
--x87-fusion; browser runs can opt in with ?x87-fold.
SSE is now a separate per-app CPU policy rather than a global claim. The
ut2003_demo client and server advertise a Pentium III with CPUID EDX bit 25;
the default personality and the not-yet-exercised UT2004 entry still hide SSE.
Following the authentic UT2003 path added the instructions it actually reached:
exact SFENCE, MOVNTQ, memory MOVLPS, all eight CMPPS predicates, and
MOVMSKPS. Unknown SSE encodings continue to trap.
That policy also selects three MSVC/D3DDrv 64-byte MMX copy loops, including a
79-byte three-register pipelined MOVNTQ body at original D3DDrv VA
0x10001100. Each is recognized by a complete address-independent byte hash
and lowered through H419 to memory.copy only for proved-disjoint, page-local
mappings; overlap and split mappings retain the original instruction ordering.
The regression compares ordinary decoding with each lowering for copied bytes,
GPRs, flags, final MMX registers, overlap, page splits, and a one-byte near miss.
A clean authentic run reaches D3DDrv with no SSE decoder trap, but the shared
machine was under heavy concurrent load during the final timing run, so that
run is evidence of compatibility, not a defensible wall-time speedup measure.
The CLI software D3D backend reaches the same engine loop without an unimplemented API but rejects its GPU draw opcode; the native/browser WebGL backend remains the authoritative graphics verification.
UT2004: the registered -opengl argument is the whole blocker
UT2004's "further post-probe launch diagnosis" above is resolved. It is not an
emulator gap at all — it is the command line lib/apps.js registers for
ut2004_demo:
args: '-opengl -window'
How the real error was recovered
The app dies inside MiniDumpWriteDump, which reads as the bug and is not:
that is only UE2's crash handler, running after the engine has already decided
to die. UE2 reports through appError, which throws, so the message never
reaches stdout. It is in memory, though — core.dll exports
?GErrorHist@@3PAGA (ordinal 1036, original VA 0x101ad200), a UTF-16 buffer
holding the error text. Dumping it one batch before the crash gives the real
complaint:
Missing symbols - aborting. History: UOpenGLRenderDevice::Init
Recipe worth reusing on any UE2 title: resolve ?GErrorHist@@3PAGA to a
runtime VA with core+0x101ad200, then --input=N:dump-mem:<va>:512 at a
batch just before the crash. --dump= is too late — it fires at exit, after
the handler has run.
A GetProcAddress census confirms it: 99 GL/WGL names resolve and 298 return
NULL, including core GL 1.1 entry points. OpenGLDrv cannot initialize
against that surface, and the engine aborts rather than falling back.
The fix, and what it reaches
Changing ut2004_demo's args to
args: '-d3d -window -nosound'
routes it to the same D3D8 path UT2003 already uses, and the game reaches gameplay: DM-Rankin's lit brick-and-wood interior with a bot in frame.
Applied 2026-09-22. With the D3D9 software path's point/spot lights
(fab74ee8), --d3d9-renderer=software --d3d9-programmable also draws the
Epic/Digital Extremes/Atari splash with zero refused draws (1.42M batches in
150s at --batch-size=200000); it had refused every lit draw before.
UT2003 under the CLI software backend
The paragraph above ("the CLI software D3D backend ... rejects its GPU draw
opcode") is narrower than it reads. With
--d3d9-renderer=software --d3d9-programmable on the remote bench box, UT2003
renders its full menu chain — intro logos, the NVIDIA splash, the main menu,
and Instant Action | Select Map complete with a live 3D Antalus preview
inside the map panel. PNG capture there comes off dx slot 5 640x480, the real
primary surface, rather than the canvas the headless-GL path reports.
Three things cost a session each and are worth writing down:
A
mousemovemust precede themousedown. UT2003's menus are in-engine widgets that track hover; a baremousedownat the right coordinate is silently discarded, the highlight never moves, and--trace-apishows a perfectly healthy message pump. Two moves then a down/up 2000 batches apart is what works.The game window is placed at (20,35) with a 1024x768 client, so on a 1024x768 desktop its bottom edge — the row holding BACK / SPECTATE / PLAY — falls off the screen. That is window placement, not UI scaling:
--screen=1100x840shows the whole dialog.--screen=enlarges the desktop only; the viewport itself is a game-config property, set inSystem/UT2003.iniunder[WinDrv.WindowsClient](WindowedViewportX/Y,FullscreenViewportX/Y,MenuViewportX/Y).Resolved 2026-09-29: PLAY works, and UT2003 reaches a DeathMatch. The "dead button row" below was a measurement artifact, not an input bug. PLAY starts the map load at once. The load runs for about 1000 batches with no Present, so every capture in that time shows the last menu frame, PLAY still highlighted. Two things made it look dead. The bounded runs below ended inside that window. And before the render-park fix (next section), parked batches were counted without running the guest, so a run could end with the guest having done almost nothing after the click. BACK was not retested; the same artifact is the likely explanation.
Route (box2, current main plus the render-park fix):
node test/run.js --app=ut2003_demo --control --frozen --max-seconds=7200 \ --max-batches=100000000 --stuck-after=100000000 \ --d3d9-renderer=software --d3d9-programmable --batch-size=200000 \ --quiet-api --screen=1100x840 --trace-input --no-close- Step to the main menu.
- Hover pair, then click INSTANT ACTION at (536,578).
- The window is at (20,20) with a 1032x796 frame and client origin (24,44).
Select
dm-asbestosby clicking (290,281). - Hover (981,775) then (985,778). Then mousedown/mouseup at PLAY (985,778), 3 batches apart. That click was batch 964/967.
- By batch 1007 the main thread is in the exe's buffered
FArchivereader.exe+0x5550is the precache path (call [eax+0x48]with0x7fffffff).exe+0x39c0is its memcpy tail. The box's load average falls to ~0.1 because there are no software-render waits. Use that as the oracle, not the picture. Check whether the snapshot EIP is in0x109055xx/0x109039xxand whetherctx.renderParkStats.waitsis flat. - At batch ~2025: DM-Asbestos with "The match is about to begin...3" and "Press [Fire] to join the match!".
- Left click in the viewport (540,400). By batch 2113: "The match has begun!", HUD at 100 health / 150 ammo, and the assault rifle in first person.
The earlier reports, kept for the record:
The
Instant Action | Select Mapdialog's bottom button row (BACK / SPECTATE / PLAY) seemed to take no input. The click that opens the dialog — INSTANT ACTION on the main menu at (536,578) — works every time. Measured, each in its own bounded run with a hover pair before the press:- BACK at screen y = 743, 760, 778, 790 and PLAY at y = 770, 778: all leave the dialog exactly where it was. Five rows spanning 47px, so this is not a coordinate offset, and BACK failing rules out anything PLAY-specific such as a disabled button.
- Double-clicking the selected map name (
dm-antalus, (290,261)), which is UT2003's own start-the-match shortcut: no effect. - Tab x3 then Enter: no effect.
Two traps for whoever picks this up: the map preview panel cycles through screenshots on its own and the map description types itself out one character at a time, so every capture of this dialog has a different hash whether or not any input landed —
md5cannot be the oracle here, only the dialog's identity can. And the row is drawn at client y ~743 of a 1024x768 client whose window origin is (20,35);--trace-inputconfirms run.js injected each event. The 2026-09-29 run routes both down and up to the game window (-> child 0x10005 ... dispatched=1,up ... matching its DOWN). Nothing was dropping them.Do not quote batches/s across phases. One UT2003 run on the box moved 13.8k -> 61k -> 65k batches/s between its intro, menu and idle phases. A batch is a budget of blocks, so the unit changes meaning with the guest's code shape.
"Stuck forever in the first software DrawIndexedPrimitive" (2026-09-29)
Reported for both demos: a bounded run
(--d3d9-renderer=software --d3d9-programmable --max-batches=1500 --batch-size=200000 --trace-api=IDirect3DDevice8_DrawIndexedPrimitive,IDirect3DDevice8_Present)
ends with EIP parked on the D3D thunk after 30 DIPs and 2 Presents, and looks
like a rasterizer that never returns. It is not a guest or rasterizer hang.
Ruled out by reading and by probing: the D3D8 DIP frontend (09ac, SetIndices
base at state+1692), $d3d9_draw_buffer's validation (09ae), and the
software prepare/step tile loop (09ah, bbox clamped to the viewport,
non-finite vertices marked bad) all terminate.
What happens: every software draw/Present returns a negative render token,
$d3d_render_park sets yield 16, and the CLI main thread waits on the render
worker (lib/d3d9-host.js; Node has no crossOriginIsolated, so the CLI always
takes the async worker path). test/run.js checked "still parked?" once per
batch: run() was skipped, the batch was counted and the batch clock
advanced, so a --max-batches budget drained one event-loop turn at a time
while the guest executed nothing. A ctl.js eval on the parked run showed the
request {"t":-6,"done":true,"yr":16} completing and moving on to -8, and
frozen stepping walked UT2004 into its NVIDIA intro with a software-rendered 3D
character — slowly, not stuck.
Fix (test/run.js, awaitMainRenderPark): before each batch, if main is parked
on yield 16, await that request in wall time (bounded by --max-seconds and
stop), then run the batch. --no-render-park-wait restores the old loop for an
A/B. The exit summary prints render park: main waited on N software D3D requests (Nms wall), N batches skipped while parked, and ctx.renderParkStats
exposes the same to --control evals. test/test-d3d-render-park-batches.js
drives the shape through real COM thunks (512x512 software device,
DrawPrimitiveUP + Present in one 40-batch step): 0 batches skipped with the
fix, 39 of 40 skipped with --no-render-park-wait.
Same UT2003 command line, same box, after the fix: 866 DIPs and 722 Presents
in 712 batches, and the capture is the UT2003 main menu (dx slot 5,
1024x768). Before it was 30 DIPs and 2 Presents in 1500 batches. The run hit its
--max-seconds=600 guard rather than its batch budget, and render park says
why: 362 waits, 588s of the 600 on the software worker, so about 1.6s per
parked request at 1024x768. The wall-clock ceiling is now the software
rasterizer's throughput; batch accounting no longer hides it. Use
--max-seconds rather than --max-batches for UT routes on this backend.
UT2004 with the same flags makes no D3D8 call in its first 1500 batches,
because it is still streaming packages in 1KB ReadFiles (humanmalea.ukx and
others) before it opens the device. Given --max-seconds=600 --max-batches=100000000 --stuck-after=100000000, it reaches the UT2004 main
menu (dx slot 5, 640x480, 845 Presents, 5195 batches). 562s of the 600 were
2518 render waits. Note that --stuck-after=0 does not disable the stuck
detector: the test is stuckCount > STUCK_AFTER, so 0 fires on the first repeat.
Pass a huge value instead.
The browser never had this bug: host.js yields to the event loop rather than
spending a counted unit per check.
The fixed UT3 installer was executed directly in Wine Assembly. Its verified first runtime blocker is:
UuidToStringAat installer EIP0x00422225(batch 0).
Static PE import comparison against src/api_table.json found nine imported
names which are not implemented:
AdjustTokenPrivilegesGetThreadContextLookupPrivilegeValueARpcStringFreeASetThreadContextUuidToStringAVerLanguageNameAVirtualProtectExWriteProcessMemory
Installer strings also name seven MSI APIs resolved dynamically, so they do not appear in the static import table:
MsiCloseHandleMsiGetProductInfoAMsiGetSummaryInformationAMsiOpenDatabaseAMsiQueryProductStateAMsiSourceListEnumSourcesAMsiSummaryInfoGetPropertyA
Only MsiQueryProductStateW currently exists in the API table. UuidCreate is
already implemented through CoCreateGuid. This is an analysis inventory only;
none of the UT3 gaps were implemented.
Call-form census and the software-D3D8 draw stall (2026-09-29)
Measured with test/run.js --edge-hist and tools/call-form-weighted.js
(docs/uop-tier-design.md §15.1). Box1 ran --d3d9-renderer=software --d3d9-programmable --batch-size=200000 --screen=1100x840. On that tree
(2a632d73), neither UT2003 nor UT2004 gets past the first 3D draw: the main
thread never returns from IDirect3DDevice8_DrawIndexedPrimitive.
- The last EAX is
0x8876086c(D3DERR_INVALIDCALL). - Only T1's Sleep/CriticalSection polling continues.
- The window stays grey, and
--dx-surfacesslot 5 showsnonZero=0. - UT2004 reaches this at about batch 2100-2250.
ut2003_demo_serverstalls the same way, after a.PAG <- .PAXC++ throw.
That run did not use --headless-gl, and box1 has no display for it. So the
earlier gameplay verification stands for its own path only.
The load phase itself is the most indirect-call-heavy code measured in the corpus. Guest indirect transfers are 4.5-8.4% of block entries, and vtable/reg calls are 2-6.6%. The sites are low-polymorphic:
core+0x10128138and+0x1011ae20, bothcall [eax+4](FArchive::Serialize), 1-3 targets.UStruct::SerializeExpratcore+0x1011d330: a monomorphic self-recursivecall [edx+0x98], plus thejmp [0x1011d9f4+edx*4]token switch (24-28 arms).
Unreal SE's Nyleve flyby on SoftDrv: under 1% guest indirect. The threaded
remainder there is SoftDrv MMX (pxor/movq/pmulhw/psraw) refused as
head-unsupported. galaxy+0x105085d2 call [0x1054c260] calls a runtime-built
mixer in heap memory (0xc49394).
MMX fill fold (2026-09-29). Unreal SE's SoftDrv has the same
movq [r],mm; add r,8; dec c; jnz clear loops as Deus Ex, at 0x10931ed0 and
0x10931ff0. The fold (docs/loop-idiom-superops-design.md §23) matches them
zero times in the flyby, batches 900-1800. The flyby never clears the
frame.
- Box1 runs with
--branch-clock --wall-clock-ms=1790673326000: user CPU is neutral, off 28.07/28.02 s against on 28.12/28.22 s. - Frames are md5-identical at 900/1200/1500/1790/end.
The flyby's MMX share is compute. SoftDrv loads at a runtime base of
0x0289b000 (preferred 0x10900000), so softdrv+0x10924747 is the block at runtime
0x028bf747. The hot blocks:
softdrv+0x10924747/+0x1092475a: palette-lookup texel, 4-5% of threaded entries.+0x10922f2f: bilinear lightmap fetch, 3-5%.+0x1092314e/+0x10923614: span setup, which loads ESP from[0x109548b4].+0x10923210/+0x109236d0: 8-texel span bodies.
That is a uop-tier MMX coverage problem, not a fold.
Covered (2026-09-29, docs/uop-tier-design.md §16). Every head above is now
installed or live in the uop tier. Threaded block entries over batches
900..1800 went from 116.1M to 68.8M. User CPU for 1800 batches went from
28.42/28.93 s to 18.45/19.01 s (−35.1%), with frames md5-identical at
900/1200/1500/1790/end.
CRT exports and the native overrides (2026-09-29, docs/crt-native-overrides.md)
UT2003 imports msvcr70.dll and UT2004 imports msvcr71.dll, both through
thin wrappers in core.dll at core+0x101139xx..0x10113cxx. Which CRT export
is hot depends on the phase:
- UT2003, batches 420..520 of the software-D3D load (
--batch-size=200000):flooris 7.9-13.5% of all block entries, 30-50K calls per 50 batches. The callers arecore+0x101139b0andcore+0x10113970. Each call runs_ctrlfpand the_fpclasshelperssub_7c0363b7,sub_7c034d89andsub_7c0366a8._vsnwprintf(_woutput) is 0.6-1.9%.
- UT2003, other windows:
rand(core+0x10113940) is 3.2%, of which_getptd(msvcr70 0x7c00137f) is 2.3%. The wide-string compares and copies (_wcsicmpatcore+0x10113b50,wcslenat+0x10113b00,wcscpyat+0x10113b60,wcsstrat+0x10113b10,_wcsnicmpat+0x10113c00) run at 10^4-10^5 calls in the heavier windows. - UT2004, 600..1100:
_wcsicmpis 2.77%, of which_getptd(msvcr71 sub_7c349636) is 2.08%.- The other wide-string functions add about 2%.
- From 1100 on,
_woutputtakes over at 2.8-14.5%, withmbtowcat 5.47% inside it.
floor, wcslen, wcscpy, wcscat, wcsstr, _wcsicmp and _wcsnicmp are
now native when imported from these DLLs. With them, msvcr70 falls from
11.8-14.7% to 1.4% of UT2003's block entries in 420..520. What is left is
_vsnwprintf, mbtowc and memmove. rand and _vsnwprintf are the
remaining candidates, and neither is done: rand keeps its seed in the ptd,
and _vsnwprintf needs a byte-exact formatter.
A run of the same build is deterministic. For UT2003 with the software backend at 200000 blocks per batch:
- The baseline reaches its 170th software render request at batch 520.
- The candidate reaches it at batch 491, and by batch 520 it is at request 199.
UT2004 over batches 600..1100: msvcr71 drops from 16.1% to 6.9% of block entries (docs/crt-native-overrides.md, Verdict).
UT2004 reaches a DeathMatch (2026-09-29)
UT2004 now gets into a match: DM-Rankin, HUD at 100/100, and the clock counting down from 20:00. It took three emulator fixes.
95b1b8c9: DestroyWindow no longer quits. UT2004's splash dialog is the first top-level window, so it became
$main_hwnd. Destroying it set$quit_flagwhile the game kept running. Now$main_hwndpasses to the next top-level window, and WM_QUIT comes only from PostQuitMessage.906cfe27: a real
RtlUnwind. The old handler unlinked frames without calling their handlers withEXCEPTION_UNWINDING, so msvcr71's C++ EH never ran its unwind funclets. The first.PAG <- .PAXthrow after PLAY left a stale FRAMEINFO chain, and__CxxFrameHandlerlooped. The replacement follows NT x86 semantics:- each frame below the target gets its handler called with
EXCEPTION_UNWINDING(plusEXIT_UNWINDwhen the target is NULL), then is unlinked; - a collided unwind (disposition 3) resumes from the dispatcher context;
- EAX returns ReturnValue.
- each frame below the target gets its handler called with
4eb870e1: a dispatcher registration node. msvcr71's
_UnwindNestedFrames(orig0x7c359b25) runs the code below.saved = FS:[0] RtlUnwind(pRN) saved->next = FS:[0] FS:[0] = savedIt relies on NT's
RtlpExecuteHandlerForExceptionhaving linked its own node on top of FS:[0] for the duration of the handler call. Without the node,savedis the catching frame itself, and the relink made it point to itself: the SEH chain read0x179fb6d8 next=0x179fb6d8and the next throw walked it forever. The emulator now links a node{next, handler=0xCACA003A thunk, establisher}around each handler call:- the node's handler returns ExceptionCollidedUnwind and fills the dispatcher context on an unwind, and ContinueSearch otherwise;
$seh_walk_fromand$rtl_unwind_stepskip the node.
test/test-rtl-unwind-handlers.jscovers the whole relink. The dump helpersehchain.js(actl.js evalthat walks FS:[0] and flags a cycle) is what found it.
Route (box2; flags as for UT2003 above):
- Step the frozen run to batch 3500 for the main menu, 640x480, at client origin (24,44).
- The mouse is DirectInput-relative, so every click needs a sync. Move to (24,44), step 3 batches, move to (300,300), step 3, move to the target, step 3, then click. The hover highlight can lag behind; the clicks still land.
- Click INSTANT ACTION at (400,362). The Gametype page is up by batch 4400.
- Click DeathMatch at (195,221). Select Map (DM-RANKIN) is up by 4550.
- Click PLAY at (448,514) (batch ~4565). The load shows no Present:
- captures keep the typewriter menu frame;
- EIP samples sit in msvcr71
_woutputand friends at0x115a..-0x115c..(runtime base0x11591000); - eight
[C++ throw] .PAG <- .PAXlines are logged and are harmless now. - Check progress with the snapshot EIP and the SEH chain, not the picture.
- By batch 8200: DM-Rankin with "Press [Fire] to join the match!".
- Click in the viewport (340,300). By 8600 the player has spawned, with the HUD, the weapon bar and the assault rifle.
UT 348 route (2026-10-06)
--app=ut348_demo mounts test/binaries/candidates/unreal-tournament-348-demo/extracted/
through a manifest written by node tools/gen-tree-manifest.js <root> --exe=System/UnrealTournament.exe --flatten=System. The game opens
UnrealTournament.ini relative to the exe and its packages through
..\System, ..\Maps etc., so System\ files are mounted at both
c:\<name> and c:\System\<name>. Without the mapping it dies early with
"Can't find file for package 'Engine'" (an appThrowf; Core's static message
buffer is at core+0x101f65fc, readable with --dump after the exit).
FirstRun=0in the shipped INI opens the setup wizard. Its device probe (exe+0x1090d9e0) runs inside the WM_PAINT thatUpdateWindow(0x1000c)sends synchronously. It ShellExecutes a second copy (testrendev=D3DDrv.D3DRenderDevice log=Detected.log), then polls the log withGFileManager->FileSizeandSleep(100)up to 100 times (a 10000 ms budget counted down by iteration, not by the clock), then lists the devices. Two emulator bugs used to stop it (fixed in dd0d6dc8):$wnd_send_messageabandoned the paint after 64 rounds, because every Sleep ends a round ([sync] ABANDONED wndproc hwnd=0x0001000c msg=0xf at 0x1090dbfe). The wizard then sat on "Detecting 3D video devices, please wait..." for good.- In the browser the ShellExecute really starts the child. The child had no
dllsseeds, so Core/Engine/Window.dll bound to stubs and it trapped on?appPackage@@YAPBGXZ, or threw anintthat went unhandled (the "C++ throw .H ... UNHANDLED EXCEPTION 0xe06d7363" console the user reported, in both thread modes). The CLI's ShellExecute starts no child, so it never showed this. The child's log never reaches the parent (a VFS child gets a copy of the file map), so the wizard always settles on Software Rendering.
- Engine errors (
appErrorfthrows anintwhile guarded; everyunguardiscatch(...) { appUnwindThrow(...); throw; }) went unhandled until 867f35a3: the nested rethrow dispatch overwrote the software SEH walk's globals, so the outer walk carried on with the rethrow's null-ThrowInfo record. Now they reach UT's own "Critical Error" box. Quick repro:--args="DM-Morpheus -window"(the demo's map isDM-MorpheusDEMO) plus wizard clicks gives "Failed to enter DM-Morpheus: Can't find file". --args="DM-MorpheusDEMO -window"goes from the wizard straight into a match. In the browser,tools/web-input-probe.js --before-load=can setwineApps.APPS.ut348_demo.args(evidencescratch/runs/20261006T141000Z-ut348-web-cxx-throw-fixed, both thread modes). With Threads on, wizard button clicks needed 61686c8e: the renderer had been pressing them on the idle shadow instance.- The child mode by itself (
--args="testrendev=D3DDrv.D3DRenderDevice log=Detected.log") loads D3DDrv, tests it and exits 0 headlessly. Pass--stuck-after=1000000: its CPU-speed loop trips the stuck detector. - Wizard buttons render without labels (Back/Next at about (223,418), Cancel at (401,418)). Next x3 by mouse reaches the UWindow menu.
- Once the wizard ended, its last page stayed in the renderer over the game
window and ate every click:
$wnd_destroy_treenever told the host about windows below the root. Fixed in 09c3a; covered bytest/test-dialog-teardown-grandchild.js. - In the UWindow menus the cursor moves by
relmousemoveat roughly 46% of the requested delta. Game > Start Practice Session opens on DM-Morpheus; Start (about (598,418)) loads the map; "Waiting for ready signals" until a fire click. VK_UP then walks and relmousemove turns the view. - Not evaluated: audio, FPS, browser. Some frames between kills are black with only the HUD (death/respawn view).
Evidence: scratch/runs/20261006T001500Z-ut348-demo-claude202b4b39-dm-morpheus.
Deus Ex demo on OpenGlDrv (2026-10-06, OPENGLDRV-GL11-SURFACE)
OpenGlDrv resolves the whole GL 1.1 + WGL table by name and aborts ("Missing
symbols") if one is absent; since 5f17bb07 every GL 1.1 name is an API
(unimplemented ones fail fast by name) and it binds. Select it locally by
setting deusExRenderer in lib/apps.js to OpenGlDrv.OpenGLRenderDevice
(the committed default stays SoftDrv) and run the CLI with
--gl-renderer=software.
- The calls it really makes beyond the old set: glMultMatrixf (GL op 109) and glClearDepth (op 110), both implemented. glGetString is queried for GL_EXTENSIONS eleven times (one per extension it probes); no glGet*v or glReadPixels at all.
- It then plays the 3D logo intro for 170 s with no trap (run
20261006T1440Z-opengldrv-deusex, intro.png). - Open: Escape out of the intro crashes, on OpenGlDrv only (SoftDrv
with the same
--input=200000:keydown:27,200100:keyup:27reaches the menu). The last GL calls are a 256x256 GL_RGBA8 upload with nine mip levels and two glTexParameteri, then engine+0x1030cba6 (call [eax+0x28]on the object at[esi+4], a per-element loop over an array of 0x28-byte records) jumps to 0x410054 ("execution entered zeros"). That object's vtable pointer is 0x7da2f600, the same value the caller holds in EBX, i.e. a heap address where a vtable should be: most likely a use-after-free (a freed block's link word read as a vtable), not a GL write -- no GL call that writes guest memory runs in that window. Next: --watch the object's first dword (--watch=0x7e2f17d0 --watch-log, addresses deterministic) to name the free that recycled it, and compare HeapFree/HeapReAlloc semantics.
Correction and narrowing (same day, watchpoints): the object's vtable is
NOT overwritten -- --watch=0x7e2f17d0 --watch-log shows only its
construction (batches 45598-45599). engine+0x1030cb70 is a lazy loader's
Load: this = 0x7e2f17d0 (a two-slot vtable whose slot 0 is this very
function), [this+4] = the FArchive (0x7e9b46a4, vtable in Core), [this+8]
= the saved file position. It calls Tell (+0x28), Seek (+0x34),
serializes the array at this+0xc (engine 0x10303904), then Seeks back.
So the jump into zeros happens while OpenGlDrv's texture upload lazily reads
texture data out of a package: the suspect is the serialized data (a count
or size from the file) smashing the stack, i.e. a file-read difference, not
a GL call. SoftDrv may never touch that texture. Next: --trace-fs on the
package reads in batches 211000-211300 and a stack-guard watch on the
caller's frame (EBP 0x179ff694).
Static follow-up (same day): engine 0x10303904 -> 0x1030cc60 is
operator<<(FArchive&, TArray<BYTE>&) (compact-index count, Realloc, then
Serialize into the heap buffer) -- nothing there writes the stack. The
FArchive at [this+4] has Core's vtable 0x1017a3f8 (file 0x10c443f8 at
runtime), and its slot 10 (Tell, 0x101634b0) and slot 13 (Seek, 0x10163410)
are real functions, so the loader's two virtual calls are sound. The jump
into zeros therefore happens later, inside Seek/Serialize or after the
loader returns; the next runtime step is --trace-at=core+0x10163410 on
the last hits before batch 211297 and a --trace-stack-scan at the crash.
Boat runs (2026-10-06, main 99e861e6, boat bx_n53xdjmt, fresh npm ci;
deusExRenderer = OpenGlDrv and OpenGlDrv.dll added to the DLL list as a
boat-local edit; --gl-renderer=software --quiet-api --quiet-blocks --stuck-after=0 --input=200000:keydown:27,200100:keyup:27). Module bases in
that build: engine 0x10e82000 (orig 0x10300000), core 0x10bca000 (orig
0x10100000), opengldrv 0x120d0000.
- The crash is ESI clobbered across a call, not a bad object. It lands in
the lazy loader's Load (engine 0x1030cb70,
thisin ESI): the first virtual call ([eax+0x28], ULinkerLoad::Tell, core 0x101634b0) returns, thenmov ecx,[esi+4]reads garbage because ESI = 0x179ff644, a stack address (crash regs: ESI 0x179ff644, ECX 0x7e2f1848, EDX 0x10fa97fc = the TLazyArray vtable, ESP 0x179ff668 = the Seek call's return slot), socall [edx+0x34]indexes past the two-slot TLazyArray vtable into zeros at 0x410054. - Ruled out: the linker is not freed (
--watch=0x7e9b46a4never fires); the mip records (FMipmap, 0x28 bytes, lazy DataArray at +0x10) are well formed (dumped at batch 211263); the micro-op tier (--no-uopcrashes identically at batch 211244); an unbalanced inner call (at core 0x101634e3, just after Tell's innercall [eax+0x28], ESP = EBP-0x24 exactly as the frame needs, every hit). - It is not a plain race either. Batch 211244 reproduces with the same
flags (runs 3 and 4), a dword watch on the linker (0x7e9b46a4) leaves it
in place, but
--watch=0x179ff648-- the slot Tell'spop esireads back -- makes it vanish (211300 batches, no crash, no watch hit), and so does--trace-api=SetFilePointer,ReadFile,.... Main's stack (0x179ff...) is outside the direct guest window, so it goes through the sparse page translation; a watched page takes the checked write path. Lead: a stale translation or fast-path write on that sparse stack page, sopop esireads a value the guest never stored there. - Side note: guest thread 1 (start 0x109010b9) ends at EIP 0 from prev_eip 0x10901a29 early in the run; not yet looked at.
CORRECTION and narrowing (same day, boat bx_rdw8tsqd, main 85141552;
evidence scratch/runs/20261006T1810Z-deusex-opengldrv-esi/key-lines.txt):
- Main's stack is NOT on a sparse page. deusex.exe's image base is
0x10900000, so guest 0x17900000-0x17a00000 is
$GUEST_STACKinside the direct window, and the "sparse page translation" lead above is wrong. The translator is single-mode now (flat PTE table), so there is nothing to toggle either. - The mechanism, caught with
--trace-eip-range=core+0x101634b0-core+0x101634f4 --trace-eip-from=211275 --trace-eip-detail(run 10, which still crashed): at Tell's landing after its innercall [eax+0x28](core 0x101634e3) every normal hit has ESP 0x179ff644 and EAX = the file position; in the crashing call ESP is 0x179ff654 (+0x10) and EAX = 0. So the inner call came back as if aret 0x10function returning 0 had run. Tell'spop edi; pop esithen read 16 bytes too high, and the second slot is[ebp-0x10], where Tell'smov [ebp-0x10],espsaved 0x179ff644 -- that is the ESI. Load's nextmov ecx,[esi+4]readsthisback from the stack and calls through the two-slot TLazyArray vtable into zeros. - The inner call's target is sound and unchanged:
[linker+0x440]= 0x7e9b4100 (watched in run 1), whose vtable 0x109267e4 never changes after construction at batch 9097 (--watch=0x7e9b4100 --watch-log, run 11); slot 10 is deusex.exe's ILT thunk 0x10901131 (jmp 0x109063b0), and 0x109063b0 is a two-instructionmov eax,[ecx+0x38]; ret. So the emulator ran different code for that call than the guest bytes say. - Ruled out inside the crash batch: a full cache clear (
cache: full clears M 2already at batch 211281, the same total as a non-crashing run to 211300), any code write or block retirement (--trace-code-writes --trace-from=211270, crash still at 211282, nothing logged). - Reproduction that survives probes: adding
--input=B:dump-mem:0x179ff600:256for every B in 211265..211320 makes the crash land at batch 211282 every time, and core-range--trace-eip-range/--decode-stats/--trace-code-writeskeep it there; an exe-range trace (0x10901100-0x10906500) or--trace-atdoes not. - Leads: (a) the block run for the call target -- the decoder extends runs
through
jmpand fusesmov esp,ebp; pop ebp; retinto a pop run + RET whose RET immediate is a thread word; an imm of 0x10 would give exactly +0x10; and the stats show 77 decodes that "evicted a live block". (b) guest thread 3 ends the run with ESP 0xd9f40000 (printed as -0x260c0000), which is not a stack -- worth a look on its own. - Tooling trap:
--trace-eip-range=0x00400000-0x7fffffff --trace-eip-from=211282 --trace-eip-streamtraced from batch 0 (11 GB log, run reached only 104,203 batches in 800 s); check--trace-eip-fromwith an explicit range before reusing it.
The overwrite (same day, boat bx_e35gh894, main 8c360029; evidence appended
to scratch/runs/20261006T1810Z-deusex-opengldrv-esi/key-lines.txt):
- The decoded code is NOT at fault. A boat-local
--input=B:dump-stream:0xGAprobe (two throwaway exports over$page_cached_stream, never committed) shows the threaded streams for the ILT thunk 0x10901131, the reader Tell 0x109063b0, and core Tell's entry and landing decoded exactly as the guest bytes say (pop run + RET imm 0, push runs, rop loads/stores), and their chunk addresses do not move in batches 211270-211282. - What changes is the vtable itself:
--watch=0x1092680c --watch-log(slot 10 of the reader vtable 0x109267e4 in deusex.exe .rdata) fires at batch 211227,0x10901131 -> 0xffff00ff(a pixel value), 17 batches before the crash. With the slot reading 0xffff00ff the inner call goes into an API thunk-like target that pops 16 bytes and returns 0 -- the ESP+0x10 / EAX 0 seen at Tell's landing. Same overwrite with--no-uop. - The watch names main at OpenGlDrv's P8->RGBA converter (opengldrv
0x10008fde..0x10009024:
mov al,[ecx+edi]; mov ecx,[pal+eax*4]; mov eax,[ebp-0x18]; mov [eax],ecx; add eax,4), but that attribution is probably wrong: the converter's destination[ebp-0x18]holds plain heap addresses (0x7ce3d408 / e408 / f408 at the row heads of batches 211226-211228) that NO mapping covers (--dump-virtual-maps: the nearest record is guest 0x7cdf0000..0x7ce31000; a boat-local--input=B:g2w:probe givestest_g2w_slow= 0xf0 sentinel for them before AND after the write),--fault-nullreports none of its stores, and a value-filtered watch on[ebp-0x18]never sees 0x1092680c. A watch is only checked on the watching instance's own block boundaries. - Lead: guest thread 3 (spawned at 0x17a06908 -- inside the THUNK_BASE window
for this image base, guest 0x17a00000+ -- with ESP 0x7d0afff8) ends every
run in msvcrt with a garbage ESP that differs run to run (0xd9f40000,
0xa1fe0000, 0xa68a0000; printed signed). A thread whose ESP sweeps through
guest 0x108EE000..0x188EE000 writes deusex.exe's image through the direct
window with every push, and the cooperative interleaving would explain why
every probe moves the crash. Next:
--trace-thread/--trace-schedon T3, find what sets its ESP, and identify the callback behind thunk 0x17a06908. - Separately: the converter writing through an unmapped destination is itself wrong on real hardware (it would fault), so either an allocation path failed to record a mapping for 0x7ce3xxxx or the guest overruns its buffer; check after the thread lead.
Thread 3 (same day, boat bx_tdvuwpfj, main 1945acdd; boat-local probes in lib/thread-manager.js and src/03-registers.wat, never committed):
- Thread 3 is Galaxy's audio mixer (its slices start in galaxy.dll at
0x11f43xxx-0x11f47xxx) calling runtime-generated MMX mixing code at
0x1224ed00-0x1224f4xx (no module covers it). That code saves ESP to a
galaxy global (
mov [0x11f7c224], esp), loadsmov sp,[ebp+0x20],shl esp,0x10and uses ESP as a fixed-point step (add edx,esp) and EBP assar ebp,0x10-- so the "garbage ESP" (0x80000000, 0x72060000, 0x1f560000, 0x40000000 at slice ends) is legitimate, and it makes no push/call while ESP is repurposed. - It IS the writer. A slot guard that reads guest 0x1092680c after every guest-thread slice fired twice, both times in a T3 slice: 0x10901131 -> 0xffff00ff (two 16-bit samples). Once mid-mixer (EDI 0x1227dfc8, EAX 0x12280048, EBX 0x122820c8), once in a slice that began at the mixer's second path (eipBefore 0x1224f143) and ended back in galaxy.
- Not an instance mismatch: T3's
get_image_base()= main's = 0x10900000. Not the uop tier (same overwrite with--no-uop). Not$gs32/$gs64: a trap on any store within 8 bytes of the slot in both never fired, so the store goes through an inlineg2w-fastpath, which for a direct-window address is a correct translation -- i.e. the guest store's own address is 0x1092680c. - The mixer's stores are only
movd/movq [edi|eax|ebx](+8), mmN, with EDI/EAX/EBX loaded from its arguments[ebp+8],[ebp+0xc],[ebp+0x10]. So in the writing slice galaxy passed an output pointer of ~0x10926804 -- inside deusex.exe -- for one mix call. DirectSound Lock/Unlock is not per-call (4 calls on T3 in batches 211150-211282), so the pointer comes from galaxy's own buffer bookkeeping, not straight from our IDirectSoundBuffer_Lock. - Next (boat): log the mixer's three output arguments at its entry
(0x1224ed20, T3) per call in the batch before the overwrite to catch the
call with ~0x109268xx, then trace where galaxy computes that pointer
(its globals near 0x11f7c2xx and the table at 0x11fbd914 are the leads);
suspects in our emulation are the inputs galaxy derives buffer positions
from -- DirectSound play/write cursors (GetCurrentPosition), buffer sizes,
or a 16-bit op in the mixer setup (
mov sp,[m16],adc esi,ebp).
ROOT CAUSE, and a correction to the Galaxy attribution above (same day, boat bx_k5x5vqk5): the writer is our own software GL, not Galaxy and not the guest.
- The thread-3 attribution was an artifact: a check after each T3 slice
compares with the value from T3's previous slice, so anything main wrote
in between was charged to T3. A value check in the
dispatch-nextmacro and at$branch_end_at, in every instance, fired in MAIN at the landing of opengldrvcall [0x10014fe0](0x10009232 -> 0x10009238), which isglTexImage2D(GL_TEXTURE_2D, level, internal, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels). - A guard in
$gl_sw_tex_store_to(trap when a texel's wasm destination is inside the direct window) loggeddib=0xF0: the texture's surface was created over the NULL sentinel.$d3d9_create_surfacetakes$dib_alloc's guest address and$g2ws it; the arena had 16384 pages (64MB) while$g2wmaps only$DIB_GUEST_CAPACITY= 63MB, so once OpenGlDrv's texture uploads after Escape filled the arena past 63MB every new surface translated to 0xF0. The surface was zeroed from 0xF0 and its texels stored from there, through the emulator's low memory and the guest image at 0x12000 -- e.g. texel (3,226) of a 256x256 level is wasm 0x3880c, deusex.exe's reader vtable slot 10, written opaque magenta 0xffff00ff. - Fix:
$DIB_PAGE_COUNT= 16128 (= capacity / 4096), withtest/test-dib-arena-translates.jsfilling the arena and checking every block translates (fails on 16384). - The Galaxy mixer's repurposed ESP/EBP and thread 3's "garbage ESP" are legitimate. The OpenGlDrv conversion buffer at 0x7ce3xxxx that no mapping covered (above) is not the cause of this crash; whether it is a separate mapping bug is still open.
Deus Ex demo on GlideDrv in the page (2026-10-06, DEUSEX-GLIDE-PAGE-EXIT)
GlideDrv played the 3D intro on the CLI but "exited to the desktop" in the
browser. The page actually showed Critical Error Assertion failed: RenDev [File:C:\Unreal\WinDrv\Src\WinViewport.cpp] [Line: 345], with the software
Glide backend (?glide-renderer=software) as well as WebGL, and its console
never logged a LoadLibrary of glidedrv.dll. UE1 loads the device class from
the guest's own C:\System; lib/apps.js mounted GlideDrv.int but not
GlideDrv.dll, and the CLI hid that by finding the DLL on the host disk beside
the exe. 7229c754 mounts the Glide, OpenGl, MeTaL and SGL driver DLLs beside
their .int files; GlideDrv then plays the intro in the page on the WebGL
Glide backend. test/test-unreal-renderer-dll-mounts.js checks that every
registry app mounting a *Drv.int mounts the DLL too. Evidence:
scratch/runs/20261006T1815Z-deusex-glide-page-w6.
Repro trap on a fresh clone or boat: the gitignored test/binaries/dlls
(msvcrt, comctl32) and fonts/*.fon are absent and there is no top-level
binaries -> test/binaries link, so the page falls back to stubs and fails for
an unrelated reason. Ship those first.
--app from a fresh candidate fetch (2026-10-10, UT2004-FRESH-FETCH-MANIFEST)
tools/fetch-candidate-corpus.js --id=<candidate> writes
.wine-assembly-browser.json at the candidate root, not under installed/. Its
urls start installed/..., its vfsPaths are c:\<path under installed>, and it
omits the exe. Before eb349d0a7 the registry read installed/.wine-assembly-browser.json
and mounted the exe and its DLLs at C:\ with cwd C:\, so a fresh fetch died at
batch 14 with a C++ throw. eb349d0a7 points unreal_special_demo, ut2003_demo(_server)
and ut2004_demo at the root manifest, with exeGuestPath/workingDirectory set to
c:\system. DLLs found beside the exe now get guest paths beside it, in both run.js and the page.
- ut2004_demo: fresh fetch +
--app, software arm → main menu with 0 throws. - ut2003_demo: its files load now, but the fetched
system/ut2003.inianddefault.iniselectRenderDevice=OpenGLDrv.OpenGLRenderDevice, and-d3ddoes not override them. The result is anAssertion failed: hRCcrash box (OpenGLRenderDevice.cpp:539). The OpenGL choice was not Setup's: the authentic Setup writesD3DDrv.D3DRenderDevice, andtools/install-unreal-demo.jsconfigureLocalRenderer()rewrote it to OpenGLDrv. That rewrite dated from when D3D8 was only a caps facade. After the fix the installer only disables fullscreen. A fresh--forcefetch then writes D3DDrv, and both ut2003_demo and ut2004_demo reach their main menus with 0 throws (scratch/runs/20261011T0010Z-ut2003-fresh-fetch-d3d-ini-w5). Trees fetched before the fix keep the OpenGL INI until re-fetched with--force. - unreal_special_demo: the upstream archive.org 7z returned HTTP 404 on
2026-10-10 because the uploader renamed it to
UnrealSpecialEdition.7z; the bytes and SHA-1 are unchanged. On 2026-10-11,archive.org/download/...also redirected every file of the item todn710701.ca.archive.org, which returned HTTP 500.tools/fetch-candidate-corpus.jstherefore falls back to the item's own servers from/metadata/<item>, tryingd1, thend2, thenworkable_servers. ia801509 crawled at ~20 KB/s, while ia601509 (d1) ran at ~1 MB/s. After the fix, a fresh fetch plus--app=unreal_special_demorenders the intro with 0 throws (scratch/runs/20261011T0120Z-unreal-special-fresh-fetch-w5).
Evidence: scratch/runs/20261010T2335Z-ut2004-fresh-fetch-app-w5.
Unreal Special Edition: headless single-player route (2026-10-01)
(Recovered from branch archive cbfe9895, Oct 2026.) A plain Node route past the SoftDrv flyby, using the stock command-line override:
node test/run.js --app=unreal_special_demo --args='Nyleve.unr?game=UnrealI.SinglePlayer -window' \
--no-threads --quiet-api --no-close --stuck-after=0 --batch-size=200000 \
--tick-ms-per-batch=25 --repaint-every=10 --branch-clock --max-batches=2101 \
--input=1490:click:300:250,1550:di-keydown:38,1550:keydown:38,1750:di-keyup:38,1750:keyup:38,1800:di-keydown:39,1800:keydown:39,1950:di-keyup:39,1950:keyup:39
(The original also pinned --wall-clock-ms=1790673326000; the --input list
is reconstructed from the described route, not copied from its command.)
The click at (300,250) focuses the viewport and fires. Up/Right are the INI's
MoveForward/TurnRight; the route sent both the DirectInput and the window
keydown and was not minimized. Checkpoints: batch 1500 first-person weapon,
100 health, 49 ammo; 1760 YOU GOT A FLARE with inventory icon; 2000 turned
view. The starting room looks like the prison interior, so the URL is not proof
of the loaded map. 7,350,053 API calls, byte-identical PNGs across two builds.
Unreal Special menu labels (2026-10-11, TEST-FILES-OBJECT-ENTRIES)
The menu bar showed raw ID_FileMenu ID_ViewMenu ID_WindowMenu. The menu
resource stores placeholder keys, and Window.dll localizes them at runtime.
The localizer is the function at original VA 0x10b01370, which recurses into
submenus. Its loop runs over GetMenuItemCount positions, last to first:
- It calls
GetMenuItemInfoA(hmenu, pos, TRUE, mii)withfMask=0x14(MIIM_SUBMENU|MIIM_TYPE),cch=0x400. - If
dwTypeDatastarts withID_, it looks the key up inwindrv.int [IDMENU_PlayerCam](for exampleID_FileMenu=&File) and callsSetMenuItemInfoA. - It then recurses into
hSubMenu.
It runs on the LoadMenuA handle before SetMenu. Our Get/SetMenuItemInfo
handled only heap menus and returned FALSE for the 0x00BE resource handle,
and SetMenu reloaded the untouched resource anyway. aeedc00f0 resolves an
unattached LoadMenu handle through its detached alias, and SetMenu attaches an
existing alias. The bar now reads File / View / Window. Evidence:
scratch/runs/20261011T0200Z-unreal-special-menu-labels-w5.
Lazy .int files in the page (2026-10-11, w5; Telegram #30/#31). In the browser, unreal_special_demo crashed at batch 0 with
VfsPendingError: c:\system\core.int ... async-only provider from ini_get_string.
- Unreal's localization tables (
Core.int,Engine.int, …) are INI files that the engine reads throughGetPrivateProfileString, and that read cannot park. - lib/app-files.js's lazy policy streamed them, because
intwas not among its eager config extensions. intis now eager: 18 files, about 35 KB, out of 196 MB of streamed data.- A headless
--lazy-rangesrun reproduces the crash before the change. After it, the run reaches the title flyby ("Press ESC to begin").
UT2003 registered native COMCTL closure (2026-10-13)
An isolated --app=ut2003_demo_server launch asserted in
WControl::RegisterWindowClass, Window.cpp:1070. Targeted API tracing identified
the actual failing GetClassInfoExA(NULL, "SysTabControl32", ...), after three
LISTBOX and two BUTTON superclass registrations. The original Window.dll call
is at VA 0x11018c8e; the tab superclass caller is 0x1101ac67.
The restored installation already contains comctl32.dll and
windows/system/comctl32.dll, both 577808 bytes, SHA-256
28a41e6a35c4509924a32a99841a815cf49e1d3ee6912ec26a823e45472edfa4.
These are preserved installed-fixture files, not newly acquired game payloads.
The local manifest mounts them in the VFS, but native startup discovery uses
the explicit DLL seeds and entry.files, not that expanded manifest. Its host
search from installed/system misses both paths. Both UT2003 registry entries
now explicitly seed the existing windows/system/comctl32.dll.
Candidate a4d487337 loads native COMCTL at 0x11729000, binds Window.dll's
import, and its DllMain returns 1. The original class assertion clears without
an API, INI, or fixture change. This is a dependency correction, not a gameplay
pass: software startup then reports invalid native free list, followed by
the game's LockRect failed: D3DERR_INVALIDCALL in
UD3DRenderDevice::ReadPixels <- Present. The device queue completes 2829
commands with queue error null, but bridge lastError is nonempty. No usable
world or player input was established. Existing SHELL32/OLE32 availability
warnings remain separately unqualified.
Evidence: 20261013T2240Z-ut2003-registered-software-control,
20261013T2245Z-ut2003-registered-class-trace, and
20261013T2247Z-ut2003-registered-comctl-software under scratch/runs/.
All use pinned WASM SHA-256
9b3ef6f173daaa8be90733a4b8449733d74ca861062d0383a709f4be02ce1c77;
the candidate changes registry JS separately, with tracked WAT and renderer
sources unchanged from the preceding 3540d8304 checkout. This does not certify
a fresh current-main build. All owned processes/groups were confirmed absent;
movement/reverse/idle and browser/WebGL/audio/network/FPS remain untested.
UT2003 registered browser startup retest (2026-10-31)
scratch/runs/20261031T0306Z-ut2003-webgl mounted the registered client's
879 original data files and launched its unchanged -d3d -window -nosound
arguments in threaded Chrome. The reviewed webgl-2.png shows the game's own
crash dialog: LockRect failed: D3DERR_INVALIDCALL, with
UD3DRenderDevice::ReadPixels <- Present <- UGameEngine::Draw in its history.
This reproduces the readback failure on a fresh browser run; it establishes
neither a menu/world render nor gameplay progress.
The URL requested WebGL, but the live renderer executor was not independently
attested, so this is not a qualified WebGL backend result. Actual module SHA-256
was 8333a35b1efa694462033e87f62ce4a3f5497941d1423540b39a590c9d31134a;
its compiled source commit is unknown. Observed checkout 016de3e789 is recorded
separately and must not be treated as that module's source identity.
verification.json confirms 881 unchanged original input entries (including
the executable and manifest), 105 valid served-file snapshots, and closure of
the owned browser, profile and server port. result.json, console logs and
worker diagnostics retain the failure baseline. No Boat was used. The next
causal step is to trace the rejected surface, rectangle and lock flags through
the readback call; the dialog alone does not identify which validation failed.
No API behavior or fixture was changed for this run.
The follow-up 20261031T0310Z-ut2003-lock-trace used the same module with
current CLI host code, rather than the browser's frozen host snapshots. Its
60-second software D3D run reached an inspected UT2003/NVIDIA splash
(cli-final.png). GetBackBuffer and GetDesc succeeded. Read-only
LockRect calls used flags 0x10 and identical surface/output/rectangle
addresses on reentry. The trace's alternating raw EAX error/success values
must not be counted as alternating guest-visible failures: the backbuffer
handler initializes EAX to INVALIDCALL, parks for rendering, then re-enters
to finish the call. The CLI recorded 23 render waits. This is not a browser
repair, menu result, or gameplay acceptance.
The original browser console also records WebGL sampler LOD bias/MAXMIPLEVEL is not implemented before the crash dialog. This is a
separate concrete lead; causation between that error and the failed readback
is not established. A console-only metadata observer in
20261031T0315Z-ut2003-sampler-observer preserved the rejecting check but
ended its observation before device creation, capturing no sampler metadata.
Its reviewed final frame is a blank startup window; its browser and server
closed. Capture the rejected texture/sampler state and completed readback
result before choosing a production change. Both follow-ups used local
processes, with no Boat.
The longer observer run 20261031T0320Z-ut2003-sampler-cause ran from
03:18:27 to 03:22:26 UTC with nine captures. The reviewed final frame still
shows a blank original UT2003 window; no rejected sampler metadata was
captured. All 881 original input hashes and 105 frozen host snapshots passed
verification, and the owned browser, profile and server closed. This does
not strengthen the sampler-causation claim. Do not repeat this observer
unchanged; establish that the diagnostic execution reaches the relevant draw
before another sampler capture. No production source changed.
First completed readback failure on exact source (2026-10-31)
20261031T0531Z-ut2003-readback establishes the causal chain on UTorigin's
retained locked build, SHA-256
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8,
with its exact 295-file source/host snapshot, seven compiler files and original
build log. This includes the window-origin repair published as fb698d57e.
It uses neither the unknown-source 8333a35b module nor mixed current-host
CLI evidence. All 881 original entries (879 data files, executable and manifest)
verify unchanged before/after; 107 served snapshots match the retained pins.
The original registered -d3d -window -nosound startup is unchanged.
Unlike the earlier observers, this single serialized native browser execution
reaches device creation, actual draws and the game's original crash dialog
(startup-15.png, personally inspected). The live render worker attests endpoint
1, API neutral, backend webgl, device 0x18721038, generation 1.
This establishes this endpoint's identity, without qualifying gameplay or backend
parity. The capped diagnostic wraps existing WASM import hooks and bridge
methods through CDP/page evaluation; production served source bytes are intact.
The first LockRect is Surface8 0x18832010, DX slot 6, output 0x179ff76c,
rectangle pointer 0x179ff75c containing (0,0,1,1), flags 0x10, return
address 0x11ae7d78. It resolves to the live device's lockable 640×480
backbuffer, pitch 2560, format 22. Source admission succeeds: it captures the
valid output/rectangle and submits backbuffer readback 0x30016 with descriptor
0x014656d4 (device program state 0x11d53004).
At 05:32:47.020 UTC, the initial handler exit has raw EAX 0x8876086c, token
-3, yield reason 16 and unchanged ESP 0x179ff71c: parked, not completed.
At 05:32:47.031, the same call re-enters and polls 0x30007/-3; the completed
request carries QueueError: D3D9 draw: WebGL sampler LOD bias/MAXMIPLEVEL is not implemented. Poll returns -1. At 05:32:47.035, token/yield are zero, ESP is
0x179ff730 (+20), EAX remains 0x8876086c, and the output words are unchanged.
This is the first completed guest failure. d3d9_backbuffer_lock takes its
post-poll result != 1 branch and clears the reserved lock; none of its initial
surface/flag/rectangle/output gates rejected this call.
The rejecting command precedes that readback: DRAW sequence 29 on the same
device/generation, after the contiguous successful prefix 1–28. Its sampler
snapshots have LOD bias -0.5, MAXMIPLEVEL 0, min/mag 2, mip filter 1.
Stage 0 is a 512×512 ten-level 2D image; stage 1 is a 128×128 eight-level cube
image. The retained backend routes used biased 2D stages through
Shader.withMipSampling, explicitly excludes cube images from those stages,
and rejects nonzero bias in ordinary uploadTexture unless the image has one
level and matching min/mag filters. Thus stage 1's multi-level cube satisfies
the rejecting condition; this stage attribution follows from that source path
and captured command metadata. READBACK sequence 48, token -3, inherits
the same poisoned-queue error; readback does not originate it. Later rejected
draw fences are propagation, not additional independently executed failures.
check-cause.cjs passes exact completion/ESP/token/argument/endpoint/sequence
checks and exercises the retained production uploadTexture rejection with
the observed cube metadata. post-failure-state.json records the surviving
surface/device/program state separately: its stack rectangle has already been
reused and must not replace the entry-hook rectangle evidence. The final
05:35 capture shows the game window gone, not a menu or world.
At this checkpoint no source repair was made: this is a concrete unsupported multi-level cube LOD bias path, not an invalid rectangle or a demonstrated small lock-handler bug. Removing the rejection would silently sample the wrong mip; the existing 2D atlas explicitly cannot handle cube sampling. Next work is correct generic cube sampler LOD support with mip-selection pixel regressions, then a matched original startup/menu/play retest. Native DM-Antalus gameplay remains blocked. No guest/assets/clock/startup changes or swallowed errors were used.
The run retains RECOVERY.md, helpers, source/compiler manifests, original
pins, command metadata, closure checks and captures. A harness preflight path
error closed before any guest launch and is separately preserved under
preflight-failure/; it is not a second native execution. Chrome 1599903
exited zero; owned controller/lock holder, HTTP 40325/CDP 36417, profile and
watchers closed. No Boat was allocated (ID/state/expiry N/A); other workers'
runtimes, laptop fonts and Heroes were untouched. Focused evidence checks and
helper syntax pass; no new full build is claimed because production source is
unchanged and the tested module is the exact previously locked build above.
Cube LOD repair and original native DM-Antalus (2026-10-31)
Run 20261031T0542Z-ut2003-cube-lod first reran the predecessor's
check-cause.cjs: the retained DRAW29 cube rejection and inherited READBACK48
error pass the causal checks. The generic repair extends the WebGL mip atlas
and shader lowering to cube images. All six supplied face chains remain
available; sampler bias, MAXMIPLEVEL, resident base LOD, partial-chain clamps,
point/bilinear min/mag filtering and point/trilinear mip filtering use the
existing native-reference policy. Face selection uses X/Y/Z tie order. Quad
helper directions are projected onto the receiving fragment's face before
computing the footprint, preventing artificial LOD jumps across face edges.
Filtering clamps taps within that face. Keyed textures and GPU resource levels
retain their existing caching/revision and feedback checks.
This lowering explicitly requires six square CLAMP faces and a supported atlas size; invalid LOD/filter/chain metadata and missing WebGL1 derivative support still reject. The ordinary upload admission check remains in place: biased sampling needs the corresponding shader lowering. No queue errors are cleared, validation removed, mip chains shortened, assets edited, guest sampler state changed or alternative backend selected.
test/test-d3d9-cube-lod-web.js passes 8,880 actual WebGL1/2 pixel checks
with distinct face, mip and texel colors. It covers fixed/programmed pixel
shaders, stages 0/1, positive/negative/zero bias, MAXMIPLEVEL beyond the chain,
all mip modes, distinct min/mag filters, partial/resident/keyed chains, GPU
resource faces and adjacent lanes crossing a face edge. The same regression
rejects the saved old source at its original LOD error. Existing fixed cube
(48 cases), single-level cube (288), shader/native-IR/2D-atlas and software-mip
tests pass. The optional Node headless-GL partial-mip test skips because its
native dependencies are absent; browser partial cube chains are exercised by
the new regression. flock /tmp/wine-build.lock bash tools/build.sh passes.
The fresh build remains WASM SHA-256
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8
because the repair is in JavaScript. This run retains its own exact 295-file
source/host snapshot, seven compiler files, dirty patch and full build log;
107 served snapshots match those pins. All 881 original input entries
verify unchanged before and after the single native execution. Registered
-d3d -window -nosound startup is preserved. Endpoint 1 is neutral/WebGL,
device 0x18721038, generation 1. A bounded live executor observer additionally
records a real WebGL2RenderingContext, 21,049 successfully completed backend
draws, and original 128×128/eight-level cube samplers with bias −0.5/MAXMIPLEVEL
0 on stages 0–2. It preserves return values/exceptions and is restored afterward.
DRAW29 now completes through sequence 29 with the predecessor's exact cube
sampler state; READBACK48 completes through 48. The identical first LockRect
arguments/rectangle/flags first park on ticket −4, then complete with EAX 0,
token/yield zero, ESP +20 and output pitch 2560/nonzero pixels. Twenty completed
successful locks are retained. check-repair.cjs verifies this transition
against the saved original failure. No bridge rejection/error is recorded;
the final capture's queue has completed through 121100.
Personally inspected captures show the original main menu, Instant Action's
selected DM-Antalus preview, native open DM-Antalus typed into the game's own
console, loading screen, first-person Fire prompt, and spawned HUD. Native
Control (the original Jump binding) joins the match; W/S move, mouse movement
changes the view, and held left mouse fire reduces ammo 150 → 146, health
100 (join-settled.png, forward-settled.png, mouse-fire-settled.png). All
88 recorded native key/button events are trusted. Menu PLAY activation was not
established; gameplay uses the explicitly recorded native console route.
This establishes basic native DM-Antalus movement/look/fire, without an audio,
performance, kill or match-completion claim. No next graphics-operation failure
was observed.
RECOVERY.md preserves replay/cleanup commands and the source/compiler/input
closure. The controller/lock holder unexpectedly ended with status 143 during
final shutdown, before its finalizer; the signal sender is unknown. The owned
Chrome was recovered and closed via its retained CDP endpoint under a reacquired
browser lock, with native input/end pins saved first. All tracked owned PIDs,
HTTP 43345/CDP 34225 and profile are verified gone. No Boat was allocated
(ID/state/expiry N/A); other runtimes and protected files were untouched.
UT2003 frozen SOFTWARE attempt: isolation prerequisite failed (2026-10-31)
20261031T1533Z-ut2003-software-antalus stopped at its first execution
prerequisite, before guest input. It does not close the missing original
SOFTWARE gameplay evidence. The preceding 5fa12b1be/0542Z Antalus run remains
WebGL evidence only; neither run establishes full-27 qualification.
The single browser launched at 15:35:48 UTC after Diablo II's new 15:34:16
FULLRELEASE for runtime 15:24:30–15:32:47, plus an independent actual whole-Chrome,
global crashpad and profile PID/start gate. Free disk was 2,318,245,888 bytes.
The run retains the exact 0542Z 295-file source snapshot, seven compiler inputs
and module SHA-256
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8.
All 881 original files, retained source/compiler/module and 102 pinned responses
served in this execution verify unchanged; all 107 predecessor served pins also
match the frozen closure. No current host source was substituted. The original
registration and -d3d -window -nosound arguments were unchanged. Only the normal
host GPU selector changed to Software before Launch; the guest-worker default
was retained, with a 1024×768 browser viewport.
The first capture (01-startup.json/.png) reports Software selected,
crossOriginIsolated=false, guestWorker=false, despite Threads being checked.
Its inspected NVIDIA intro and toolbar “not isolated” state corroborate that
failure. The actual main-thread bridge has backend/kind software, device
410128440, generation 1, submitted/consumed/completed 85/85/85, no inflight
operations and no queue error; 01-startup-executor.json has no render-worker
executor. These completed startup operations are outside the required default
guest-worker configuration, not qualifying gameplay or a software graphics
failure.
The cause is in this run's harness: its custom frozen-response handler omitted
Cross-Origin-Opener-Policy: same-origin and
Cross-Origin-Embedder-Policy: require-corp. first-dependency-http.json retains
the completed HTTP 200 response without either header. The static server's
crossOriginIsolated: true option applies those headers only to responses it
serves itself; a completed custom response returns earlier. The fallback
isolation-service-worker request was refused as unpinned. The 0542Z driver
explicitly included both headers in its custom responder; this adaptation
accidentally omitted them. This is an identified harness prerequisite failure,
not an established emulator defect. No retry was made. The next attempt must
restore those response headers and assert isolation
and an active default guest worker before guest input, then perform the
prepared ordinary menu PLAY route, allowing its documented no-Present load
period. Menu PLAY remains open; the explicitly labelled native-console
open DM-Antalus fallback was not used here.
Only the host Launch click occurred; no guest movement/look/fire, health/ammo/
clock progression, audio, FPS, benchmark or match-completion claim follows.
The controller cooperatively quit at 15:36:27. Durable Python Popen.wait()
receipts record Chrome/controller/wrapper/monitor exit 0; the monitor sent no
signals. Three PID/start-qualified holders retained FD9 on
/tmp/wine-browser.lock during runtime. Cleanup verifies all owned processes
and crashpads absent, both ports closed, profile gone, held inputs empty and
the full flock available. FULLRELEASE was posted at 15:37:07. No Boat was
allocated (ID/state/expiry N/A). RECOVERY.md, verification.json and
focused-check.json preserve the precise prerequisite, identity and cleanup
checks. No production files changed.
UT2003 isolated SOFTWARE Antalus entry: disk stop before join (2026-10-31)
20261031T1543Z-ut2003-software-isolated repairs the preceding harness
omission in a new scratch helper only. Both COOP same-origin and COEP
require-corp are set before every custom-response branch, including rejected
unpinned URLs. Actual HTTP checks of HTML, host JS, WASM and a custom 404 retain
both headers. Before any guest input, firstlaunch-gate.json verifies
crossOriginIsolated=true, wine.guestWorker=true, Threads enabled, Software
selected and a 1024×768 viewport. Every subsequent completed action rechecks
isolation, worker and backend. The original 0542Z/1533Z frozen sources remain
unchanged.
This single execution uses the exact 0542Z module SHA-256
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8,
295-file source snapshot and seven compiler inputs. All 881 original inputs,
107 predecessor served pins and this run's 107 served pins verify unchanged
before/after. Registration and -d3d -window -nosound remain original; only
the normal host selector changes to Software. Read-only executor inspection
finds an actual software Device, its native software exports, accumulated
completed samples and gpu=false; no draw/input wrappers are installed.
Inspected captures show NVIDIA startup, the main menu, native console and
DM-Antalus with “Press FIRE to start!” / “Press [Fire] to join the match!”
(21-antalus-load-settled.png). Menu navigation did not establish Instant
Action or PLAY; those remain open. Entry explicitly used the ordinary native
console: Backquote, trusted keyboard typing open DM-Antalus, then Enter.
Captures immediately after input lagged the settled display; the typed-command
capture is partial, while the later Antalus view establishes map entry. A
logged .PAG <- .PAX C++ throw during loading was followed by that rendered
map, so it does not establish a terminal guest failure. The last bridge
snapshot completes 12,389 / 12,391 submitted operations, with no queue
error; remaining work is pending, not a completed graphics failure.
The first unmet continuation prerequisite is free disk. Prelaunch had 2,311,340,032 bytes free. At 15:48:45 UTC the monitor observed 2,093,572,096 bytes, below the mandated 2.1 GB early-stop threshold, and cooperatively quit. No deletion or retry was attempted. The requested native join and following capture timed out after shutdown and are unexecuted; there is no spawned HUD, inspected movement/look/fire, or health/ammo/clock progression evidence. This run closes the isolation prerequisite and proves Software map entry, while the SOFTWARE gameplay gap and full-27 qualification remain open. The preceding 0542Z success remains WebGL evidence only.
Runtime 15:43:37–15:48:47 followed both predecessor FULLRELEASE records and an
independent actual whole-Chrome/global-crashpad/profile PID/start gate. The
wrapper/controller/monitor inherited FD9 for the full browser lifetime; Python
Popen.wait() receipts record exit 0, and the monitor sent no signals. Cleanup
verifies all owned runtime processes absent, both ports closed, profile removed,
inputs balanced/released and the full flock available. FULLRELEASE was posted
at 15:50:01. No Boat was allocated (ID/state/expiry N/A). RECOVERY.md,
verification.json, focused-check.json and the saved cleanup audit retain
the bounded result. No production source, assets, INI, clock, save bytes or
guest memory changed. Next work needs enough disk for a fresh bounded run,
then native join and inspected gameplay under the same proven configuration.
SOFTWARE join follow-up: launch reserve unavailable (2026-10-31)
20261031T1603Z-ut2003-software-join stopped before browser launch at the
requested disk prerequisite. The required new Diablo II FULLRELEASE arrived
at 16:03:08 UTC for its sole 15:51:57–16:01:44 execution. At 16:03:23, an
independent process/PID-start scan under an exclusive FD9 browser flock found
no actual Chrome or global crashpad processes and confirmed the predecessor
profile absent. Free disk was 2,542,460,928 bytes, 57,539,072 bytes short
of the required 2,600,000,000-byte prelaunch reserve. The saved
post-predecessor-gate.json records that first dependency. No browser retry,
guest input, queued join or gameplay capture occurred, and no existing evidence
was removed.
Cheap preparation verifies the exact 0542Z module
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8,
295 frozen source files, seven compiler files, 881 original inputs and 107
predecessor served pins. New scratch helpers retain the repaired custom
COOP/COEP responses, isolation/default-worker checks before guest input,
1024×768 viewport, original -d3d -window -nosound registration and normal
Software selector. Helper syntax and focused prerequisite checks pass; this
is preparation evidence only. No production files changed; no Boat was
allocated (ID/state/expiry N/A).
The next execution requires the disk reserve, a fresh sole-browser release
gate and the same frozen identity. Use the authorized native console
open DM-Antalus, then ordinary FIRE to join and inspect the actual HUD,
movement/look/fire and health/ammo/clock response. Software gameplay remains
unverified, and menu PLAY remains open. The preceding WebGL gameplay and
Software pre-join screenshot do not supply those missing observations.
SOFTWARE join and native gameplay verified (2026-10-31)
20261031T1612Z-ut2003-software-join-reserve closes that bounded Software
gameplay gap. Personally inspected 12-antalus-settled.png shows original
Antalus and Fire-to-join after ordinary Backquote, typed open DM-Antalus,
and Enter. Native left click (350,430) starts the countdown in frame 14;
15-joined-settled.png shows the joined weapon/crosshair HUD, health 100
and ammo 150. No menu PLAY attempt was repeated; that issue remains open.
Native W held 2,200 ms moves from the overlook onto the lower path in
17-forward-settled.png. Mouse motion to (430,400) in eight steps turns
the view toward the rock wall (19-look-settled.png). A 2,300 ms native
left-button hold reduces ammo 150 → 148 (21-fire-settled.png); health
stays 100. Native F1 opens the scoreboard, identifying DeathMatch in
Antalus, frag limit 25, player score/deaths 0/0, and elapsed time 00:24
(23-scoreboard.png). A later inspected capture shows 00:33
(24-scoreboard-clock-later.png). The ordinary HUD has no visible countdown
clock; these are the native scoreboard's elapsed-time readings. F1 dismisses
scores, and S held 1,800 ms moves backward in 27-final-gameplay.png,
still health 100/ammo 148. No damage, enemy-hit, kill, FPS, audio, match
completion or full-27 qualification is claimed.
This uses exact0542Z WASM SHA-256
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8,
295 frozen source files, seven compiler files, 881 original inputs and
107 served pins, verified before/after. Original -d3d -window -nosound
registration is unchanged. The normal host selector alone chooses Software;
the repaired custom COOP/COEP responder and first-input isolation/default
guestWorker gates pass, with the browser consistently 1024×768. Actual
Software Device inspection finds gpu=false, native software exports and
completed samples advancing from 199,850,535 at the joined HUD to
301,598,102 at final gameplay. Final queue evidence records 25,202
completed / 25,220 submitted, error null and empty bridge lastError;
18 pending operations are not completed failures. All sampled queues have
no error. The load-time .PAG <- .PAX diagnostic was followed by the
inspected match. No draw/input wrappers, guestworker disable, validation
removal, current-host mixing, asset/INI/clock/save/memory edits or cheats
were used.
The fresh whole-Chrome/global-crashpad/profile PID/start gate ran under
exclusive lifetime FD9 after Diablo FULLRELEASE16:03:08. The 2.8 GB
prelaunch assertion passed; the first monitor sample, before profile PIDs
appeared, had 2,968,604,672 bytes free. Minimum sampled free space was
2,701,918,208 bytes, above both the 2.1 GB stop and 2 GB floor. The
browser ran 16:12:10–16:16:11 UTC, within fresh 17/18/19-minute bounds.
Python actual Popen.wait() receipts record wrapper/controller/monitor exits
zero, and the Chrome exit receipt records zero; no monitor signals were sent.
Cleanup verifies owned PID/start identities absent, both ports closed,
profile removed, inputs released and full flock available. 63 trusted
balanced native events, 17 PNGs, frozen identity and focused evidence
checks pass. No production files changed, public deployment or Boat
allocation occurred (ID/state/expiry N/A). RECOVERY.md, verification.json,
focused-check.json and saved cleanup receipts retain this completed
execution; predecessor unexecuted join requests remain unexecuted.
Original visible menu PLAY reaches SOFTWARE gameplay (2026-10-31)
20261031T1628Z-ut2003-native-menu-play closes the remaining ordinary
menu-to-gameplay gap in one fresh bounded browser execution. This is separate
from the completed console route in 950e4940e; no console was opened or
command typed in this run. No generic emulator defect was demonstrated and
no production code changed.
Cheap inspection first distinguished native routing, the shared DirectInput
ring, guest execution and graphics completion. The frozen renderer's existing
onInputTrace hook records routing without a wrapper; read-only worker
inspection records registers, RPC counters and the ring at the base supplied
by that frozen RegionMap. The guest's di_mouse_event_take advances its
head. A drained edge proves emulator consumption, not acceptance by a
particular Unreal widget. The historical no-Present loading interval above
remains relevant: the menu picture alone cannot diagnose activation failure.
Personally inspected captures show the original intro, main menu and
Instant Action | Select Map, DM-Antalus (10-map-page.png). Native click
(350,538) selects Instant Action; Enter opens it. After hover at visible
PLAY (637,663), native left down/up held 1,200 ms is recorded as action
13. Both edges route to game hwnd 0x10005, with dispatched=1 on down and
matching DOWN on up. The DirectInput head/tail progresses 46/46 → 46/47 →
47/47 → 47/48 → 48/48, and the Windows input queue drains. PLAY's normal
help text appears in 14-play-progress-12s.png; that capture still retains
the menu while guest EIP/RPC counters progress. The .PAG <- .PAX diagnostic
at 16:33:46 UTC precedes the next Enter (16:33:50). Enter (action 15)
and another native click on the established PLAY tooltip (17, 16:34:18)
were also completed during this interval. These extra inputs are preserved;
this run does not attribute joining to one particular press.
By 16:34:39, 18-play-loading-progress-20s.png shows "The match has
begun!", joined weapon/crosshair HUD, health 100 / ammo 150. This is
original menu gameplay, not an inference from queued commands or an unchanged
menu frame. W 1,800 ms, mouse motion to (430,400) in eight steps, and S
1,800 ms complete; inspected frames 22/24/30 show changed views. A native
left-button hold 2,300 ms produces ammo 148, health 100 in
24-fire-settled.png. Native F1 shows AVERAGE DeathMatch in Antalus, six
scoreboard rows including Player and bots, frag limit 25, and remaining
time 14:46 → 14:42 (26-scoreboard-clock.png,
27-scoreboard-clock-later.png). No player hit, kill, audio, FPS, match
completion or full-27 qualification is claimed. The observed continuation
resolves the visible-menu failure report without a speculative source fix.
Exact0542Z module SHA-256 remains
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8.
All 295 frozen source / seven compiler / 881 original inputs / 107 actual
served pins and 107 predecessor served pins verify unchanged. The original
-d3d -window -nosound registration, normal Software selector,
defaultViewport:null, stable 1024×768, default guestWorker and isolation
are retained. Actual HTTP 200 and custom 404 responses have COOP same-origin
and COEP require-corp, asserted before guest input. The real executor is a
Software Device with gpu=false, native software exports and completed
samples 137,600,200 → 192,718,184 between frames 18 and 30. Final queue
12,159 completed / 12,188 submitted has error null; every sampled bridge
lastError is empty. The 29 pending operations are not failed completions.
There were no draw/input wrappers, forced menu enablement, guestworker disable,
input bypass, current-host mixing, asset/INI/save/memory/clock edits or cheats.
Launch 16:31:24 UTC followed the required NEW Diablo2 den-route FULLRELEASE
16:31:03, for sole runtime 16:17:54–16:30:23, plus independent actual
whole-Chrome/global-crashpad/profile PID/start scans and the lifetime FD9 gate.
The 2.6 GB prelaunch reserve passed; minimum sampled disk was
2,677,112,832 bytes. All 246 active profile samples show wrapper,
controller and monitor holding FD9. Explicit quit ended Chrome/controller at
16:36:08, within target 16:48:24, hard 16:49:24, cleanup
16:50:24. Durable Python Popen.wait() receipts record wrapper/controller/
monitor zero; Chrome exits zero and the monitor sends no signals. Cleanup
checks all owned PID/start identities and helpers absent, both ports closed,
profile gone, inputs empty and full flock available. No watcher was launched.
FULLRELEASE was posted 16:36:32. 25 focused checks, 59 trusted balanced
native events, 32 PNGs, helper syntax and document diff checks pass.
RECOVERY.md, cheap-inspection.json, input-state.jsonl, focused-check.json
and saved cleanup preserve the exact route and its limits. No Boat was
allocated (ID/state/expiry N/A), no build was needed for this docs-only change,
and no further browser, heavy CLI, deployment, worker or successor was launched.
Original visible menu WebGL arm: prelaunch reserve dependency (2026-10-31)
Run 20261031T1642Z-ut2003-webgl-native-menu prepared the matching ordinary
visible-menu WebGL arm; no browser, guest or native input was launched.
The accepted 62ee90c86 SOFTWARE result above remains unchanged. This run
adds no WebGL gameplay or input-failure claim and demonstrates no generic
emulator defect. No production source changed.
The required NEW Diablo2 unexplored-den FULLRELEASE at 16:48:03 UTC,
for sole runtime 16:40:02–16:47:00, arrived before the independent gate.
At 16:48:21, the actual whole-Chrome/global-crashpad PID/start scan and
active-profile scan were clear under exclusive FD9 on
/tmp/wine-browser.lock. Free disk was 2,798,702,592 bytes, below the
required 2,800,000,000-byte prelaunch reserve by 1,297,408 bytes.
This is the first concrete dependency; no launch, retry, evidence removal,
foreign signal, console route or speculative source repair followed. The
older UT and Diablo releases were not used as authorization.
Cheap preparation verified the immutable exact0542Z module SHA-256
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8,
295 matching frozen source files, seven compiler files, 881 original inputs
and 107 predecessor served pins retained through the accepted 1612Z/1628Z
closure. There are no new served pins, HTTP launch assertions, completed
WebGL operations or screenshots in this unlaunched run. The scratch-only
controller was prepared for the normal WebGL selector, default guestWorker,
actual HTTP isolation headers, stable 1024×768/defaultViewport null, native
visible-menu input and read-only inspection of endpoint-owned devices and
receiver completion streams. Preparation is not execution evidence.
RECOVERY.md, first-dependency.json, independent-prelaunch-gate.json,
predecessor-releases.json, verification.json and focused-check.json
preserve the dependency and cheap checks. Helper syntax, frozen identities,
no-runtime checks and documentation diff checks pass. No build, heavy CLI,
public deployment, worker/agent/successor or Boat allocation occurred
(ID/state/expiry N/A). Ownership and the transient gate lock are released.
Next work requires sufficient sustained disk reserve and a fresh serialized
ordinary-menu WebGL execution with actual completed executor/gameplay evidence;
this run does not close that backend arm.
Original visible menu WebGL gameplay completed (2026-10-31)
Run 20261031T1653Z-ut2003-webgl-menu-execution completes the requested
WebGL backend arm in one original ordinary-menu execution. This adds
backend coverage for UT2003, not another title. The coordinator's revised
2.6 GB launch reserve replaces the preceding run's 2.8 GB gate; no evidence
was deleted. No production code changed or generic emulator defect was found.
Personally inspected captures follow the original NVIDIA intro, main menu,
Instant Action / selected DM-Antalus (09-map-settled.png), visible PLAY
(12-play.png), actual Antalus loading (13-loading.png) and native Press
[Fire] to join (15-loaded.png). Click (350,538) plus two Enter presses
opened Instant Action. After hover, PLAY (637,663) received a native
1,200 ms down/up; no extra Enter or click was sent during map loading.
Fire-to-join (350,440) produced 17-joined.png: The match has begun!,
weapon/crosshair HUD, health 100 / ammo 150. Native W 1,800 ms moves
into the arena (19-forward-settled.png); mouse motion to (430,400) in
eight steps changes the view as it settles (21-look-settled.png through
23-fire-settled.png). A native fire hold 2,300 ms reduces ammo to 149,
health stays 100. S 1,800 ms moves backward (29-final.png). Native
F1 shows Player and five bots in AVERAGE DeathMatch in Antalus, frag limit
25, with remaining time 14:51 → 14:48 (25-clock.png,
26-clock-later.png). No hit/kill, FPS, audio or match-completion claim follows.
Read-only CDP inspection traverses the actual render endpoint's adapter and
receiver closures. Endpoint 1, neutral/WebGL, owns device 410128440,
generation 1. Both the D3D device and its GPU object match the frozen
WebGL constructors; the real WebGL2RenderingContext is not lost. The
640×480 drawing/presentation buffer is distinct from the 1024×768 browser
viewport and 684×570 desktop canvas. Chrome uses ANGLE SwiftShader; this
establishes the WebGL API route without a hardware-GPU claim. The final
receiver has sequence 19,248, pending 0, failed false. Frozen
adapter/receiver source confirms completion follows actual executor return,
not queue submission (executor-provenance.json). The later page snapshot
records 19,283 completed / 19,284 submitted, error null and empty bridge
lastError; the remaining pending command is not a failed completion. There
are no draw or input wrappers.
The unchanged exact0542Z WASM SHA-256 is
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8.
295 frozen source/host files, seven compiler files, 881 original inputs,
107 predecessor and 107 actual served pins pass before/after verification.
Original -d3d -window -nosound, normal WebGL selector, default guestWorker,
defaultViewport:null and stable 1024×768 are retained. Actual HTTP responses,
including a custom 404, carry COOP same-origin and COEP require-corp;
isolation/default-worker checks precede all guest input. No console, asset,
INI, save, guest-memory or clock edits, cheats or worker bypass occurred.
Launch 16:52:57 UTC followed NEW Diablo FULLRELEASE 16:48:03 for sole runtime 16:40:02–16:47:00 and independent entire actual Chrome/global crashpad/profile PID/start scans, repeated under lifetime FD9. All 261 active profile samples show wrapper/controller/monitor holding that lock. Minimum free disk 2,521,784,320 bytes stays above the 2.1 GB early-stop threshold. Atomic temp-file/rename command handoff avoided partially parsed JSON. One request helper timed out waiting for action 14; the controller subsequently recorded that action's successful completion before the next command. All 30 issued commands completed, including explicit quit at 16:58:02. Chrome/controller/wrapper/monitor exit zero, with no monitor signals. Actual PID/start-qualified cleanup confirms owned helpers absent, both ports closed, profile gone, held inputs empty and full flock available. NEW FULLRELEASE was posted 16:58:19 for the waiting successor.
24 focused checks, 40 trusted balanced native events, 30 PNG signatures/
hashes, helper syntax and documentation diff checks pass. RECOVERY.md,
focused-check.json, commands.jsonl, completed-commands.jsonl, executor
snapshots and cleanup receipts preserve the execution. No build was required
for this documentation-only change; no further browser, heavy CLI, public
deployment, agent or worker was launched. Boat ID/state/expiry are N/A.
UT2004 explicit CLI renderer startup check (2026-10-31)
Run 20261031T0327Z-ut2004-startup reached an inspected black game window
and logged 43,060 D3D9 requires a GPU window messages. This command omitted
--d3d9-renderer=software: the CLI defaults to WebGL unless the registration
opts into software, and this invocation provided no GPU context. This is a
route prerequisite failure, not evidence of a new guest defect.
The corrected original-input run 20261031T0330Z-ut2004-software selected
software explicitly and reached an inspected NVIDIA intro frame. It exited
zero at the 45-second limit (405,812 batches, 45.107 seconds), without those
GPU-window errors or a crash signature. Both runs used --no-build --no-threads --quiet-api --quiet-blocks --max-seconds=45 --max-batches=1000000 --stuck-after=1000000 --no-close; their result records
retain the exact commands. All 998 original-input hashes and four module/host
file hashes remained unchanged across both runs. Module 7f9da4e9da5183e9f7f061d2356cd34626fe74bdbaf7da0345f6693dd81152be
has unknown compiled-source identity. Both runner sessions ended; no browser,
server or Boat was created. These startup observations do not qualify menu,
input, gameplay or software/WebGL parity. No production source changed.
The live-control follow-up 20261031T0337Z-ut2004-live-input delivered
Escape down/up at batches 29,431/29,432 rather than relying on an unreachable
batch schedule. At its 120-second guard (432,213 batches, 119.980 seconds),
the inspected final frame showed the original animated title background with
a scrolling game-mode strip. Earlier captures showed a blank startup window.
A second Escape was also delivered; this evidence does not isolate which
input caused the transition or establish menu interaction or gameplay. All
998 original inputs and four module/host hashes remained unchanged, using the
same 7f9da4e9 module with unknown compiled-source identity. The runner exited
zero and loopback control port 18127 closed; no Boat was used. Exact command,
snapshots, input replies and validation remain in the run folder.
UT2004 original DM-Rankin movement/fire retest (2026-10-31)
Run scratch/runs/20261031T0427Z-ut2004-match/ reached an inspected,
playable original DeathMatch through the registered title/menu route. The
software CLI ran 8,425 batches in 636.949 seconds and exited zero. This is
fresh gameplay evidence; the September route above remains a historical
control, and the earlier October CLI title result alone did not qualify it.
Personally inspected captures:
38-after-enter.png: textured DM-Rankin with Press [Fire] to join the match!.44-player-hud.png, batch 8,185: assault rifle, health 100, ammo 100, clock 19:59, and The match has begun!; bot entry messages are visible.45-forward.png, batch 8,265: position changed from the ramp into the adjacent brick/concrete corner after ordinary W down/up at 8,185/8,245.46-fired.png, batch 8,330: bullet marks/ejected cases and ammo 96 after normal viewport mouse down/up at 8,265/8,315. Subsequent ammo reached 94.47-retreat-look.png, batch 8,400: changed position/view after S down/up at 8,330/8,380 and relative mouse motion90,-40. Clock reads 19:54.
These readable world/HUD images establish ordinary player movement, look and fire. No enemy hit/kill or completed match is claimed. An additional short press at 8,400/8,415 did not establish another shot before the final capture. This does not qualify browser Worker operation, WebGL parity, audio or real-time performance.
Route and input recovery
launch.json preserves the exact invocation: registered --app=ut2004_demo,
unchanged -d3d -window -nosound, --no-build, retained --wasm,
--no-threads --d3d9-renderer=software, --batch-size=200000,
--tick-ms-per-batch=25, --frozen --control=18128, quiet API/block logs,
--trace-input-dispatch, and a 900-second internal guard. No asset, INI,
guest state, or production source was patched.
Startup was inspected before Escape, and the menu was inspected at batch
2,475. The default host capture clipped the window bottom; the existing
canvas-resize:800:600 input expanded the capture. Instant Action was reached
using native menu navigation/Enter; the Gametype page was inspected at 3,620.
Normal mouse down/up at (195,214) selected DeathMatch, and the Select Map
page showed the original DM-Rankin by batch 4,050.
Do not replay old coordinates/timing blindly. Current read-only geometry was
outer window (20,20,648,488), client (24,44,640,460). The visible PLAY
label was around (450,494), but clicks there did not establish activation.
After the historical relative-mouse sync (move to client origin, step; move
to (300,300), step; move to target, step), target (450,514) with a
DirectInput button hold highlighted PLAY. Enter down/up at 7,752/7,803 was
also delivered. The join prompt was inspected at 7,849; the evidence does
not isolate whether Enter was necessary or loading was already proceeding.
No input-mapping production defect is diagnosed from this sequence.
Loading retained the menu image while sampled Engine addresses and batches
advanced. A read-only SEH walk was finite, without the historical self-cycle.
Those stale menu captures were not sufficient to diagnose rendering failure.
The normal viewport mouse down/up at (340,280), batches 8,005/8,065,
triggered the join countdown. The preceding DirectInput-only button hold
at 7,904/7,954 had not joined. Use normal mouse input for this recovered
route. Full commands, actual replies and dispatch observations are in
input-log.jsonl/runtime.log; RECOVERY.md explains bounded stepping and
cancelling an outstanding step before issuing another. Several exploratory
step requests were deliberately cancelled; one overlapping step was refused.
Identity, checks and cleanup
The original executable remains SHA-256
2a95e2fa8c22ae94eb1c361fdb49ea8ec44c5e2a93faa00831308c01e951db8d.
All 998 original inputs matched the earlier original manifest; all
1,283 pinned input/runtime/source files passed the after-run comparison.
All 39 PNGs passed signature/hash checks. The live backend reported
software, with no bridge error at the sampled player frame.
Module SHA-256 was
8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676,
matching the retained ReVolt locked after-build module. Its 292-entry source
manifest had zero current drift (module-provenance.json). Observed initial
checkout 849d6a527 is recorded separately; it is not asserted to be the
compiled module's source commit. No rebuild or source repair was needed.
Before launch, process inspection found no active game Chrome/CLI runtime;
the previous Deus Ex runtime had ended. /tmp/wine-browser.lock serialized
the entire CLI lifetime. Explicit quit left owned runtime 1524823 and
controller 1524815 absent, control port 18128 closed, and exit status zero
(cleanup.json). The waiting Forsaken worker acquired the released lock;
its processes were not touched. No browser, server, Boat or test box was
created; box ID/state/expiry are N/A. Free disk stayed above 2 GB (about
4.5 GiB at cleanup). Next useful extension is a separately serialized default
Worker browser replay of this inspected native route; no successor launched.
UT2004 original default Worker browser gameplay (2026-10-31)
Run scratch/runs/20261031T0451Z-ut2004-browser/ qualifies the original
registered demo in the default guestWorker browser, with the software
renderer. Personally inspected browser screenshots show:
deathmatch-windowed-origin-result.png: DeathMatch maps, original DM-Rankin.rankin-load-progress2.png: textured Rankin and the Fire-to-join prompt.player-hud-first.png: assault rifle, health 100, ammo 100, and The match has begun! after an ordinary viewport mouse press.native-forward-settled.png: the player advanced down the corridor after native W down/up held 2,200 ms.native-fire-settled.png: ammo 99 after a native left-button hold;native-look-settled.pngsubsequently shows 98, with a changed view after native mouse motion from(340,400)to(430,360).native-retreat-settled.png: the player retreated to the doorway after native S down/up held 2,200 ms; health remains 100, ammo 98.
player-hud-workers.json and final-gameplay-workers.json record a running
ut2004_demo with guestWorker: true, an instantiated guest Worker, and a
live render endpoint whose options specify backend: "software". The page
host bridge independently reports software with lastError: null. This is
actual browser transport/gameplay evidence, beyond the earlier CLI result.
It does not qualify WebGL, audio, throughput, enemy hits/kills or completion.
Native route and presentation limitation
The registered executable, DLLs, manifest and -d3d -window -nosound
arguments were unchanged. Escape reached the title. Tab/Enter selected
Instant Action; early uncalibrated pointer attempts selected Assault.
Ctrl+Shift+Tab returned from Select Map to Gametype, where a calibrated
ordinary mouse press selected DeathMatch and the original DM-Rankin page.
PLAY was selected by native mouse, loading was inspected, then a normal
viewport left-button hold joined. commands.jsonl, screenshot-side JSON and
native-input.json preserve commands and trusted key/button events. Capture
names describe intended actions; only inspected outcomes above are claims.
There is a measured 24-pixel horizontal / 44-pixel vertical presentation
offset in this pinned default Worker software route. Menu headers and the
upper/left HUD are cropped, while the world, weapon, health and ammo remain
readable. Native pointer targets needed the visible position plus (24,44):
DeathMatch (204,380), PLAY (459,674). These are calibrated browser input
coordinates, not a guest-state or startup-route patch.
The first cause is recorded in presentation-geometry-workers.json and
presentation-owner-state-eval.json. The live guest instance reports
get_d3d9_windowed_hwnd() == 65541, with client origin (24,44). The page
presentation owner's hostCtx.exports reports windowed hwnd 0 and main
hwnd 0, but shared get_dx_present_hwnd() correctly finds 65541;
the render Worker also reports windowed hwnd 0. In the frozen
lib/host-imports.js, _presentDxSurfaceToMainWindow consequently starts
the surface at screen (0,0), then clips it against the correct client
rectangle. The surviving source starts at (24,44), explaining the lost
headers and input offset. No production repair was attempted. The narrow
next repair is to carry the windowed device origin to the page presentation
owner, with a focused default Worker/software regression, then repeat the
same original route. Retained menu frames during loading were separate:
execution/RPC observations advanced before the world appeared.
Frozen identity, checks and cleanup
Module SHA-256 remains
8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676.
The browser served the matching ReVolt0403Z 292-file source-after snapshot,
including host bytes; observed checkout 08b6288f2 is recorded separately
and is not its compiled-source identity. All 998 original inputs, all
292 retained source files and 107 served snapshots passed before/after
or retained-byte comparisons; all 106 PNGs passed signature/hash checks.
The original EXE remains SHA-256
2a95e2fa8c22ae94eb1c361fdb49ea8ec44c5e2a93faa00831308c01e951db8d.
Unpinned application code was refused; optional /build-info.js returned
404. Font-substitution bytes were separately frozen and hashed. No assets,
guest memory, production code or registry entries were changed; no build
was required for this documentation-only result.
Chrome 151.0.7922.108, headless at 1024x768, used a loopback isolated
server; the default Threads setting was untouched. The runtime lock and
process gate serialized launch after Deus Ex closed. At shutdown the
controller 1555850 unexpectedly exited 143, with finalizer unfinished;
its cause is unknown. Chrome 1555861 remained alive. Explicit delegated
cleanup re-acquired the lock and used CDP Browser.close; both PIDs were
then absent, HTTP 33513 and CDP 42377 closed, and the owned profile
and watcher were removed/stopped. The waiting Pirates process gate refused
the orphan interval, so no overlapping game runtime started. Cleanup and
verification JSON preserve this limitation rather than claiming a clean
controller exit. Free disk was about 4.4 GiB. No Boat/test box was
allocated; box ID/state/expiry are N/A. The bounded task finished within
30 minutes and launched no successor.
UT2004 windowed presentation origin repair (2026-10-31)
Run scratch/runs/20261031T0514Z-ut2004-origin/ repairs the measured
default guestWorker/software origin loss and repeats the original DM-Rankin
route on a freshly built, matched candidate. Personally inspected
deathmatch-visible-result.png shows the complete Instant Action | Select
Map header and tabs. Native clicks at the visible DeathMatch label
(204,380) and PLAY label (459,674) selected DeathMatch/DM-Rankin and
started loading. Those labels now occupy those positions; no additional
(24,44) pointer correction was used. An early title-pointer attempt opened
Join Game; ordinary Escape and Shift+Tab/Enter returned to Instant Action.
The settled map-page clicks, rather than that early attempt, establish the
pointer/presentation alignment.
rankin-loading-3.png shows the original world and Fire-to-join prompt.
After normal viewport Fire, player-hud-first.png shows the complete top
HUD, including clock 19:58, health 100, ammo 100, and The match
has begun! Native W advanced along the corridor
(native-forward-settled.png); a native left-button hold reduced ammo to
98 (native-fire-settled.png). Mouse motion (340,400) to (430,360)
changed the view (native-look-settled.png), and S returned to the doorway
(native-retreat-settled.png). The final frame retains the full clock/score
area, health 100 and ammo 98. No WebGL, audio, throughput, enemy
hit/kill or match-completion qualification is claimed.
Cause and ownership
Before production edits, current main still declared
$d3d9_windowed_hwnd as an instance-local mutable global in
src/09ad-handlers-d3d9.wat; CreateDevice and Reset wrote it and the exported
getter read it. The page compositor correctly resolved shared window 65541,
but could not observe that device state. Its existing client clipping then
discarded source pixels (24,44), exactly as the earlier frozen evidence
showed. That frozen module is a historical comparison, not current-build
acceptance.
The authoritative windowed HWND now occupies atomic word +32 of the
existing shared DX_PROCESS_STATE. Successful CreateDevice and committed
Reset publish the windowed HWND, or zero for fullscreen. All WAT readers and
get_d3d9_windowed_hwnd read that same shared word. The region grows from
32 to 48 bytes, with the generated JS layout updated. Guest, page and render
Worker instances already share this memory, so no extra JS state or message
protocol is needed. lib/host-imports.js remains byte-unchanged: its existing
getter-based distinction still places DirectDraw primaries in screen
coordinates and explicitly windowed D3D at the device client origin.
Live final-owner-state-eval.json reports page windowed HWND 65541,
page main HWND 0, shared target 65541, client origin (24,44),
software backend and no bridge error. final-gameplay-workers.json confirms
default guestWorker and an actual software render endpoint; guest and render
instances both read windowed HWND 65541.
Regression, identity and cleanup
test/test-d3d-windowed-origin-worker.js creates a real D3D device and uses
separate guest/page/render WASM instances over shared memory. It checks the
page's local main HWND remains zero, the shared target is nonzero, both
client-edge pixel markers survive, chrome remains transparent, and fullscreen
clears the shared windowed state. The identical regression rejects saved
pre-edit production source with page getter 0, expected 65541
(reject-old-final.log), and passes the repair. The initial fixture omitted
its window record and failed earlier; before-regression.log is retained
but is not the intended old-source rejection. Existing DirectDraw placement,
GPU layer origin, browser Worker presentation and direct/Worker D3D Reset
regressions pass. Full flock /tmp/wine-build.lock bash tools/build.sh
passes (build-final.log); no broad suite or benchmark was substituted.
The tested module is SHA-256
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8.
The loopback browser served this build with 295 frozen current source/host
files, a retained compiler manifest and the dirty shared-checkout diff.
Observed checkout is recorded separately from compiled-source identity.
All 998 original inputs, 295 retained source files, 107 served
snapshots and 34 trusted native key/button events passed checks;
all 48 PNGs, including the explicitly historical comparison, passed hash and
signature checks. No executable, asset, argument, font, guest-state or clock
patch was applied; no public deployment occurred.
Chrome 151 at 1024x768 ran from 05:17 to 05:25 UTC under the full-lifetime
browser lock, after the prior Pirates browser closed. Explicit quit exited
Chrome 1583479 zero; controller 1583452, holder 1583451 and owned
crashpad processes were absent, HTTP 45739 and CDP 36791 closed, and
the profile was removed (cleanup-verified.json). The board watcher was
also stopped. Free disk remained above 2 GB (about 4.2 GiB at cleanup).
No Boat/test box was allocated; ID/state/expiry are N/A. The repair and
original software browser route are verified; other backends remain separate
work if requested.
UT2004 original default Worker WebGL gameplay (2026-10-31)
Run scratch/runs/20261031T0629Z-ut2004-webgl/ supplies the missing
WebGL arm on current main containing the window-origin and cube-LOD
repairs. One original startup followed visible title → Instant Action →
DeathMatch → DM-Rankin → PLAY → Fire-to-join. An early Escape opened the
ordinary quit prompt; Escape canceled it before successful menu selection.
Native clicks used visible Instant Action (410,522), DeathMatch
(204,380) and PLAY (459,674), without an added coordinate offset.
gametype-settled.png, deathmatch-map.png and rankin-loading-5.png
were personally inspected; the last shows the textured world and native
Fire-to-join prompt, rather than retained loading backing.
Personally inspected player-hud-first.png shows full clock 20:00,
health 100, ammo 100, weapon and The match has begun! Native W
held 2,200 ms advances up the ramp (native-forward-settled.png, clock
19:56). A 2,300 ms left-button hold reduces ammo to 99, then 98 as
the queued input settles. Native mouse motion (340,400) → (430,360)
changes the view toward the ceiling and right-hand room
(native-look-settled.png, clock 19:52, health 98/ammo 98). Native S held
2,200 ms moves backward (native-retreat-settled.png, clock 19:51,
health 96, ammo 98). These frames retain readable top clock/score
and bottom health/ammo HUD. Health changed during the live match; this run
makes no enemy-hit, kill, FPS, audio or match-completion claim.
Actual endpoint, dimensions and command evidence
This is the unchanged default guestWorker route. Browser viewport is
1024×768, emulated desktop/presentation canvas 684×570, and actual
guest/render drawing buffer 640×480. final-owner-eval.json and
final-workers.json confirm shared windowed HWND 65541, client origin
(24,44) in guest/page/render instances, and no bridge error. The desktop
canvas begins at browser (10,160), placing the guest client at (34,204).
The viewport size is not a claim of a 1024×768 guest render target.
executor-restore.json records an actual WebGL2RenderingContext, context
not lost, 68,545 completed backend draws and 68,885 completed actual
GL draw calls, with zero observed executor failures. The last observed
drawElements(TRIANGLES,114,UNSIGNED_SHORT,0) belongs to adapter 1,
command 69959, device 410128432, generation 1. The same adapter
belongs to render endpoint 1, whose actual options are neutral/WebGL.
Chrome 151 uses ANGLE SwiftShader; this establishes the WebGL API route,
without a hardware-GPU or throughput claim. The bounded observer preserves
returns/exceptions and was restored; helper checks verify ownership,
successful-call counting and restoration.
Startup/readback diagnostics are retained. The first LockRect parks with token −7/yield 16, then resumes with EAX 0, token/yield zero, ESP +20, pitch 2560 and nonzero pixels. The temporary parked EAX is not a completed API failure. Twenty completed successful locks are recorded. All sampled bridge error/rejection lists are empty. The final owner capture samples queue completed 69672, submitted 69682, with ten pending commands and no error; the later executor observation above advances further. No first completed graphics/API failure was observed, so no new source repair was justified.
Frozen identity, checks and cleanup
Pre-runtime checkout HEAD was 3d04b4841d5ec3744bb4f124073f0bf4dafcc356;
the exact build/launch snapshot HEAD was
bf9c495b6b83049342347155f3954d0f971a4eac after concurrent documentation
publication. The fresh locked canonical build yields WASM SHA-256
9b4e39a22c9c3abe4608e5f55e2db0eb5818da59cec04bc7b7406a0b8504d1b8.
Its matching 295 current source/host files, seven compiler files,
shared dirty/status records, runtime identities and helpers are retained.
The current JavaScript cube repair is included; the equal historical WASM
hash does not authorize mixing old host files.
All 998 original inputs verify unchanged before and after, including
the EXE SHA-256
2a95e2fa8c22ae94eb1c361fdb49ea8ec44c5e2a93faa00831308c01e951db8d.
Retained source/compiler hashes, 107 served snapshots, 41 PNG
signatures/hashes, 26 trusted native events, observer/evidence checks
and documentation diff checks pass. Registered -d3d -window -nosound,
assets, INI, guest state, clock, shaders, validation and queues were not
patched or bypassed. No protected fonts/Heroes II files were touched.
The full-lifetime browser lock serialized this execution after Forsaken;
the actual process/profile gate was clean. Quit at 06:43 UTC exited Chrome
1670515 zero. Controller 1670055, holder 1661318, wrapper and
all tracked descendants/crashpads are absent; HTTP 44079, CDP 40213
are closed and the profile is gone. cleanup-under-lock.json verifies
cleanup before releasing the lock; cleanup-verified.json checks actual
PID/port/profile absence afterward. The board watcher was also stopped.
Free disk stayed above 2 GB. No Boat/test box was allocated
(ID/state/expiry N/A), public deployment or successor launch occurred.
RECOVERY.md, result.json and final.txt retain replay and limitations.
UT 348 on GlideDrv: RenDev assertion is windowed Glide on a Voodoo Graphics (2026-11-14, UT348-GLIDE-RENDEV)
Symptom: with all three [Engine.Engine] devices set to
GlideDrv.GlideRenderDevice and StartupFullscreen=False, UT dies with
Assertion failed: RenDev [File:E:\unreal220\WinDrv\Src\WinViewport.cpp] [Line: 343] (OpenWindow <- UGameEngine::Init). GlideDrv.dll does load and
Glide initializes; System\UnrealTournament.log (get it with
--save-vfs=DIR --save-vfs-suffix=.log) shows, twice (Game- then
WindowedRenderDevice):
Init: Found Glide: 2.43 Wine Assembly
Init: Glide info: Type=0, fbRam=4 fbiRev=2 nTexelfx=1 Sli=0
Init: grSstOpen Res=7 Ref=0 Buffers=2
Init: Glide tmu 0: tmuRev=1 tmuRam=4 Space=4194296
Log: Flushed Glide TMU 0
Log: 3d hardware initialization failed
GlideDrv (image base 0x10700000, unrelocated in this run) copies
GrHwConfiguration to this+0xbc (so this+0xc0 = SSTs[0].type). Its
SetRes (0x10702d00; the tail at 0x10702ff0) does: if Fullscreen ->
Viewport->ResizeViewport(BLIT_Fullscreen..); else if type == 1
(GR_SSTTYPE_SST96, Voodoo Rush) -> windowed ResizeViewport; else
return 0. So on a Voodoo Graphics board GlideDrv refuses a window, exactly
as on real hardware; the stock INI only gets away with it because
WindowedRenderDevice is SoftDrv. -window does not force windowed in
348 -- only StartupFullscreen matters. Nothing in our Glide is wrong here.
With the same INI but StartupFullscreen=True (with or without -window) UT
plays DM-MorpheusDEMO on Glide on the CLI (Glide asks for 3 colour buffers,
gets FXFALSE, falls back to 2, as Deus Ex does). The emulator-side
alternative -- answering grSstQueryHardware as a Voodoo Rush -- would make
windowed GlideDrv work but changes the board identity (and the
SST96Config struct layout) for every Glide 2 app, so it was not done.
Fix for the registry: when GlideDrv is selected, set
WinDrv.WindowsClient StartupFullscreen=True like deusExIniSet.
CLI repro (--vfs-mount now applies after the app manifest, so it can
replace one manifest file for a run):
node test/run.js --app=ut348_demo --args="DM-MorpheusDEMO -window" \
--quiet-api --max-seconds=55 --max-batches=1000000 --batch-size=100000 \
--stuck-after=1000000 \
--vfs-mount="INI=c:\System\UnrealTournament.ini" \
--vfs-mount="INI=c:\UnrealTournament.ini" \
--save-vfs=DIR --save-vfs-suffix=.log --png=OUT.png --no-close
Without --max-batches the CLI stops at 200 batches inside UT's CPU-speed
loop (exe+0x10903523), and without --stuck-after it reports STUCK there.
Evidence: scratch/runs/20261114-ut348-glide (run3 = failure + log, run5 =
fullscreen Glide gameplay fullscreen.png, run6 = fullscreen INI + -window).