GekkoAOT v0.0.9

Highlights

• The Enhanced Renderer: ambient occlusion, contact shadows, per-fragment GX
  lighting, sun shadow cascades, indirect light, reflections, particle lights,
  depth of field and generated materials, added to any game whose 3D scene
  can be captured.
• AI texture reconstruction with Real-ESRGAN on the GPU or ESPCN on the CPU.
• Remastered and Remake graphics presets.
• Three compilation modes: Full, Balanced and Fast.
• Lower CPU use across the GX and main threads.
• GoldenEye: Rogue Agent no longer crashes at random, and Medal of Honor:
  Rising Sun gets past its first loading screen.

Graphics

• Scene capture: opaque, depth-tested 3D draws write view normals, depth with
  a camera identity (up to 15 projections per frame) and their color
  contribution to extra targets. The game's EFB, copies and CPU reads are
  unchanged.
• Ambient occlusion, contact shadows and bilateral filtering that never mix
  pixels of different cameras, so a weapon model does not shade the world.
• Per-fragment evaluation of the game's own GX lights on draws with normals.
• Environment light from the game's directional light, or a configured sun on
  baked scenes, with the world's vertical axis locked from scene evidence.
• Sun cascades: every eligible draw is replayed into a shadow atlas with its
  real geometry, skinning and alpha test, filtered with 4×4 PCF. The game's
  own blob shadows fade while cascades are active.
• One-bounce indirect light and screen-space reflections, the latter only on
  surfaces with GX reflection evidence.
• Particle lights selected on the GPU from additive and alpha-over particles,
  with radiance estimated from the TEV program.
• Depth of field, generated normal, roughness and height maps, parallax
  occlusion, surface micro-detail and specular highlights.
• Texture reconstruction at 2× or 4×: Real-ESRGAN compact on a dedicated GPU
  compute queue, ESPCN on the CPU, and rule-based paths for fonts, thin strips,
  pixel art and limited palettes. Results are cached on disk.
• Presets: Remastered — Natural, Vivid, Cinematic and Performance; Remake —
  AI textures (Remastered Cinematic with 4× Real-ESRGAN, surface detail,
  specular and FXAA).
• FXAA, alone or with 4× MSAA.
• Live field-of-view override, with CPU culling widened through proven native
  camera providers.
• Shaders: known pipelines compile at startup, unknown ones on worker
  threads; a draw is never skipped while its pipeline compiles.
• VSync uses Mailbox when available: no tearing and one to two refreshes less
  latency than FIFO.
• Experimental frame-rate unlock: the newest frame's geometry is replayed at
  the display rate with interpolated (Smooth) or predicted (Instant)
  transforms. It falls back to direct presentation when a replay no longer
  fits in a refresh. Off by default.

Compilation

• Full, Balanced and Fast modes in the launcher. Fast starts Medal of Honor:
  Frontline in 68 s from a cold cache on an 8-core laptop.
• FPSCR status bits are not computed and reservations are not cleared on
  stores when a per-game scan proves no instruction observes them
  (microbenchmarks: 1.96× and 3.97×).
• Functions get a direct start entry; the resume switch is used only to
  re-enter mid-function. Hot functions used to run about 10 KB of register
  moves on every call.
• SDK services are bound to named, ABI-checked native entry points.
• Secondary executables get hardware lowering and ThinLTO. With ThinLTO,
  per-chunk machine code is no longer generated twice.
• REL pointers keep their live-address provenance through arithmetic.
• Job hashing is linear in the number of chunks; Super Mario Sunshine's
  analysis went from 96 s to 39 s.
• REL branches that the synthetic module layout puts out of REL24/REL14
  range keep their real target instead of failing the build (titles with
  45-110 MiB of REL modules).
• Several games can compile at the same time: concurrent builds no longer
  reset each other's source checkout, and the graphics bridge is no longer
  relinked by every controller start.
• The controller and the side-module builder start their tools directly
  instead of through a shell.
• Games whose entry point is a plain function start with the IPL's stack and
  small-data registers.

Performance

• Harry Potter and the Chamber of Secrets, Burrow cutscene: main, GX and
  render threads together from 118 % to 54 % of one core.
• Star Fox Adventures, ThornTail Hollow at 1920×1200 with every effect: from
  4 to 37 fps. Logic-op shadow masks no longer split the render pass per
  triangle.
• Precomputed draw runs per display-list plan, stable texture IDs per
  source, and per-page write tracking (Linux) so a guest write invalidates
  only the textures it touches.
• The module caches its memory owner and views; the runtime is called only
  on a miss (was about 11 % of process CPU in Chamber of Secrets).
• Cache-flush loops no longer take a queue lock per 32-byte line.
• Renderer PGO with GCC on Linux, trained by any game and shared.
• EA's MPEG-2 IDCT runs natively in Medal of Honor: Frontline and 007: Agent
  Under Fire.
• Medal of Honor: Frontline's particle loop runs natively (code hash
  checked; GEKKOAOT_MOH_NATIVE_PARTICLES=0 disables it).

Compatibility

• Non-IEEE floating-point mode now flushes results only. Loads and stores are
  exact, so integers and pointers copied through floating-point registers are
  no longer zeroed. This fixes the random crashes of GoldenEye: Rogue Agent
  (Havok contact IDs) and affects every game whose SDK enables the mode.
• Medal of Honor: Rising Sun stopped after its first loading screen: the SDK
  VM library patches its exception handlers, and the runtime could no longer
  tell which of the game's two main executables was in memory.
• GoldenEye: Rogue Agent: effects missing in the top-left quarter, where the
  game saves, clears and restores its bloom work area.
• Tales of Symphonia: a dark or light band at the depth of the far blur plane
  with sun and sky light.
• Star Fox Adventures: black screen when more than 32 disc reads were queued
  at once, and a callback stack-alignment failure.
• Rayman 3: sun shadows invisible behind a full-screen glow pass.
• Killer7 and Shrek 2: textures that were missing or wrong now display.
• Mario Kart: Double Dash!!: widescreen presentation fixed.
• Real-ESRGAN jobs no longer fail on the GPU and fall back to the CPU.
• Movie frames in GoldenEye: Rogue Agent no longer get horizontal lines from
  texture reconstruction.

Launcher

• Compilation mode setting.
• Graphics dialog with every Enhanced Renderer, material and texture option,
  applied live; settings migrate once to the new defaults.
• Cheat code and texture pack managers for desktop and TV mode.
• Memory card manager shows save icons.

Diagnostics

• GEKKOAOT_ENHANCED_DIAGNOSTICS and GEKKOAOT_ENHANCED_VIEW debug views
  (depth, coverage, normals, cameras, environment, cascades, indirect,
  reflections).
• GEKKOAOT_GX_PHASE_PROFILE, GEKKOAOT_NATIVE_SAMPLE and
  GEKKOAOT_HUGE_TEXT_PERF_MAP for profiling.
• GEKKOAOT_CRASH_DUMP writes guest memory when a run ends.
• The compatibility laboratory (tools/compat_lab.py) compiles and observes
  a whole disc collection in private headless sessions.

Documentation

• New pages: Graphics, Launcher and
  Testing. Disc access, native services and the GX IR are
  now part of Architecture.
• Environment variables: every GEKKOAOT_* variable,
  generated from the sources and checked by the test suite.

Clean-room

• The repository stores no game or SDK code. SDK recognition uses
  non-reversible fingerprints: hashes of normalized function bodies and
  prefixes, 8-bit hashes per instruction and counters
  (tools/sdk_groundtruth_fingerprint.py); exact structural proofs store a
  mask template and a 64-bit hash (runtime/sdk/word_proof.h). Resolution
  results are unchanged on 129 tested game executables.
• Code translated from game executables and its translator were removed.
• Tests that execute SDK bodies read them from a local directory
  (GEKKOAOT_SDK_FIXTURES) and are reported as skipped without it.
• policy.clean-room guards these rules; see Clean-room policy.
• The release workflow grants write access only to the job that publishes,
  and the controller starts tools without a shell.

Upgrading

• Every game is compiled again on its first launch after updating, once per
  compilation mode.

Known issues

• Fast mode code is about three times slower on the main thread than Full.
• GoldenEye: Rogue Agent's VP6 intro movie shows vertical stripes.
• Terminator 3: The Redemption: the Enhanced Renderer leaves the player
  character much darker than the scene.
• The frame-rate unlock replays only the newest vertex data, so CPU-animated
  meshes stay at the game's rate.
• Effects use the visible scene only, and pre-rendered backgrounds receive
  them only on 3D objects.
• The issues listed for 0.0.8 that are not mentioned above remain open.