Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIHugging Face LMArena Human Preference 140K

use some webGPU wrapper library. create single html js. particlesArray[50]; every frame…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.0-flash-001’s answer.
  1. User

    use some webGPU wrapper library. create single html js. particlesArray[50]; every frame move each particle with small vx vy. In webGPU shader draw particles and draw lines between nearest. Fast GPU code, calculate lines in shader.

  2. Assistant

    Certainly! Below is a complete single HTML+JS example using gpuweb/gpuweb via the popular lightweight wrapper wgpu style code (but since no official wrapper is standardized, I'll use a minimal helper approach). The example:

    • Creates 50 particles with positions and velocities on CPU.
    • Updates positions each frame on CPU.
    • Uploads particle positions to GPU buffer.
    • Uses a compute shader to find nearest neighbors and generate line vertex data.
    • Uses a render shader to draw points and lines.
    • All line calculations happen on GPU for speed.

    How it works:

    • CPU updates particle positions.
    • Positions uploaded to GPU buffer.
    • Compute shader runs:
      • For each particle, finds nearest neighbor.
      • Outputs line vertex data (pairs of points).
    • Render pass draws:
      • Points as particles.
      • Lines between nearest neighbors.

    Code:

    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>WebGPU Particles + Lines</title>
    <style>
      body { margin: 0; overflow: hidden; background: #111; }
      canvas { display: block; width: 100vw; height: 100vh; }
    </style>
    </head>
    <body>
    <canvas id="gpu-canvas"></canvas>
    <script type="module">
      // Check WebGPU support
      if (!navigator.gpu) {
        alert("WebGPU not supported on this browser.");
        throw new Error("WebGPU not supported");
      }
    
      const canvas = document.getElementById('gpu-canvas');
      const adapter = await navigator.gpu.requestAdapter();
      const device = await adapter.requestDevice();
      const context = canvas.getContext('webgpu');
    
      // Configure canvas context
      const format = navigator.gpu.getPreferredCanvasFormat();
      context.configure({
        device,
        format,
        alphaMode: 'opaque',
      });
    
      // Constants
      const PARTICLE_COUNT = 50;
      const PARTICLE_SIZE = 4 * 2; // vec2<f32> position
      const LINE_VERTEX_SIZE = 4 * 2; // vec2<f32> position
      const LINE_COUNT = PARTICLE_COUNT; // one line per particle (to nearest neighbor)
      const LINE_VERTICES = LINE_COUNT * 2; // 2 vertices per line
    
      // Particle data on CPU
      const particlesArray = new Float32Array(PARTICLE_COUNT * 2); // x,y per particle
      const velocitiesArray = new Float32Array(PARTICLE_COUNT * 2); // vx, vy per particle
    
      // Initialize particles randomly in [-1,1] range
      for (let i = 0; i < PARTICLE_COUNT; i++) {
        particlesArray[i * 2] = (Math.random() * 2 - 1) * 0.9;
        particlesArray[i * 2 + 1] = (Math.random() * 2 - 1) * 0.9;
        velocitiesArray[i * 2] = (Math.random() * 2 - 1) * 0.002;
        velocitiesArray[i * 2 + 1] = (Math.random() * 2 - 1) * 0.002;
      }
    
      // Create GPU buffers
      // Particle positions buffer (storage & vertex)
      const particleBuffer = device.createBuffer({
        size: particlesArray.byteLength,
        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
        mappedAtCreation: true,
      });
      new Float32Array(particleBuffer.getMappedRange()).set(particlesArray);
      particleBuffer.unmap();
    
      // Particle velocities buffer (storage only)
      const velocityBuffer = device.createBuffer({
        size: velocitiesArray.byteLength,
        usage: GPUBufferUsage.STORAGE,
        mappedAtCreation: true,
      });
      new Float32Array(velocityBuffer.getMappedRange()).set(velocitiesArray);
      velocityBuffer.unmap();
    
      // Line vertex buffer (output from compute shader)
      // Each line has 2 vertices (vec2 positions)
      const lineVertexBuffer = device.createBuffer({
        size: LINE_VERTICES * LINE_VERTEX_SIZE,
        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.STORAGE,
      });
    
      // Uniform buffer for particle count
      const uniformBuffer = device.createBuffer({
        size: 4,
        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
      });
      device.queue.writeBuffer(uniformBuffer, 0, new Uint32Array([PARTICLE_COUNT]));
    
      // Compute shader WGSL: find nearest neighbor for each particle and output line vertices
      const computeShaderCode = `
    struct Particles {
      positions: array<vec2<f32>>;
    };
    
    @group(0) @binding(0) var<storage, read> particles : Particles;
    @group(0) @binding(1) var<storage, read_write> lines : array<vec2<f32>>;
    @group(0) @binding(2) var<uniform> uCount : u32;
    
    @compute @workgroup_size(64)
    fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
      let i = global_id.x;
      if (i >= uCount) { return; }
    
      let p = particles.positions[i];
      var minDist = 10000.0;
      var nearestIndex : u32 = 0u;
    
      // Find nearest neighbor
      for (var j: u32 = 0u; j < uCount; j = j + 1u) {
        if (i == j) { continue; }
        let q = particles.positions[j];
        let dist = distance(p, q);
        if (dist < minDist) {
          minDist = dist;
          nearestIndex = j;
        }
      }
    
      // Write line vertices: 2 vertices per line
      // line index = i
      // vertex 0 = p, vertex 1 = nearest neighbor position
      lines[i * 2u] = p;
      lines[i * 2u + 1u] = particles.positions[nearestIndex];
    }
    `;
    
      // Render shader WGSL: draw points and lines
      // We'll use two pipelines: one for points, one for lines
    
      // Vertex shader for points
      const vertexShaderPoints = `
    @vertex
    fn main(@location(0) position: vec2<f32>) -> @builtin(position) vec4<f32> {
      return vec4<f32>(position, 0.0, 1.0);
    }
    `;
    
      // Fragment shader for points
      const fragmentShaderPoints = `
    @fragment
    fn main() -> @location(0) vec4<f32> {
      return vec4<f32>(1.0, 0.8, 0.2, 1.0);
    }
    `;
    
      // Vertex shader for lines
      const vertexShaderLines = `
    @vertex
    fn main(@location(0) position: vec2<f32>) -> @builtin(position) vec4<f32> {
      return vec4<f32>(position, 0.0, 1.0);
    }
    `;
    
      // Fragment shader for lines
      const fragmentShaderLines = `
    @fragment
    fn main() -> @location(0) vec4<f32> {
      return vec4<f32>(0.2, 0.8, 1.0, 1.0);
    }
    `;
    
      // Create shader modules
      const computeModule = device.createShaderModule({ code: computeShaderCode });
      const vertexModulePoints = device.createShaderModule({ code: vertexShaderPoints });
      const fragmentModulePoints = device.createShaderModule({ code: fragmentShaderPoints });
      const vertexModuleLines = device.createShaderModule({ code: vertexShaderLines });
      const fragmentModuleLines = device.createShaderModule({ code: fragmentShaderLines });
    
      // Compute pipeline
      const computePipeline = device.createComputePipeline({
        layout: 'auto',
        compute: {
          module: computeModule,
          entryPoint: 'main',
        },
      });
    
      // Bind group for compute
      const computeBindGroup = device.createBindGroup({
        layout: computePipeline.getBindGroupLayout(0),
        entries: [
          { binding: 0, resource: { buffer: particleBuffer } },
          { binding: 1, resource: { buffer: lineVertexBuffer } },
          { binding: 2, resource: { buffer: uniformBuffer } },
        ],
      });
    
      // Render pipeline for points
      const renderPipelinePoints = device.createRenderPipeline({
        layout: 'auto',
        vertex: {
          module: vertexModulePoints,
          entryPoint: 'main',
          buffers: [
            {
              arrayStride: PARTICLE_SIZE,
              attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x2' }],
            },
          ],
        },
        fragment: {
          module: fragmentModulePoints,
          entryPoint: 'main',
          targets: [{ format }],
        },
        primitive: {
          topology: 'point-list',
        },
      });
    
      // Render pipeline for lines
      const renderPipelineLines = device.createRenderPipeline({
        layout: 'auto',
        vertex: {
          module: vertexModuleLines,
          entryPoint: 'main',
          buffers: [
            {
              arrayStride: LINE_VERTEX_SIZE,
              attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x2' }],
            },
          ],
        },
        fragment: {
          module: fragmentModuleLines,
          entryPoint: 'main',
          targets: [{ format }],
        },
        primitive: {
          topology: 'line-list',
        },
      });
    
      // Resize canvas to fit window
      function resize() {
        const dpr = window.devicePixelRatio || 1;
        canvas.width = canvas.clientWidth * dpr;
        canvas.height = canvas.clientHeight * dpr;
      }
      window.addEventListener('resize', resize);
      resize();
    
      // Animation loop
      function frame() {
        // Update particle positions on CPU
        for (let i = 0; i < PARTICLE_COUNT; i++) {
          let x = particlesArray[i * 2];
          let y = particlesArray[i * 2 + 1];
          let vx = velocitiesArray[i * 2];
          let vy = velocitiesArray[i * 2 + 1];
    
          x += vx;
          y += vy;
    
          // Bounce off edges [-1,1]
          if (x < -1 || x > 1) {
            vx = -vx;
            x = Math.min(1, Math.max(-1, x));
          }
          if (y < -1 || y > 1) {
            vy = -vy;
            y = Math.min(1, Math.max(-1, y));
          }
    
          particlesArray[i * 2] = x;
          particlesArray[i * 2 + 1] = y;
          velocitiesArray[i * 2] = vx;
          velocitiesArray[i * 2 + 1] = vy;
        }
    
        // Upload updated particle positions to GPU
        device.queue.writeBuffer(particleBuffer, 0, particlesArray);
    
        // Command encoder
        const commandEncoder = device.createCommandEncoder();
    
        // Compute pass: find nearest neighbors and write line vertices
        {
          const passEncoder = commandEncoder.beginComputePass();
          passEncoder.setPipeline(computePipeline);
          passEncoder.setBindGroup(0, computeBindGroup);
          passEncoder.dispatchWorkgroups(Math.ceil(PARTICLE_COUNT / 64));
          passEncoder.end();
        }
    
        // Render pass
        const textureView = context.getCurrentTexture().createView();
        const renderPassDescriptor = {
          colorAttachments: [
            {
              view: textureView,
              clearValue: { r: 0.05, g: 0.05, b: 0.1, a: 1 },
              loadOp: 'clear',
              storeOp: 'store',
            },
          ],
        };
    
        const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
    
        // Draw lines
        passEncoder.setPipeline(renderPipelineLines);
        passEncoder.setVertexBuffer(0, lineVertexBuffer);
        passEncoder.draw(LINE_VERTICES);
    
        // Draw points
        passEncoder.setPipeline(renderPipelinePoints);
        passEncoder.setVertexBuffer(0, particleBuffer);
        passEncoder.draw(PARTICLE_COUNT);
    
        passEncoder.end();
    
        device.queue.submit([commandEncoder.finish()]);
    
        requestAnimationFrame(frame);
      }
    
      requestAnimationFrame(frame);
    </script>
    </body>
    </html>
    

    Explanation:

    • Particles are stored as vec2 positions and velocities on CPU.
    • Each frame, CPU updates positions and bounces particles inside [-1,1] box.
    • Positions uploaded to GPU buffer.
    • Compute shader finds nearest neighbor for each particle and writes line vertex pairs.
    • Render pass draws lines (line-list) and points (point-list).
    • Points are yellowish, lines are bluish.
    • Uses workgroup_size(64) for compute shader dispatch.
    • Canvas resizes with window.

    Notes:

    • This example uses raw WebGPU API with minimal helper code.
    • The compute shader does O(N²) nearest neighbor search, which is fine for 50 particles.
    • For larger counts, spatial partitioning or approximate methods would be needed.
    • The GPU does the line vertex generation, so CPU only updates positions.
    • The code is fully contained in one HTML file.

    Open this file in a Chromium-based browser with WebGPU enabled (Chrome Canary, Edge Canary, or recent Chrome with flags) to see the particles moving and lines connecting nearest neighbors, all computed on GPU.

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