Overview › Code › R90
Code · blind round

R90 · Poisson-disk sampling, Bridson's algorithm

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.

The field: deepseek-r1:14b · gemma4:26b · llama3.1:8b · mistral-small:24b · qwen3-coder:30b · qwen3:14b · qwen3:8b · qwen3.5:9b — listed alphabetically, which is not the order of the cards below.

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.

Show task 
Create ONE self-contained HTML file (STRICT LIMIT: max 7000 characters in total — this is a budget on characters, not on lines, so removing line breaks does not help) that fills a <canvas> with evenly spaced random points using Bridson's Poisson-disk sampling: keep a background grid for fast neighbour lookups and an active list, spawn candidate points in the ring around an active sample, and accept only those that keep the minimum distance to every neighbour. Draw each point the moment it is accepted, so the blue-noise pattern visibly fills the area. Show the sample count and start a fresh pattern once no active samples remain. 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 Agemma4:26bDNF
No usable answer reached the harness (TIMEOUT). Counted as a did-not-finish.
MODEL Bqwen3.5:9bBLANKFORMAT
Show code
```html
<!DOCTYPE html>
<html><head><title>Poisson Disk Sampling</title></head><body style="margin:0;overflow:hidden;"><canvas id="c"></canvas><script>
const c=document.getElementById('c');
const ctx=c.getContext('2d');

let W, H;
let grid, active=[];
let max_dist;
let count=0;
let running=true;

function init() {
    W=H=window.innerWidth;
    c.width=W;
    c.height=H;
    grid=new Map();
    active=[];
    count=0;
    running=true;
}

init();

function getGridKey(x, y) {
    const gx=Math.floor((x/max_dist));
    const gy=Math.floor((y/max_dist));
    return `${gx},${gy}`;
}

function setPoint(x, y, r) {
    ctx.beginPath();
    ctx.arc(x, y, r, 0, Math.PI*2);
    ctx.fillStyle=rgba(0,150,255,0.8);
    ctx.fill();
}

function isSafe(px, py) {
    const gx=Math.floor((px/max_dist));
    const gy=Math.floor((py/max_dist));
    const key=`${gx},${gy}`;
    if (!grid.has(key)) return true;

    const neighbors=grid.get(key);
    for (let n of neighbors) {
        const distSq = (px-n[0])**2 + (py-n[1])**2;
        return distSq >= max_dist**2 - 1e-6;
    }
    return true;
}

function addPoint(x, y) {
    if (!isSafe(x, y)) return false;
    grid.set(getGridKey(x,y), (grid.get(getGridKey(x,y)))||[]);
    grid.get(getGridKey(x,y)).push([x, y]);
    active.push({x:x, y:y});
    setPoint(x, y);
    count++;
    return true;
}

function sampleDisk() {
    if (active.length === 0) {
        init();
        return;
    }

    const p=Math.random()*W;
    const q=Math.random()*H;
    let attemptCount=0;
    while(attemptCount++<100){
        const nextX = p + (Math.cos(attemptCount*0.1)*max_dist/2); // Ring sampling approximation
        const nextY = q + (Math.sin(attemptCount*0.1)*max_dist/2);

        if (addPoint(nextX, nextY)) {
            return true;
        }
    }
    return false;
}

function animate() {
    // Draw a faint background grid to aid visualization of sampling structure
    ctx.fillStyle="#050";
    for(let i=0;i<W/max_dist; i++) {
        for(let j=0;j<H/max_dist; j++) {
            ctx.fillRect(i*max_dist, j*max_dist, 1, 1);
        }
    }

    if (running) {
        const success = sampleDisk();
        
        // Update status text (optional but good for demonstration)
        if (!window.statusDiv) {
            const s=document.createElement('div');
            s.id='status';
            s.style.position='absolute';
            s.top='10px';
            s.left='10px';
            s.color='#fff';
            document.body.appendChild(s);
        }
        const s=document.getElementById('status');
        if (success) {
             s.textContent=`Points: ${count}. Running...`;
        } else if (active.length === 0 && count > 0) {
             running=false;
             s.textContent=`Finished! Total Points: ${count}. Restarting in 2s...`;
             setTimeout(() => { active=[]; init(); }, 2000);
        }

    }
    requestAnimationFrame(animate);
}

// Since we are limited on characters, I will use a shorthand for rgba.
function rgba(r, g, b, a) { return `rgba(${r},${g},${b},${a})`; }

animate();
</script></body></html>
```
MODEL Cqwen3-coder:30bERRBLANKMINIFIED
Show code
<!DOCTYPE html>
<html><head><title id="blue-noise"></title><style>body{margin:0;overflow:hidden;background:#111}canvas{display:block}</style></head><body onload="init()"><canvas id="c"></canvas><script>window.onload=function(){var c=document.getElementById('c'),ctx=c.getContext('2d');let R=50,GRID_SIZE=R*2;c.width=1280;c.height=720;let active=[];let grid=new Array(Math.ceil(c.width/GRID_SIZE)).fill(null).map(()=>new Array(Math.ceil(c.height/GRID_SIZE)).fill(false));function drawPoint(x,y){ctx.fillStyle='#00ffff';ctx.fillRect(x-1,y-1,2,2);}function getGridCoords(x,y){let gx=Math.floor(x/(R*2));let gy=Math.floor(y/(R*2));return [gx,gy];}function checkNeighbors(x,y,rMin){for(let i=Math.max(0, Math.floor((x-R)/GRID_SIZE));i<=Math.min(Math.ceil((x+R)/GRID_SIZE),grid.length-1);++i){for(let j=Math.max(0, Math.floor((y-R)/GRID_SIZE));j<=Math.min(Math.ceil((y+R)/GRID_SIZE),grid[0].length-1);++j)){if(!grid[i][j])continue;let nx=i*GRID_SIZE+(Math.random()*-R);let ny=j*GRID_SIZE+(Math.random()*-R);if(Math.hypot(nx-x,ny-y)<rMin){return false;}}}function findCandidate(p1){let angleStep=0.2;for(let i=0;i<4;++i){let theta=angleStep*i+Math.random()*Math.PI/2;let dist=R*(1+Math.sin(active.length/5));let cx=p1.x+Math.cos(theta)*dist;let cy=p1.y+Math.sin(theta)*dist;if(checkNeighbors(cx,cy,R)){return {x:cx,y:cy};}}return null;}function attemptSample(p){let count=0;for(let i=0;i<5;++i){let candidate={x:p.x+Math.random()*2*R-R,y:p.y+Math.random()*2*R-R};if(checkNeighbors(candidate.x,candidate.y,R)){return true;}else{count++;}}return count>=5}function init(){active=[];grid=new Array(Math.ceil(c.width/GRID_SIZE)).fill(null).map(()=>new Array(Math.ceil(c.height/GRID_SIZE)).fill(false));animate();}// Main loop functionvar frameId;function animate(){if(frameId){cancelAnimationFrame(frameId);}let p1={x:Math.random()*c.width,y:Math.random()*c.height};if(!active.length||active[active.length-1].x < Math.max(0,c.width)/2){active.push(p1);drawPoint(p1.x,p1.y);let startP=p1;}else{let startP=active[Math.floor(Math.random()*active.length)];}if(!startP)return;let success=false;for(let i=0;i<30;++i){let p2={x:Math.random()*c.width,y:Math.random()*c.height};let candidate=findCandidate(startP);if(candidate){drawPoint(candidate.x,candidate.y);active.push(candidate);success=true;break;}else{/* Try resampling from the last known point */}}if(!success && active.length>0){console.log("Attempting restart/resampling...");}requestAnimationFrame(animate)}</script></body></html>
MODEL Dmistral-small:24bDNF
No usable answer reached the harness (TIMEOUT). Counted as a did-not-finish.
MODEL Ellama3.1:8bSTATFORMAT
Show code
```html
<!DOCTYPE html>
<html>
<head>
<style>
body { margin: 0; padding: 0; overflow: hidden; }
canvas { border: 1px solid black; }
</style>
</head>
<body>
<canvas id="c" width="800" height="600"></canvas>
<script>
const c = document.getElementById('c');
let ctx = c.getContext('2d');
ctx.translate(400, 300);
ctx.scale(20, 20);

const n = Math.floor(Math.sqrt(c.width / 20) * Math.sqrt(c.height / 20));
ctx.fillStyle = 'lightgray';
for (let i = -n; i <= n; ++i) {
  for (let j = -n; j <= n; ++j) {
    if (Math.abs(i) + Math.abs(j) <= n) {
      ctx.fillRect(i, j, 1, 1);
    }
  }
}

const r0 = 20;
const r1 = 50;
const points = [];
let active = [ {x: -n, y: -n} ];
let i = 0;

function animate() {
  if (active.length) {
    const p = active.shift();
    for (let j = 0; j < Math.PI * 2; ++j) {
      const a = j / 32;
      const x = r1 + r0 * Math.cos(a);
      const y = r1 + r0 * Math.sin(a);
      let minDistance = Infinity;
      for (const q of points) {
        if (q.x !== p.x && q.y !== p.y) {
          const dx = x - q.x, dy = y - q.y;
          const d2 = dx * dx + dy * dy;
          if (d2 < minDistance) {
            minDistance = d2;
          }
        }
      }
      if (minDistance > r0 * r0) {
        points.push({x: x / 20, y: y / 20});
        ctx.fillStyle = 'blue';
        ctx.beginPath();
        ctx.arc(x / 20, y / 20, 1, 0, Math.PI * 2);
        ctx.fill();
      }
    }
    i++;
    document.title = `Points: ${i}`;
  } else {
    active.push({x: -n + Math.floor(Math.random() * (2 * n))});
  }
}

function main() {
  for (let j = 0; j < Math.PI * 2; ++j) {
    const a = j / 32;
    const x = r1 + r0 * Math.cos(a);
    const y = r1 + r0 * Math.sin(a);
    let minDistance = Infinity;
    for (const q of points) {
      if (q.x !== active[active.length - 1].x && q.y !== active[active.length - 1].y) {
        const dx = x / 20 - q.x, dy = y / 20 - q.y;
        const d2 = dx * dx + dy * dy;
        if (d2 < minDistance) {
          minDistance = d2;
        }
      }
    }
    if (minDistance > r0 * r0) {
      active.push({x: x / 20, y: y / 20});
    }
  }
}

main();
setInterval(animate.bind(this), 16);
</script>
</body>
</html>
```
MODEL Fqwen3:14bERRBLANKFORMAT
Show code
```html
<!DOCTYPE html>
<html>
<head>
<title>Poisson Disk Sampling</title>
<style>body{margin:0;overflow:hidden;background-color:#111}canvas{display:block}</style>
</head>
<body>
<canvas id="c"></canvas>
<script>
const c = document.getElementById('c');
const ctx = c.getContext('2d');

let W, H;
let grid, active, samples, minD;
let pointCount = 0;

function init() {
    W = window.innerWidth;
    H = window.innerHeight;
    c.width = W;
    c.height = H;
    grid = new Array(Math.ceil(W / (minD * 1.5))).fill(null).map(() => new Array(Math.ceil(H / (minD * 1.5))).fill(0));
    active = [];
    samples = [];
    pointCount = 0;
}

function reset() {
    init();
    for(let y=0; y<H; y+=2) { for(let x=0; x<W; x+=2) { grid[Math.floor(x/(minD*1.5))][Math.floor(y/(minD*1.5))] = 0; } }
}

function check(x, y, rSq) {
    let k = Math.floor(x/(minD*1.5));
    let j = Math.floor(y/(minD*1.5));
    if (k < 0 || k >= grid.length || j < 0 || j >= grid[0].length) return false;
    return grid[k][j] === 0;
}

function findNeighbors(x, y) {
    let a = Math.floor((x - minD/2) / (minD * 1.5));
    let b = Math.floor((y - minD/2) / (minD * 1.5));
    for (let i = a-1; i <= a+1; ++i) {
        for (let j = b-1; j <= b+1; ++j) {
            if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length) continue;
            const n = [i * minD * 1.5 + (i+1)/2, j * minD * 1.5 + (j+1)/2];
            if (grid[i][j] > 0) {
                samples.push({x: grid[i][j].x, y: grid[i][j].y});
            }
        }
    }
}

function sample() {
    const r = Math.random() * minD * 2;
    const theta = Math.random() * Math.PI * 2;
    let x = active[active.length - 1].x + r * Math.cos(theta);
    let y = active[active.length - 1].y + r * Math.sin(theta);

    if (x < 0 || x > W || y < 0 || y > H) return false;

    const dSq = samples.reduce((max, s) => Math.max(max, (s.x - x)**2 + (s.y - y)**2), 0);
    if (dSq >= minD * minD) {
        // Accept point
        samples.push({x: x, y: y});
        active.push({x: x, y: y});
        grid[Math.floor(x/(minD*1.5))][Math.floor(y/(minD*1.5))] = 1;
        ctx.fillStyle='#6aa';
        ctx.fillRect(x-2, y-2, 4, 4);
        pointCount++;
        return true;
    }
    return false;
}

function loop() {
    if (active.length === 0) {
        reset();
    }

    let accepted = false;
    while (accepted && active.length < 1000) {
        accepted = sample();
    }

    if (!accepted || active.length >= samples.length * 2) {
        requestAnimationFrame(loop);
        return;
    }

    requestAnimationFrame(loop);
}

window.addEventListener('resize', () => {
    W = window.innerWidth;
    H = window.innerHeight;
    init();
});

let minD = Math.min(Math.random() * 0.1 + 0.3, 0.5);
if (typeof requestAnimationFrame === 'function') {
    loop();
} else {
    // Fallback for older environments
    setInterval(loop, 16);
}
</script>
</body>
</html>
```
MODEL Gdeepseek-r1:14bERRBLANKFORMAT
Show code
```html
<!DOCTYPE html>
<html><head><style>body{background:#000}canvas{position:fixed;top:0;left:0;z-index:-1}</style></head>
<body><h2 style="color:#fff;padding:15px;">Poisson Disk Sampling</h2>
<canvas id=c width=800 height=600></canvas>
<div id=s stats></div>
<script>
const c=document.getElementById('c'), ctx=c.getContext('2d');
const w=c.width,h=c.height,d=Math.sqrt,minD=.05;
let grid=[],active=[],candidates=[];
function init(){grid=Array(h).fill().map(()=>[]);active=[];candidates=[];}
function addPoint(px,py){if(px<0||py<0||px>w||py>h)return false;
const x=~~(py/CELL), y=~~(px/CELL);if(grid[x][y])return false;
let canAdd=true,dx=CELL/2 - Math.abs(px%CELL-CELL/2);
for(let i=-1;i<3;i++)for(let j=-1;j<3;j++){
const nx=x+i,ny=y+j;if(!grid[nx]||!grid[ny][j])continue;
for(const p of grid[nx][ny]){let distSq=(px - p.x)*(px-p.x)+(py-p.y)*(py-p.y);
if(distSq < minD*minD){canAdd=false;break;} }
if(!canAdd)break; }if(canAdd){
active.push({x, y: py, cx: px, cy: py});grid[x][y].push({x:px,y:py});
ctx.beginPath();ctx.arc(px, py, 1.5,0,2*Math.PI);ctx.fillStyle='#fff';ctx.fill();
return true;}return false;}
function generateCandidates(){const len=active.length;
for(let i=len-1;i>=0;i--){const p=active[i];
for(let a=0;a<Math.PI*2;a+=.5){
const da=a + (Math.random()-0.5)*45,dr=Math.random()*minD/2 + minD*.5;
const dx=dr*Math.cos(da), dy=dr*Math.sin(da);
candidates.push({x:p.x+dx,y:p.y+dy});} } }
function update(){if(active.length==0){init();addPoint(w/2,h/2);return requestAnimationFrame(update);}
let count=0;while(candidates.length>0 && active.length>0){
const c=candidates.shift(),cx= ~~(c.x/CELL), cy=~~(c.y/CELL);
let canAdd=true;if(!grid[cx]||!grid[cy])continue;
for(let i=-1;i<3;i++)for(let j=-1;j<3;j++){
if(cx+i<0||cx+i>=h/cellSize)continue;if(cy+j<0||cy+j>=w/cellSize)continue;
for(const p of grid[cx+i][cy+j]){let distSq=(c.x - p.x)*(c.x-p.x)+(c.y-p.y)*(c.y-p.y);
if(distSq < minD*minD){canAdd=false;break;} } if(!canAdd)break; }
if(canAdd){
grid[cx].push({x:c.x,y:c.y});active.push(c);count++;} }
document.getElementById('s').textContent=`Samples: ${active.length}`;
requestAnimationFrame(update);}
init();addPoint(w/2,h/2);update();
</script>
</body></html>
```
MODEL Hqwen3:8bDNF
No usable answer reached the harness (ERR). Counted as a did-not-finish.
Reveal the models— compare the answers first, then open. Names, blind scores and latencies are hidden until you do.

Who wrote what

Blind labelModelBlind scoreLatencyStatus
MODEL A gemma4:26b ——harness
MODEL B qwen3.5:9b —34.7 sOK
MODEL C qwen3-coder:30b —18.8 sOK
MODEL D mistral-small:24b ——DNF
MODEL E llama3.1:8b —148.1 sOK
MODEL F qwen3:14b —18.7 sOK
MODEL G deepseek-r1:14b —110.9 sOK
MODEL H qwen3:8b ——harness