Code · blind round

R79 · Aggregation on a lattice

blind round 5/8 local models answered

Answers below are anonymized and shuffled. Read, judge, pick a favourite — then scroll down and reveal the models.

2 of the 8 local models delivered nothing through our test harness in this round — for reasons that lie with our setup, not with the models. Those cards are marked DNF like any other, but they are not evidence about those models. Which ones, and why, is spelled out in the reveal.

The reveal also holds a frontier reference on the same task (Claude Opus 5) — kept out of sight here so it cannot steer your judgement.

Show task

Create ONE self-contained HTML file (STRICT LIMIT: max 120 lines total) that simulates diffusion-limited aggregation on a 200x150 CELL GRID drawn on a <canvas>. A seed cell sits in the middle; random walkers step one cell at a time in the four grid directions and freeze permanently when they touch the cluster, growing a branching structure. Work strictly cell by cell — no floating-point positions. Show the number of frozen cells and the cluster radius. Smooth requestAnimationFrame animation, NO user input, starts immediately and keeps running (restart with a fresh random instance when finished). No external libraries, no comments needed. Output ONLY the HTML file content, nothing else.

The answers — blind

Local models (Brain cluster) — identical prompt, anonymized order

MODEL Amistral-small:24bDNF

No usable answer reached the harness (TIMEOUT). Counted as a did-not-finish.

MODEL Bdeepseek-r1:14bERRBLANKFORMAT

Show code

```html
<!DOCTYPE html>
<html><body style="margin:0;background:#000;">
<canvas id=c width=200 height=150></canvas>
<div id=o style="position:absolute;top:10px;left:10px;color:white;font-family:monospace;"></div>
<script>
const c=document.getElementById('c'), ctx=c.getContext('2d');
const w=200,h=150;let grid=[],frozen=[],currentWalker=null,count=0,radius=0;
class Walker{constructor(){this.x=Math.floor(w/2);this.y=Math.floor(h/2);this.path=[]}
move(){if(this.path.length>400&&!grid.includes(this.path[this.path.length-1])){const dir=[[0,1],[0,-1],[1,0],[-1,0]][Math.random()*4|0];let x=this.x+dir[0],y=this.y+dir[1];if(x<0||x>=w||y<0||y>=h)return false;if(!frozen.some(p=>p.x==x&p.y==y)){this.x=x;this.y=y;if(frozen.some(p=>p.x==this.x&p.y==this.y))return this.freeze()}}}freeze(){frozen.push({x:this.x,y:this.y});grid.push(this.x+h*this.y);count++;radius=Math.sqrt((this.x - w/2)**2 + (this.y - h/2)**2)/Math.SQRT1_2;currentWalker=null;if(count>200){location.reload()}}
}

function checkCell(x,y){return x>=0&&x<w&&y>=0&&y<h&&!frozen.some(p=>p.x==x&p.y==y)}
function draw(){ctx.clearRect(0,0,w,h);for(let i=0;i<w*h;i++){const x=i%w,y=Math.floor(i/w);if(grid.includes(i))ctx.fillStyle='#f00';else ctx.fillStyle='#fff';ctx.fillRect(x*1,y*1,1,1)}}}

grid.push(w/2 + h/2*(w%2==0?h-1:0));frozen=[{x:w/2,y:h/2}];currentWalker=new Walker();
function animate(){if(currentWalker&&checkCell(currentWalker.x,currentWalker.y)){currentWalker.move();return requestAnimationFrame(animate)}draw();document.getElementById('o').textContent=`Frozen cells: ${count}\nRadius (approx): ${radius.toFixed(1)}`;if(count<200){currentWalker=new Walker()}else{location.reload()}}
animate();
</script>
</body></html>
```

MODEL Cllama3.1:8bERRBLANKFORMAT

Show code

```html
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>DLA Simulation</title>
</head>
<body>
  <canvas id="canvas" width="200" height="150"></canvas>
  <script>
    const canvas = document.getElementById('canvas');
    const ctx = canvas.getContext('2d');

    let grid = new Array(200);
    for (let i = 0; i < 200; i++) {
      grid[i] = new Array(150).fill(false);
    }

    let walkers = [];
    let clusterRadius = 0;
    let frozenCells = 0;

    const xCenter = Math.floor(grid.length / 2);
    const yCenter = Math.floor(grid[0].length / 2);
    grid[xCenter][yCenter] = true;

    function randomDir() {
      return Math.random() < 0.25 ? -1 : (Math.random() < 0.5 ? 0 : 1);
    }

    function stepWalker(walker) {
      const newX = walker[0] + randomDir();
      const newY = walker[1] + randomDir();

      if (newX >= 0 && newX < grid.length && newY >= 0 && newY < grid[0].length && !grid[newX][newY]) {
        grid[newX][newY] = true;
        clusterRadius = Math.max(clusterRadius, Math.sqrt(Math.pow(newX - xCenter, 2) + Math.pow(newY - yCenter, 2)));
        walkers.push([newX, newY]);
      } else if (grid[newX][newY]) {
        frozenCells++;
      }

      walker[0] += randomDir();
      walker[1] += randomDir();
    }

    function draw() {
      ctx.clearRect(0, 0, canvas.width, canvas.height);
      for (let i = 0; i < grid.length; i++) {
        for (let j = 0; j < grid[i].length; j++) {
          if (grid[i][j]) {
            ctx.fillStyle = 'black';
            ctx.fillRect(i * 1, j * 1, 1, 1);
          }
        }
      }

      document.getElementById('cluster-radius').textContent = `Cluster Radius: ${clusterRadius}`;
      document.getElementById('frozen-cells').textContent = `Frozen Cells: ${frozenCells}`;

      for (const walker of walkers) {
        stepWalker(walker);
      }
    }

    function animate() {
      draw();
      if (!walkers.length) {
        grid.forEach(row => row.fill(false));
        walkers = [];
        frozenCells = 0;
        clusterRadius = 0;
        grid[xCenter][yCenter] = true;
      } else {
        requestAnimationFrame(animate);
      }
    }

    animate();
  </script>
  <div id="cluster-radius"></div>
  <div id="frozen-cells"></div>
</body>
</html>
```

MODEL Dqwen3-coder:30bBLANKLIMFORMAT

Show code

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>DLA Simulation</title>
    <style>body {background: #111; margin: 0;} canvas {display: block;}</style>
</head>
<body>
    <canvas id="dlaCanvas"></canvas>
    <script>
        const canvas = document.getElementById('dlaCanvas');
        const ctx = canvas.getContext('2d');

        let COLS = 200;
        let ROWS = 150;
        let CELL_SIZE = 3; // Pixels per cell
        canvas.width = COLS * CELL_SIZE;
        canvas.height = ROWS * CELL_SIZE;

        let grid = Array(ROWS).fill(0).map(() => Array(COLS).fill(false));
        let cluster = new Set();
        let seedX = Math.floor(COLS / 2);
        let seedY = Math.floor(ROWS / 2);
        let isRunning = true;

        function draw() {
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            for (const key of cluster) {
                const [y, x] = key.split(',').map(Number);
                ctx.fillStyle = '#3A6EA5';
                ctx.fillRect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE - 1, CELL_SIZE - 1);
            }
        }

        function initialize() {
            grid = Array(ROWS).fill(0).map(() => Array(COLS).fill(false));
            cluster.clear();
            seedX = Math.floor(COLS / 2);
            seedY = Math.floor(ROWS / 2);

            // Place seed
            if (!grid[seedY][seedX]) {
                grid[seedY][seedX] = true;
                cluster.add(`${seedY},${seedX}`);
            }

            draw();
        }

        function getNeighbors(x, y) {
            const dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]];
            let available = [];
            for (const [dy, dx] of dirs) {
                const nx = x + dx;
                const ny = y + dy;

                if (nx >= 0 && nx < COLS && ny >= 0 && ny < ROWS && !grid[ny][nx]) {
                    available.push({x: nx, y: ny});
                }
            }
            return available;
        }
        
        function runWalker() {
            if (!isRunning) return;

            const [currY, currX] = ['',''].map(c => Math.random() * (COLS - 1)); // Start near center for simplicity if seed fails
            let x = Math.floor((seedX + Math.random() * 50 - 25) / 2);
            let y = Math.floor((seedY + Math.random() * 50 - 25) / 2);

            // Ensure walker starts adjacent to the cluster
            while (Math.abs(x - seedX) > 10 || Math.abs(y - seedY) > 10) {
                if (x < 0 || x >= COLS || y < 0 || y >= ROWS) break;
                // Simple random walk movement until near cluster area
                const dx = Math.floor(Math.random() * 3) - 1;
                const dy = Math.floor(Math.random() * 3) - 1;
                x += dx; y += dy;
            }

            let currentX = x > 0 && x < COLS - 1 ? Math.min(Math.max(x, 1), COLS - 2) : seedX + Math.floor(Math.random() * 5);
            let currentY = y > 0 && y < ROWS - 1 ? Math.min(Math.max(y, 1), ROWS - 2) : seedY;


            const MAX_WALK_STEPS = 1000;
            let steps = 0;

            while (steps < MAX_WALK_STEPS && !isRunning) {
                if (!getNeighbors(currentX, currentY).length) break;
                
                // Random step attempt
                const potentialSteps = getNeighbors(currentX, currentY);
                if (potentialSteps.length === 0) break;

                let nextStep = potentialSteps[Math.floor(Math.random() * potentialSteps.length)];
                currentX = nextStep.x;
                currentY = nextStep.y;
                steps++;
            }


            // Try to connect/freeze the walker
            let frozen = false;
            for (let i = 0; i < 50 && !frozen; i++) { // Limited attempts to find attachment point
                const potentialSteps = getNeighbors(currentX, currentY);
                if (potentialSteps.length === 0) break;

                // Check if any neighbor is adjacent to the cluster boundary
                for (let j = 0; j < potentialSteps.length; j++) {
                    const nx = potentialSteps[j].x;
                    const ny = potentialSteps[j].y;
                    
                    // Heuristic check: Is this spot adjacent to an occupied cell?
                    if (!grid[ny][nx]) { 
                        let isNearCluster = false;
                        for (const key of cluster) {
                            const [cy, cx] = key.split(',').map(Number);
                            // Check if the neighbor's neighbors include (nx, ny) or vice versa
                            if ((Math.abs(ny - cy) <= 1 && Math.abs(nx - cx) <= 1) && !(nx == cx && ny == cy)) {
                                isNearCluster = true;
                                break;
                            }
                        }

                        if (isNearCluster) {
                            // Found attachment point! Freeze here.
                            grid[ny][nx] = true;
                            cluster.add(`${ny},${nx}`);
                            frozen = true;
                            break; 
                        }
                    }
                }
            }
        }

        function loop() {
            draw();
            if (Math.random() < 0.1) { // Throttle simulation speed slightly
                runWalker();
            }

            // Termination condition: If cluster size is too large, or if no growth for a long time (simplified check)
            if (cluster.size > COLS * ROWS * 0.8 || !isRunning) {
                 // Simulate completion and restart after delay
                setInterval(() => {
                    initialize();
                    requestAnimationFrame(loop);
                }, 1500);
                return;
            }

            requestAnimationFrame(loop);
        }

        window.onload = () => {
            initialize();
            loop();
        };
    </script>
</body>
</html>
```

MODEL Eqwen3:14bBLANK

Show code

<!DOCTYPE html>
<html><head><title>DLA</title></head><style>body{background:#111;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;font-family:monospace;}canvas{border:1px solid #333;}</style><body><canvas id="dlaCanvas" width="400" height="300"></canvas><script>
const canvas = document.getElementById('dlaCanvas');
const ctx = canvas.getContext('2d');

let GRID_W = 200;
let GRID_H = 150;
let CELL_SIZE = 2; // Adjusted for visible detail on a smaller canvas
let grid;
let clusterSize = 0;
let walkerSteps = 0;
let animationFrameId = null;

function initialize() {
    grid = Array(GRID_H).fill(0).map(() => Array(GRID_W).fill(false));
    clusterSize = 0;
    walkerSteps = 0;
    ctx.clearRect(0, 0, canvas.width, canvas.height);

    // Seed the starting cell (center)
    const startX = Math.floor((GRID_W - 1) / 2);
    const startY = Math.floor((GRID_H - 1) / 2);
    grid[startY][startX] = true;
    clusterSize = 1;

    // Draw initial cluster (seed)
    draw();
}

function draw() {
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    for (let y = 0; y < GRID_H; y++) {
        for (let x = 0; x < GRID_W; x++) {
            if (grid[y][x]) {
                ctx.fillStyle = '#0099ff'; // Blue for cluster
                ctx.fillRect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE);
            } else {
                ctx.fillStyle = '#1a1a1a'; // Background/Empty space
                ctx.fillRect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE);
            }
        }
    }
}

function isBlocked(y, x) {
    return y < 0 || y >= GRID_H || x < 0 || x >= GRID_W || grid[y][x];
}

function walk(startX, startY) {
    let currentX = startX;
    let currentY = startY;
    let path = [];

    while (!isBlocked(currentY, currentX)) {
        // Random move (0: N, 1: E, 2: S, 3: W)
        const direction = Math.floor(Math.random() * 4);
        let nextX = currentX;
        let nextY = currentY;

        if (direction === 0) nextY--; // North
        else if (direction === 1) nextX++;  // East
        else if (direction === 2) nextY++; // South
        else nextX--; // West

        currentX = Math.min(Math.max(nextX, 0), GRID_W - 1);
        currentY = Math.min(Math.max(nextY, 0), GRID_H - 1);
        
        if (isBlocked(currentY, currentX)) {
            break; // Hit the cluster boundary
        }

        path.push({x: currentX, y: currentY});
    }
    return path;
}

function processPath(path) {
    let newCells = 0;
    for (const cell of path) {
        if (!grid[cell.y][cell.x]) {
            grid[cell.y][cell.x] = true;
            newCells++;
        }
    }
    clusterSize += newCells;
}

function animate() {
    if (walkerSteps >= 50 && clusterSize > GRID_W * GRID_H * 0.9) {
        // Simulation near completion, stop and restart
        cancelAnimationFrame(animationFrameId);
        setTimeout(() => {
            initialize();
            animate(); // Restart the loop
        }, 100);
        return;
    }

    if (walkerSteps >= 50 && clusterSize > GRID_W * GRID_H * 0.9) return;


    const startX = Math.floor((GRID_W - 1) / 2);
    const startY = Math.floor((GRID_H - 1) / 2);

    // Run a walker and process its path
    const path = walk(startX, startY);
    processPath(path);

    draw();
    walkerSteps++;
}

window.onload = () => {
    initialize();
    animate();
};
</script></body></html>

MODEL Fqwen3:8bDNF

No usable answer reached the harness (ERR). Counted as a did-not-finish.

MODEL Ggemma4:26bDNF

No usable answer reached the harness (TIMEOUT). Counted as a did-not-finish.

MODEL Hqwen3.5:9bSTATLIM

Show code

<!DOCTYPE html>
<html><head><title>DLA Simulation</title></head><body style="margin:0;overflow:hidden;"><canvas id="dlaCanvas" width="400" height="300"></canvas><script>
const canvas = document.getElementById('dlaCanvas');
const ctx = canvas.getContext('2d');
let GRID_W = 200;
let GRID_H = 150;
let CELL_SIZE = 2;

let grid, clusterSize;
let seedX, seedY;

function initialize() {
    grid = Array(GRID_H).fill(0).map(() => Array(GRID_W).fill(0));
    clusterSize = 1;
    seedX = Math.floor(GRID_W / 2);
    seedY = Math.floor(GRID_H / 2);

    // Set the seed cell (value 1)
    grid[seedY][seedX] = 1;
}

function draw() {
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    for (let y = 0; y < GRID_H; y++) {
        for (let x = 0; x < GRID_W; x++) {
            if (grid[y][x] === 1) {
                ctx.fillStyle = 'rgba(0, 150, 255, 0.8)';
                ctx.fillRect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE);
            } else {
                ctx.fillStyle = '#eee';
                ctx.fillRect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE);
            }
        }
    }

    // Display stats
    ctx.fillStyle = 'black';
    ctx.font = '14px Arial';
    let status = `Frozen Cells: ${clusterSize}. Radius: ${Math.round(Math.sqrt(Math.pow(seedX - GRID_W/2, 2) + Math.pow(seedY - GRID_H/2, 2)))}`;
    ctx.fillText(status, 10, 20);
}

function findPerimeter() {
    let perimeter = [];
    for (let y = 0; y < GRID_H; y++) {
        for (let x = 0; x < GRID_W; x++) {
            if (grid[y][x] === 1) {
                const neighbors = [[0, 1], [0, -1], [1, 0], [-1, 0]];
                for (const [dy, dx] of neighbors) {
                    const ny = y + dy;
                    const nx = x + dx;
                    if (ny >= 0 && ny < GRID_H && nx >= 0 && nx < GRID_W && grid[ny][nx] === 0) {
                        perimeter.push({x: nx, y: ny});
                    }
                }
            }
        }
    }
    return perimeter;
}

function step() {
    let potentialSteps = findPerimeter();
    if (potentialSteps.length === 0 || clusterSize >= GRID_W * GRID_H) {
        initialize(); // Restart simulation if stuck or full
        draw();
        return true;
    }

    // Attempt to move from a random perimeter point
    let attempts = Math.min(15, potentialSteps.length); 
    for (let i = 0; i < attempts; i++) {
        const pIndex = Math.floor(Math.random() * potentialSteps.length);
        const start = potentialSteps[pIndex];

        // Simulate diffusion from 'start' until it hits the cluster or boundary
        let currentX = start.x;
        let currentY = start.y;
        let steps = 0;
        let success = false;

        while (steps < 15 && grid[currentY][currentX] === 0) {
            const directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
            directions.sort(() => Math.random() - 0.5); // Random walk
            
            let nextX = currentX + directions[0][1];
            let nextY = currentY + directions[0][0];

            if (nextX < 0 || nextX >= GRID_W || nextY < 0 || nextY >= GRID_H) {
                break; // Hit wall
            }
            if (grid[nextY][nextX] === 1) {
                // Collision! The walker stops here and freezes.
                currentX = nextX;
                currentY = nextY;
                success = true;
                break;
            }
            
            // Continue diffusing
            currentX = nextX;
            currentY = nextY;
            steps++;

            const newDirections = [[0, 1], [0, -1], [1, 0], [-1, 0]];
            newDirections.sort(() => Math.random() - 0.5);
            nextX = currentX + newDirections[0][1];
            nextY = currentY + newDirections[0][0];

            if (nextX < 0 || nextX >= GRID_W || nextY < 0 || nextY >= GRID_H) {
                break; // Hit wall
            }
        }

        // If the walk successfully hit a cluster point, freeze it.
        if (success && grid[currentY][currentX] === 0) {
             grid[currentY][currentX] = 1;
             clusterSize++;
        }
    }

    draw();
    return false; // Not finished
}


function animate() {
    const running = step(); 
    if (running) return;
    requestAnimationFrame(animate);
}

initialize();
animate();
</script></body></html>

Reveal the models— compare the answers first, then open. Names, blind scores and latencies are hidden until you do.

Who wrote what

Blind label	Model	Blind score	Latency	Status
MODEL A	mistral-small:24b	—	—	DNF
MODEL B	deepseek-r1:14b	—	56.9 s	OK
MODEL C	llama3.1:8b	—	135.7 s	OK
MODEL D	qwen3-coder:30b	—	26.8 s	OK
MODEL E	qwen3:14b	—	47.4 s	OK
MODEL F	qwen3:8b	—	—	harness
MODEL G	gemma4:26b	—	—	harness
MODEL H	qwen3.5:9b	—	51.2 s	OK

Frontier reference — outside the blind field

These models answered the identical prompt outside the blind field. They are deliberately not scored and not part of the blind comparison — they are there so you can see where a frontier model lands on the same task.

Collected differently from the blind field: the local models run through a plain API harness, the frontier references through a context-free agent, one shot, no retries. Response times are therefore not comparable and are not shown. On two English tasks the reference answer came back in German — an artefact of that harness, flagged on the affected rounds.

Claude Opus 5frontier reference

Show code

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Diffusion-Limited Aggregation</title>
<style>
  html,body{margin:0;height:100%;background:#05070d;color:#c8d6f0;
    font:13px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
    display:flex;align-items:center;justify-content:center}
  .wrap{width:min(96vw,900px)}
  h1{font-size:12px;letter-spacing:.28em;text-transform:uppercase;color:#5f7398;margin:0 0 10px;font-weight:600}
  canvas{width:100%;display:block;border:1px solid #16223a;border-radius:6px;
    background:#05070d;image-rendering:pixelated;box-shadow:0 0 60px -20px #2a6bff}
  #hud{display:flex;gap:26px;margin-top:10px;flex-wrap:wrap}
  #hud div{display:flex;gap:8px;align-items:baseline}
  #hud span{color:#5f7398;font-size:11px;letter-spacing:.14em;text-transform:uppercase}
  #hud b{color:#e8f0ff;font-weight:600;font-variant-numeric:tabular-nums;font-size:15px}
</style>
</head>
<body>
<div class="wrap">
  <h1>Diffusion-Limited Aggregation &middot; 200 &times; 150 cell lattice</h1>
  <canvas id="c" width="800" height="600"></canvas>
  <div id="hud">
    <div><span>Frozen cells</span><b id="n">1</b></div>
    <div><span>Cluster radius</span><b id="r">0</b></div>
    <div><span>Generation</span><b id="g">1</b></div>
  </div>
</div>
<script>
const cv=document.getElementById('c'),x=cv.getContext('2d');
const W=200,H=150,S=4,CX=W>>1,CY=H>>1,MAXR=70;
const en=document.getElementById('n'),er=document.getElementById('r'),eg=document.getElementById('g');
let grid,count,maxR,wx,wy,spawnR,kill2,phase,fadeT,gen=0;

function reset(){
  grid=new Uint8Array(W*H);count=0;maxR=0;phase=0;fadeT=0;gen++;
  x.globalAlpha=1;x.fillStyle='#05070d';x.fillRect(0,0,cv.width,cv.height);
  freeze(CX,CY);respawn();
}
function freeze(px,py){
  grid[py*W+px]=1;count++;
  const dx=px-CX,dy=py-CY,r=Math.round(Math.sqrt(dx*dx+dy*dy));
  if(r>maxR)maxR=r;
  paint(px,py,r);
}
function paint(px,py,r){
  const t=r/MAXR;
  x.shadowBlur=7;x.shadowColor='hsla('+(195+t*150)+',95%,60%,.75)';
  x.fillStyle='hsl('+(195+t*150)+',92%,'+(72-t*22)+'%)';
  x.fillRect(px*S,py*S,S,S);
  x.shadowBlur=0;
}
function respawn(){
  spawnR=Math.min(maxR+6,MAXR+4);
  const a=Math.random()*Math.PI*2,k=spawnR+18;
  kill2=k*k;
  wx=CX+Math.round(spawnR*Math.cos(a));
  wy=CY+Math.round(spawnR*Math.sin(a));
  if(wx<1)wx=1;if(wx>W-2)wx=W-2;if(wy<1)wy=1;if(wy>H-2)wy=H-2;
}
function touching(px,py){
  return grid[py*W+px-1]||grid[py*W+px+1]||grid[(py-1)*W+px]||grid[(py+1)*W+px];
}
function step(){
  const d=Math.random()*4|0;
  if(d===0)wx++;else if(d===1)wx--;else if(d===2)wy++;else wy--;
  if(wx<1||wx>W-2||wy<1||wy>H-2){respawn();return;}
  const dx=wx-CX,dy=wy-CY;
  if(dx*dx+dy*dy>kill2){respawn();return;}
  if(touching(wx,wy)){
    freeze(wx,wy);
    if(maxR>=MAXR||count>7000)phase=1;else respawn();
  }
}
function frame(){
  if(phase===0){
    for(let i=0;i<24000;i++){step();if(phase)break;}
  }else{
    fadeT++;
    x.globalAlpha=.055;x.fillStyle='#05070d';
    x.fillRect(0,0,cv.width,cv.height);x.globalAlpha=1;
    if(fadeT>70)reset();
  }
  en.textContent=count.toLocaleString();
  er.textContent=maxR+' cells';
  eg.textContent=gen;
  requestAnimationFrame(frame);
}
reset();
requestAnimationFrame(frame);
</script>
</body>
</html>