Skip to content
TheChatArchiveThe Chat Archive
Qwenqwen3.6-27b· Alibaba (Qwen)Hugging Face Arena WebDev Preferences (2026)

Technical Requirements * Use Three.js as the primary 3D framework * Use WebGPURenderer…

  1. User

    Technical Requirements

    • Use Three.js as the primary 3D framework
    • Use WebGPURenderer exclusively
    • Do not implement a WebGL or legacy-renderer fallback
    • Detect WebGPU support during initialization
    • When WebGPU is unavailable, display a clear compatibility message and stop execution
    • Use Three.js Nodes and TSL where appropriate for materials, lighting, particles, and post-processing
    • Use physically based materials
    • Use GPU instancing for repeated environment assets, props, and zombie crowds
    • Implement frustum culling, level-of-detail systems, and distance-based simulation throttling
    • Pool projectiles, particles, zombies, debris, and temporary effects
    • Use WebGPU-compatible post-processing
    • Use compute shaders where beneficial for particles, crowd behavior, destruction effects, or environmental simulations
    • Maintain a stable frame rate on modern WebGPU-capable desktop browsers
    • Adapt rendering quality based on detected GPU capabilities without switching renderers
    • Use a seeded timeline and deterministic event system
    • Organize the code into modular systems rather than one monolithic file
    • Target current WebGPU-capable versions of Chrome, Edge, and other compatible browsers
    • Do not include compatibility code for browsers or devices without WebGPU support

    Produce a complete, runnable WebGPU-only implementation with a clear project structure, setup instructions, and comments for all major systems.

  2. Qwen Assistant

    I'll build a complete WebGPU-only zombie survival shooter using Three.js. Let me start by exploring the project structure and then create all the necessary files.

    Now let me install Three.js with WebGPU support:

    Let me research the Three.js r170 WebGPU API to ensure I use the correct imports:

    Now I have a clear picture of the Three.js r170 WebGPU API. Key findings:

    • Import from 'three/webgpu' for WebGPURenderer and node materials
    • TSL from 'three/tsl' for shader nodes
    • Post-processing via TSL display functions
    • await renderer.init() for async initialization

    Let me now create the game. I'll build a zombie survival shooter with instanced zombie crowds, particle effects, post-processing, and all required systems. Starting with the core infrastructure:

    I need to create type declarations for three/webgpu and fix some TypeScript issues. Let me create the declaration file and continue with more system files:

    The three/webgpu module path doesn't properly re-export all Three.js classes through TypeScript. Let me fix the approach — I'll import core classes from 'three' and the WebGPURenderer separately, and fix PointerLockControls import:

    I need to install @types/three for proper TypeScript support:

    Good. Now let me create the entity files and core game systems. I'll create them in parallel batches:

    Let me fix those small type errors and continue creating more systems:

    I see — the DYING/DEAD cases are unreachable since they're already filtered at line 92. Let me fix the switch:

    Let me rewrite the problematic parts more cleanly:

    Now let me create the remaining game systems:

    Let me fix the type errors:

    Now let me create the main Game.ts that orchestrates everything, plus the UI:

    Let me fix those type errors:

    Now let me create the React UI components:

    Now let me update the CSS and try building:

    The build succeeded. Let me verify all files are in place and then enhance the game with some improvements:

    The build succeeded. Let me fix a few issues I noticed and enhance the gameplay. Let me fix the zombie removal logic and add a weapon model:

    Good, deadTimer is already there. Now let me update Game.ts to use deadTimer for cleanup and add a weapon model:

    Now let me enhance the game with a visible weapon, screen shake, and audio cues. Let me update Game.ts with the weapon:

    Build succeeded. Let me add a sound system and some final polish:

    Now let me integrate audio into the game:

    Build succeeded. Let me add a README with documentation and then do a final verification:

    Let me do a final build to confirm everything works:

    Let me verify the complete file structure:

    The project is complete. Here's a summary of what was built:

    Dead Zone — WebGPU Zombie Survival

    A complete first-person zombie survival shooter with 17 modular source files organized into:

    Architecture

    src/game/
    ├── Game.ts          → Main engine orchestrating all systems
    ├── Renderer.ts      → WebGPURenderer with GPU tier detection (no WebGL fallback)
    ├── Camera.ts        → FPS PointerLock camera controller
    ├── types.d.ts       → Type declarations for three/webgpu, TSL, WebGPU API
    ├── entities/
    │   ├── Player.ts    → Health, ammo, score, wave management
    │   └── Zombie.ts    → 6-state AI behavior machine (idle/walk/chase/attack/die)
    ├── systems/
    │   ├── PRNG.ts      → Seeded xorshift32 for deterministic randomness
    │   ├── Events.ts    → Reproducible event timeline (spawns, waves, pickups)
    │   ├── Pooling.ts   → Generic ObjectPool<T> preventing GC pressure
    │   ├── Particles.ts → GPU-accelerated Points particle system
    │   ├── Collision.ts → Raycasting hit detection with sphere intersection
    │   ├── LOD.ts       → Distance-based LOD + simulation throttling
    │   ├── Environment.ts → Instanced buildings/debris, atmospheric fog, animated lights
    │   ├── PostFX.ts    → TSL-based RenderPipeline (graceful fallback to direct render)
    │   └── Audio.ts     → Synthesized gunshots, hits, deaths (Web Audio API)
    └── UI/
        └── HUD.tsx      → React overlay: health bar, ammo, score, wave, crosshair
    

    Key Technical Features

    • WebGPU exclusively — WebGPURenderer from three/webgpu, clear compatibility message if unavailable
    • GPU instancing — Single InstancedMesh renders up to 128 zombies
    • TSL/Nodes — Post-processing via RenderPipeline + pass() from three/tsl
    • Frustum culling + LOD — 4 distance tiers, simulation throttling beyond 60m, render culling beyond 80m
    • Object pooling — Zero-allocation gameplay for zombies, particles
    • Deterministic events — Seeded PRNG ensures reproducible wave compositions
    • Audio synthesis — All sounds generated procedurally (no external assets)
    • Weapon model — First-person gun with recoil animation and barrel sway
    • Screen shake — Damage feedback via camera displacement

    Files built: index.html, src/game/Renderer.ts, src/game/Camera.ts, src/game/systems/PRNG.ts, src/game/types.d.ts, src/game/entities/Player.ts, src/game/entities/Zombie.ts, src/game/systems/Pooling.ts, src/game/systems/Events.ts, src/game/systems/LOD.ts, src/game/systems/Particles.ts, src/game/systems/Collision.ts, src/game/systems/Environment.ts, src/game/systems/PostFX.ts, src/game/Game.ts, src/game/UI/HUD.tsx, src/App.tsx, src/index.css, src/game/systems/Audio.ts, README.md

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.