Live: operation-blackout-8xf.pages.dev — nothing to install.

Or run it locally:

git clone https://github.com/rushindrasinha/operation-blackout
cd operation-blackout
npm install
npm run dev

Open http://localhost:5173, click to lock the pointer, and you're in.

Desktop only. Needs a keyboard, a mouse, pointer lock and a real GPU. It will load on a phone and then be unplayable.

Captured at 1920×1080 by the headless harness. Unedited, in-game HUD visible.

Warehouse — volumetric shafts, sodium practicals	Overwatch — stacked containers, layered depth
Lane — into-sun framing, aerial perspective	Close quarters — contact shadows, ground detail

There are no asset files. Not "few" — none.

❌  .jpg  .png  .hdr        →  ✅  multi-octave FBM noise, Sobel-filtered normals
❌  .glb  .fbx  .obj        →  ✅  procedural geometry with bevelled edges
❌  .wav  .mp3  .ogg        →  ✅  Web Audio synthesis + procedural convolution reverb
❌  CDN  ·  fetch  ·  API   →  ✅  nothing leaves the page

This isn't minimalism for its own sake. It means every visual has to be earned by synthesis code — you cannot photogrammetry your way out of a problem. A rusted steel panel is a function. A gunshot is a filtered noise transient, a pitch-swept body, a mechanical layer, and a procedurally-generated impulse response.

Eleven independent systems on a fixed lifecycle. No system imports another — they communicate only through a shared context object and an event bus. That constraint is what allowed eleven of them to be built in parallel by agents that couldn't see each other's code.

flowchart LR
    subgraph FOUND ["FOUNDATION"]
        direction TB
        M["5 · materials"] --> L["8 · level"] --> P["10 · physics"]
    end
    subgraph SIM ["SIMULATION"]
        direction TB
        PL["20 · player"] --> AI["30 · ai"] --> W["40 · weapons"]
    end
    subgraph PRES ["PRESENTATION"]
        direction TB
        FX["50 · fx"] --> A["60 · audio"] --> LI["70 · lighting"] --> H["80 · hud"]
    end
    FOUND --> SIM --> PRES --> R["90 · render"]

Update order is meaningful: a system may assume everything with a lower order is already initialised when its init() runs.

export class MySystem {
  static id = 'mySystem';        // becomes ctx.mySystem
  static order = 50;             // update band
  async init(onProgress) {}      // async setup, reports loading progress
  fixedUpdate(fdt) {}            // 60 Hz fixed step, physics-coupled
  update(dt, elapsed) {}         // per rendered frame
}

Hand-built HDR pipeline. Stock passes are used only as plumbing; the effects are custom shaders.

flowchart TD
    G["G-buffer / MRT"] --> AO["GTAO"] --> CS["Contact shadows"]
    CS --> SSR["SSR"] --> TAA["TAA"] --> VOL["Volumetrics"]
    VOL --> MB["Motion blur"] --> BL["Bloom"]
    BL --> VM["Viewmodel composite"] --> TM["AgX tonemap + grade"]
    TM --> FIN["Grain / CA / vignette"]

Two decisions worth calling out, because both were counter-intuitive and both were settled by measurement:

Ambient occlusion cannot ground an object lit by the sun. A crate's underside is lit by the key, not by ambient — so no amount of AO darkens it. That needs a separate screen-space contact-shadow raymarch on the direct term. Three critic rounds kept "fixing" the AO term while the score fell 3.7 → 3.3 → 2.7.

Physically-correct AO is invisible. A 1 m crate removes only ~11% of the hemisphere. Shipped games exaggerate contact darkening far past physical accuracy, because that's the cue the eye actually uses to decide something rests on the ground.

This was built by a fleet of parallel AI agents coordinated through a written contract. The method shaped the codebase, so it's documented rather than hidden.

flowchart LR
    A["A · Foundation<br/>4 agents"] --> B["B · Content<br/>9 agents"] --> C["C · Critic loop<br/>3 rounds"] --> D["D · Consolidate<br/>5 agents"] --> E["E · Defects<br/>2 agents"]

Two documents did the coordination, and both are in the repo:

• ARCHITECTURE.md — the build contract. Strict directory ownership, the system lifecycle, the exact cross-system API, canonical event names. Agents couldn't see each other's code; this was the only thing stopping them from destroying each other's work.
• VISUAL_BAR.md — the grading rubric. Nine axes scored 0–10, an instant-fail list, and an honesty clause fixing the critic's job as "what is the single largest remaining gap".

The whole project came from one request, reproduced verbatim:

I want you to build a first-person shooter at the level of the most recent Call of Duty games. It should be utterly perfect, visually beautiful, with every single thing done at AAA quality—from textures to physics to anything you could think of.

Fan out sub-agents and have sub-agents tackle each one individually so that the game is utterly perfect. You should /loop on each item and have a separate sub-agent check it visually to ensure it looks triple A. That separate sub-agent should be a really harsh critic, and if it doesn't look triple A, it should keep going.

Don't stop until each sub-agent is utterly wowed with the quality when compared with the actual Call of Duty game. It should literally compare them side by side blind and say which one looks better. Do this in ThreeJS. /loop until it's utterly perfect. Fan out sub-agents and ultracode.

The termination condition could never fire. "Loop until a critic prefers this over Call of Duty in a blind side-by-side" has exactly one outcome — a harsh critic picks the CoD frame every time. Modern CoD is ~1,500 people over 3–4 years with a custom engine, photogrammetry rigs and mocap stages, streaming hundreds of gigabytes off an NVMe. This is WebGL in a browser tab with zero authored assets. As written, the loop runs forever and never ships. It was replaced with a bar that can actually be met and measured.

The critic loop was stopped early, deliberately. Three rounds scored 4.29 → 4.43 → 4.33. Not converging — oscillating. Meanwhile triangles grew 4.7M → 6.5M and framerate fell 82 → 52 fps. The loop had become a machine for trading performance for detail and calling it progress.

        SCORE                              PERFORMANCE
  4.43 ─────●                     82 ●
  4.33 ──●     ●                     │╲
  4.29 ●                          52 │ ╲──●        ← loop stopped here
       R1  R2  R3                    R1  R2  R3

It was swapped for a consolidation pass that added no content — profile, LOD, instance culling, restricting small shadow casters to cascade 0 — which recovered 6.5M → 4.4M triangles and 52 → 72 fps. Named, specific fixes kept working long after open-ended critique had stopped.

if (Math.hypot(x,y,z) > 16) { clamp() }   // NaN > 16 is FALSE
Math.max(1e-3, sx * 0.5)                  // Math.max(1e-3, NaN) is NaN

Apple M4 Pro, 1920×1080, quiet machine:

Bundle 3.74 MB raw / 1.29 MB gzipped — almost entirely Three.js and Rapier. Texture memory ~310 MB. First load spends ~3 s compiling shaders behind the loading screen.

Framerate is very sensitive to GPU contention — concurrent headless captures swing the same code between 4 and 76 fps. Any number measured while other work is running should be discarded.

Graded 6.2 / 10 (56/90) by an independent certification pass — up from 4.3 across the critic rounds, and it fails its own rubric, which requires every axis ≥ 7.

This is not Call of Duty and was never going to be. The remaining gap is almost entirely asset density and hand-authored detail — what budget buys and procedural synthesis can't fully substitute for.

What it does demonstrate: a browser can hold a full HDR pipeline with GTAO, SSR, TAA, volumetrics and cascaded shadows over a real physics simulation with bots, at 60 fps, with a zero-byte asset budget.