Overview › Code › R75
Code · blind round

R75 · Falling sand on a cell grid

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 falling sand as a cellular automaton on a 150x100 CELL GRID drawn on a <canvas>. Sand is poured in at the top; each step, every sand cell tries to move one cell down, otherwise one cell down-left or down-right, otherwise it rests. Work strictly cell by cell on the grid — no floating-point positions, no velocities. Show the number of resting cells and the step count. 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 Allama3.1:8bBLANKFORMAT
Show code
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Falling Sand</title>
<style>body { margin: 0; }</style>
</head>
<body>
<canvas id="canvas"></canvas>

<script>
const canvas = document.getElementById('canvas');
canvas.width = 150;
canvas.height = 100;

const ctx = canvas.getContext('2d');

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

function drawGrid() {
	ctx.fillStyle = 'black';
	for (let x=0; x<150; x++) {
		for (let y=0; y<100; y++) {
			if (grid[x][y] == 1) ctx.fillRect(x, y, 1, 1);
		}
	}
}

function updateGrid() {
	let resting = 0;
	for (let x=0; x<150; x++) {
		for (let y=0; y<100; y++) {
			if (grid[x][y] == 2) { // sand
				if (y < 99 && grid[x][y+1] != 1) grid[x][y+1] = 2;
				else if ((x > 0 && grid[x-1][y+1] != 1 && grid[x-1][y+1] != 2) || (x < 149 && grid[x+1][y+1] != 1 && grid[x+1][y+1] != 2)) {
					grid[x][y] = 3; // rest
					resting++;
				}
			} else if (grid[x][y] == 3) { // rest
				if ((x > 0 && grid[x-1][y] != 1 && grid[x-1][y] != 2) || (x < 149 && grid[x+1][y] != 1 && grid[x+1][y] != 2)) {
					grid[x][y] = 2;
				}
			} else if (grid[x][y] == 0) { // empty
				if (Math.random() < 0.05) { // pour in some sand
					grid[x][y] = 2;
				}
			}
		}
	}

	document.getElementById('resting').textContent = resting;

	drawGrid();
}

function animate() {
	updateGrid();
	requestAnimationFrame(animate);
}

const pouringButton = document.createElement('button');
pouringButton.textContent = 'Start';
document.body.appendChild(pouringButton);

canvas.addEventListener('click', function(e) {
	grid[e.clientX][e.clientY] = 2;
});

pouringButton.addEventListener('click', function() {
	animate();
});

drawGrid();
</script>

<div id="resting"></div>
```
MODEL Bqwen3-coder:30bERRBLANKMINIFIED
Show code
<!DOCTYPE html>
<html><body><canvas id="sandCanvas" width="300" height="150"></canvas><script>const canvas=document.getElementById("sandCanvas");const ctx=canvas.getContext("2d");let W=15;let H=10;let CELL_SIZE=20;let GRID_W=150,GRID_H=100;// Scaling dimensions for the actual simulation logic
let grid = Array(GRID_H).fill(0).map(()=>Array(GRID_W).fill(0));let nextGrid=Array(GRID_H).fill(0).map(()=>Array(GRID_W).fill(0));let stepCount=0;function init() {for(let i=0;i<GRID_H;i++)grid[i]=Object.assign([...grid[i]]);for(let i=0;i<GRID_W;i++)grid[i].fill(0);stepCount=0;console.log("Simulation initialized.");}function draw() {ctx.clearRect(0,0,canvas.width,canvas.height);let scaleX=canvas.width/GRID_W;let scaleY=canvas.height/GRID_H;for(let y=0;y<GRID_H;y++)for(let x=0;x<GRID_W;x++)if(grid[y][x])ctx.fillStyle="#D2B48C";ctx.fillRect(x*scaleX,y*scaleY,scaleX-1,scaleY-1);function update() {nextGrid=Object.assign([...nextGrid]);for(let y=0;y<GRID_H;y++)for(let x=0;x<GRID_W;x++)if(grid[y][x]===1){let dy=y+1,dx=x;let target=[{dy:dy,dx:dx},{dy:y+1,dx:x-1},{dy:y+1,dx:x+1}];let moveTarget={r:-1,c:-1};for(const t of target){if(t.dy>=0&&t.dy<GRID_H&&t.dx>=0&&t.dx<GRID_W&&grid[t.dy][t.dx]===0){moveTarget={r:t.dy,c:t.dx};break;}}if(moveTarget.r>-1){nextGrid[moveTarget.r++][moveTarget.c++]++;}else{nextGrid[y][x]++;}}let restingCells=0;for(let y=0;y<GRID_H;y++)for(let x=0;x<GRID_W;x++)if(grid[y][x]===1&&nextGrid[y][x]===1)restingCells++;grid=Object.assign([...nextGrid]);nextGrid=Array(GRID_H).fill(0).map(()=>Array(GRID_W).fill(0));stepCount++;document.getElementById("status").innerHTML=`Step: ${stepCount}<br>Resting Cells: ${restingCells}`;requestAnimationFrame(loop);function loop() {draw();update();};init();window.onload=()=>{let status=document.createElement('div');status.id="status";status.style.position='absolute';status.style.top='10px';status.style.left='10px';document.body.appendChild(status);loop();}
</script></body></html>
MODEL Cdeepseek-r1:14bDNF
No usable answer reached the harness (TIMEOUT). Counted as a did-not-finish.
MODEL Dqwen3.5:9bOKFORMAT
Show code
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Falling Sand Simulation</title>
    <style>body { background: #111; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0; } canvas { border: 2px solid #ccc; }</style>
</head>
<body>
    <canvas id="sandCanvas" width="300" height="500"></canvas>
    <script>
        const canvas = document.getElementById('sandCanvas');
        const ctx = canvas.getContext('2d');

        const COLS = 150;
        const ROWS = 100;
        const CELL_SIZE = 2; // Scale factor for visualization
        const GRID_WIDTH = Math.ceil(COLS * CELL_SIZE);
        const GRID_HEIGHT = Math.ceil(ROWS * CELL_SIZE);

        let grid = Array.from({ length: COLS }, () => new Array(ROWS).fill(0));
        let stepCount = 0;
        let restingCells = 0;
        let running = true;

        function initializeGrid() {
            grid = Array.from({ length: COLS }, () => new Array(ROWS).fill(0));
            stepCount = 0;
            restingCells = 0;
            for (let i = 0; i < COLS; i++) {
                if (Math.random() < 0.1) { // Random sand placement at start
                    grid[i][ROWS - 1] = 1;
                }
            }
        }

        function drawGrid() {
            ctx.clearRect(0, 0, GRID_WIDTH, GRID_HEIGHT);
            for (let x = 0; x < COLS; x++) {
                for (let y = 0; y < ROWS; y++) {
                    if (grid[x][y] === 1) {
                        ctx.fillStyle = '#FFD700'; // Sand color
                        ctx.fillRect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE);
                    }
                }
            }

            ctx.fillStyle = 'white';
            ctx.font = "14px Arial";
            ctx.fillText(`Step: ${stepCount} | Resting: ${restingCells}`, 10, 20);
        }

        function update() {
            let nextGrid = JSON.parse(JSON.stringify(grid));
            let newRestingCells = 0;
            let sandMoved = false;

            for (let x = 0; x < COLS; x++) {
                for (let y = ROWS - 1; y >= 0; y--) {
                    if (grid[x][y] === 1) {
                        let newX = x;
                        let newY = y - 1;

                        // Try falling down
                        if (newY >= 0 && nextGrid[x][newY] === 0) {
                            nextGrid[x][newY] = 1;
                            grid[x][y] = 0; // Clear old spot in original grid for the move logic below
                            sandMoved = true;
                        } else if (newY >= 0 && (x > 0 ? nextGrid[x - 1][y] === 0 : false) && (x < COLS - 1 ? nextGrid[x + 1][y] === 0 : false)) { // Try diagonal fallback
                            if (Math.random() < 0.5) {
                                newX = x - 1;
                            } else {
                                newX = x + 1;
                            }
                            newY = y;

                            if (nextGrid[newX][newY] === 0) {
                                nextGrid[newX][newY] = 1;
                                grid[x][y] = 0;
                                sandMoved = true;
                            } else {
                                // If diagonal spot is occupied in the temporary grid, it rests
                                nextGrid[x][y] = 1;
                                newRestingCells++;
                            }
                        } else {
                            // Rests if blocked or already at top edge
                            nextGrid[x][y] = 1;
                            newRestingCells++;
                        }
                    } else {
                        nextGrid[x][y] = grid[x][y]; // Keep empty spots empty
                    }
                }
            }

            grid = nextGrid;
            stepCount++;
            restingCells = newRestingCells;

            drawGrid();

            requestAnimationFrame(update);
        }

        initializeGrid();
        update();
    </script>
</body>
</html>
```
MODEL Egemma4:26bDNF
No usable answer reached the harness (TIMEOUT). Counted as a did-not-finish.
MODEL Fmistral-small:24bBLANKFORMAT
Show code
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Falling Sand</title>
<style>
    body { display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #f0f0f0; }
    canvas { border: 2px solid black; }
    #info { position: absolute; top: 10px; left: 10px; font-family: Arial, sans-serif; color: black; }
</style>
</head>
<body>
<canvas id="sandCanvas" width="600" height="400"></canvas>
<div id="info">Step: 0 | Resting: 0</div>
<script>
const canvas = document.getElementById('sandCanvas');
const ctx = canvas.getContext('2d');
const cellSize = 4;
const cols = 150;
const rows = 100;
const grid = Array.from({ length: rows }, () => Array(cols).fill(0));
let stepCount = 0;
let restingCells = 0;

function drawGrid() {
    for (let r = 0; r < rows; r++) {
        for (let c = 0; c < cols; c++) {
            ctx.fillStyle = grid[r][c] ? 'yellow' : 'white';
            ctx.fillRect(c * cellSize, r * cellSize, cellSize, cellSize);
        }
    }
}

function updateGrid() {
    const newGrid = Array.from({ length: rows }, () => Array(cols).fill(0));
    let restingCount = 0;
    for (let r = 0; r < rows; r++) {
        for (let c = 0; c < cols; c++) {
            if (grid[r][c]) {
                if (r === rows - 1) {
                    newGrid[r][c] = 1;
                    restingCount++;
                } else if (!newGrid[r + 1][c]) {
                    newGrid[r + 1][c] = 1;
                } else if (c > 0 && !newGrid[r + 1][c - 1]) {
                    newGrid[r + 1][c - 1] = 1;
                } else if (c < cols - 1 && !newGrid[r + 1][c + 1]) {
                    newGrid[r + 1][c + 1] = 1;
                } else {
                    newGrid[r][c] = 1;
                    restingCount++;
                }
            }
        }
    }
    grid.splice(0, rows, ...newGrid);
    return restingCount;
}

function pourSand() {
    if (Math.random() < 0.05) grid[0][Math.floor(Math.random() * cols)] = 1;
}

function animate() {
    stepCount++;
    restingCells += updateGrid();
    pourSand();
    drawGrid();
    document.getElementById('info').innerText = `Step: ${stepCount} | Resting: ${restingCells}`;
    if (restingCells >= cols * rows) restart();
    else requestAnimationFrame(animate);
}

function restart() {
    grid.fill(Array(cols).fill(0));
    stepCount = 0;
    restingCells = 0;
    animate();
}

requestAnimationFrame(animate);
</script>
</body>
</html>
```
MODEL Gqwen3:14bOKLIMFORMAT
Show code
```html
<!DOCTYPE html>
<html>
<head>
<title>Falling Sand Simulation</title>
<style>body { background: #000; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }</style>
</head>
<body>
<canvas id="sandCanvas" width="300" height="600"></canvas>

<script>
    const canvas = document.getElementById('sandCanvas');
    const ctx = canvas.getContext('2d');

    // Grid dimensions (150 columns, 100 rows) - Note: Canvas size is fixed at 300x600 for visual scaling
    const COLS = 150;
    const ROWS = 100;
    const CELL_SIZE = 2; // Drawing scale factor
    const GRAVITY = 1;

    // State representation: 0 = Empty, 1 = Sand
    let grid = [];
    let stepCount = 0;

    function initializeGrid() {
        grid = Array(ROWS).fill(0).map(() => new Uint8Array(COLS));
        stepCount = 0;

        // Fill with some initial random sand for demonstration
        for (let r = 1; r < ROWS - 5; r++) {
            for (let c = Math.random() * COLS; c < Math.min(c + 2, COLS); c++) {
                if (Math.random() > 0.9) grid[r][c] = 1; // Sparse initial sand
            }
        }

        // Ensure the top corner starts with sand for continuous flow
        grid[0][30] = 1; 
    }

    function getSandCount(currentGrid) {
        let count = 0;
        for (let r = 0; r < ROWS; r++) {
            for (let c = 0; c < COLS; c++) {
                if (currentGrid[r][c] === 1) count++;
            }
        }
        return count;
    }

    function update() {
        const nextGrid = new Uint8Array(COLS).fill(0);
        let currentSandCount = 0;
        let nextSandCount = 0;
        let restingCells = 0;

        // Iterate bottom up, left to right (standard CA processing order)
        for (let r = ROWS - 1; r >= 0; r--) {
            for (let c = 0; c < COLS; c++) {
                if (grid[r][c] === 1) {
                    currentSandCount++;

                    // Try Down
                    const downR = r + GRAVITY;
                    const downC = c;
                    
                    if (downR < ROWS && grid[downR][downC] === 0) {
                        grid[downR][downC] = 1; // Move down
                        nextSandCount++;
                        continue;
                    }

                    // Try Down-Left or Down-Right if Down is blocked
                    const potentialMoves = [
                        { r: r + GRAVITY, c: c - 1 },
                        { r: r + GRAVITY, c: c + 1 }
                    ];

                    let moved = false;
                    for (const move of potentialMoves) {
                        const newR = move.r;
                        const newC = move.c;

                        if (newR < ROWS && newC >= 0 && newC < COLS && grid[newR][newC] === 0) {
                            grid[newR][newC] = 1; // Move diagonally
                            nextSandCount++;
                            moved = true;
                            break;
                        }
                    }

                    if (!moved) {
                        // Rests in place (This is the cell that stays at grid[r][c])
                        restingCells++;
                    }
                }
            }
        }
        
        // Fallback: If any cells were moved, they must be reset for the next frame.
        // Since we are modifying 'grid' directly in place (which is fine for this simple CA model), 
        // we don't need to copy the whole grid, just ensure boundaries are respected implicitly by logic.

        // We only count resting cells based on the successful updates within the loop structure.
        stepCount++;
    }

    function draw() {
        ctx.fillStyle = '#010A28'; // Dark background color
        ctx.fillRect(0, 0, canvas.width, canvas.height);

        for (let r = 0; r < ROWS; r++) {
            for (let c = 0; c < COLS; c++) {
                if (grid[r][c] === 1) {
                    ctx.fillStyle = '#ffaa00'; // Sand color
                    ctx.fillRect(c * CELL_SIZE, r * CELL_SIZE, CELL_SIZE, CELL_SIZE);
                }
            }
        }

        // Display stats
        const sandCount = getSandCount(grid);
        let statusText = `Step: ${stepCount} | Sand Cells: ${sandCount}`;
        ctx.fillStyle = '#FFFFFF';
        ctx.font = '16px monospace';
        ctx.fillText(`Status: Running`, 10, 20);

        // Draw info below canvas (simulated update for text output)
        const statusDisplay = document.createElement('div');
        statusDisplay.style.position = 'absolute';
        statusDisplay.style.top = 'calc(100vh - 50px)';
        statusDisplay.style.left = '0';
        statusDisplay.innerHTML = `<strong>Step: ${stepCount}</strong> | Sand Cells: ${sandCount}`;
        document.body.appendChild(statusDisplay);
    }

    function loop() {
        // Core simulation step
        update(); 
        draw();
        requestAnimationFrame(loop);
    }

    // Start the simulation
    initializeGrid();
    loop();
</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 llama3.1:8b —9.1 sOK
MODEL B qwen3-coder:30b —17.5 sOK
MODEL C deepseek-r1:14b ——DNF
MODEL D qwen3.5:9b —18.3 sOK
MODEL E gemma4:26b ——harness
MODEL F mistral-small:24b —101.1 sOK
MODEL G qwen3:14b —22.7 sOK
MODEL H qwen3:8b ——harness

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>Falling Sand — Cellular Automaton</title>
<style>
*{box-sizing:border-box}
body{margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;padding:1.2rem;
background:radial-gradient(1200px 700px at 50% -10%,#141a26,#080a10 70%);color:#e7ebf3;
font:16px/1.5 ui-sans-serif,system-ui,"Segoe UI",Roboto,sans-serif}
.wrap{width:min(980px,100%)}
h1{margin:0 0 .25rem;font-size:clamp(1.05rem,2.6vw,1.5rem);font-weight:650;letter-spacing:.01em}
p.sub{margin:0 0 1rem;color:#8b95a8;font-size:.85rem}
.stats{display:flex;flex-wrap:wrap;gap:.6rem;margin-bottom:.75rem}
.stat{flex:1 1 120px;background:#121722;border:1px solid #232a39;border-radius:12px;padding:.5rem .75rem}
.k{display:block;font-size:.66rem;letter-spacing:.14em;text-transform:uppercase;color:#7d879b}
.v{font:600 1.2rem/1.25 ui-monospace,SFMono-Regular,Menlo,monospace;color:#f3f6fb;font-variant-numeric:tabular-nums}
canvas{display:block;width:100%;aspect-ratio:3/2;background:#05070b;border:1px solid #232a39;
border-radius:12px;image-rendering:pixelated;box-shadow:0 18px 50px -22px #000}
</style>
</head>
<body>
<div class="wrap">
<h1>Falling Sand · 150 × 100 cell automaton</h1>
<p class="sub">Every step each grain moves one cell down, else down-left or down-right, else it rests.</p>
<div class="stats">
<div class="stat"><span class="k">Step</span><span class="v" id="eS">0</span></div>
<div class="stat"><span class="k">Resting cells</span><span class="v" id="eR">0</span></div>
<div class="stat"><span class="k">Grains</span><span class="v" id="eG">0</span></div>
<div class="stat"><span class="k">Run</span><span class="v" id="eN">0</span></div>
</div>
<canvas id="c" width="150" height="100"></canvas>
</div>
<script>
const W=150,H=100,N=W*H;
const cv=document.getElementById("c"),ctx=cv.getContext("2d");
const img=ctx.createImageData(W,H),buf=new Uint32Array(img.data.buffer);
const eS=document.getElementById("eS"),eR=document.getElementById("eR"),
      eG=document.getElementById("eG"),eN=document.getElementById("eN");
const grid=new Uint8Array(N),shade=new Uint8Array(N),rest=new Uint8Array(N),pal=new Uint32Array(256);
const BG=0xff0b0705;
let step=0,total=0,resting=0,run=0,src=[],emit=1,cap=0,idle=0,mov=0;
function hsl(h,s,l){s/=100;l/=100;const k=n=>(n+h/30)%12,a=s*Math.min(l,1-l),
 f=n=>Math.round(255*(l-a*Math.max(-1,Math.min(k(n)-3,9-k(n),1))));return[f(0),f(8),f(4)];}
function px(h,s,l){const c=hsl(h,s,l);return 4278190080|(c[2]<<16)|(c[1]<<8)|c[0];}
function reset(){
 grid.fill(0);shade.fill(0);rest.fill(0);
 step=0;total=0;resting=0;idle=0;run++;
 const hue=Math.random()*360;
 for(let i=0;i<256;i++)pal[i]=px((hue+i/11-11+360)%360,58+i/15,32+i/6.5);
 mov=px(hue,95,80);
 const k=1+(Math.random()*3|0);src=[];
 for(let i=0;i<k;i++)src.push(14+(((W-28)*(k===1?0.5:i/(k-1)))|0));
 emit=1+(Math.random()*3|0);
 cap=2400+(Math.random()*3400|0);
}
function tick(){
 if(total<cap)for(const x of src)for(let i=0;i<emit;i++){
  const p=Math.max(0,Math.min(W-1,x+(Math.random()*3|0)-1));
  if(!grid[p]){grid[p]=1;shade[p]=Math.random()*256|0;total++;}
 }
 const dir=step&1;
 for(let y=H-2;y>=0;y--)for(let i=0;i<W;i++){
  const x=dir?i:W-1-i,p=y*W+x,b=p+W;
  if(!grid[p])continue;
  let t=-1;
  if(!grid[b])t=b;
  else{
   const dl=x>0&&!grid[b-1],dr=x<W-1&&!grid[b+1];
   if(dl&&dr)t=Math.random()<0.5?b-1:b+1;else if(dl)t=b-1;else if(dr)t=b+1;
  }
  if(t>=0){grid[t]=1;shade[t]=shade[p];grid[p]=0;shade[p]=0;}
 }
 step++;
 let cnt=0;
 for(let p=0;p<N;p++){
  rest[p]=0;
  if(!grid[p])continue;
  const y=(p/W)|0,x=p-y*W,b=p+W;
  if(y===H-1||(grid[b]&&(x===0||grid[b-1])&&(x===W-1||grid[b+1]))){rest[p]=1;cnt++;}
 }
 resting=cnt;
 let blocked=true;
 for(const x of src)if(!grid[x])blocked=false;
 if(blocked)idle+=3;
 else if(total>=cap&&resting===total)idle+=2;
 else idle=0;
 if(idle>110)reset();
}
function draw(){
 buf.fill(BG);
 for(let p=0;p<N;p++)if(grid[p])buf[p]=rest[p]?pal[shade[p]]:mov;
 ctx.putImageData(img,0,0);
 eS.textContent=step.toLocaleString();
 eR.textContent=resting.toLocaleString();
 eG.textContent=total.toLocaleString();
 eN.textContent=run;
}
let last=0,acc=0;
function frame(t){
 requestAnimationFrame(frame);
 if(!last)last=t;
 acc+=Math.min(120,t-last);last=t;
 let k=0;
 while(acc>=16.6&&k<4){tick();acc-=16.6;k++;}
 draw();
}
reset();requestAnimationFrame(frame);
</script>
</body>
</html>