Nemotron 3 Nano Omni (free)

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Snake Game</title>
<style>
  body {
    margin: 0;
    display: flex;
    justify-content: center;
    align-items: center;
    min-height: 100vh;
    background: #111;
    font-family: Arial, sans-serif;
    color: #fff;
  }
  canvas {
    background: #222;
    border: 2px solid #555;
  }
  #overlay {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    font-size: 2rem;
    color: #ff0;
    pointer-events: none;
    opacity: 0;
    transition: opacity 0.3s;
  }
  #overlay.show {
    opacity: 1;
    pointer-events: all;
  }
</style>
</head>
<body>
<canvas id="game" width="600" height="600"></canvas>
<div id="overlay">Game Over<br>Score: <span id="score">0</span><br>Best: <span id="best">0</span><br>Press Space or Enter to Restart</div>

<script>
(() => {
  const canvas = document.getElementById('game');
  const ctx = canvas.getContext('2d');
  const overlay = document.getElementById('overlay');
  const scoreEl = document.getElementById('score');
  const bestEl = document.getElementById('best');

  const GRID_SIZE = 20;
  const CELL_PX = canvas.width / GRID_SIZE;
  const DIRECTIONS = {
    ArrowUp: {x:0, y:-1},
    ArrowDown: {x:0, y:1},
    ArrowLeft: {x:-1, y:0},
    ArrowRight: {x:1, y:0},
    w: {x:-1, y:0},
    a: {x:-1, y:0},
    s: {x:0, y:1},
    d: {x:1, y:0}
  };
  let snake = [{x: 9, y: 9}];
  let dir = {x:0, y:0};
  let nextDir = {x:0, y:0};
  let food = randomFood();
  let score = 0;
  let best = 0;
  let gameRunning = false;
  let isPaused = false;

  function randomFood() {
    let pos;
    do {
      pos = {
        x: Math.floor(Math.random() * GRID_SIZE),
        y: Math.floor(Math.random() * GRID_SIZE)
      };
    } while (snake.some(s => s.x === pos.x && s.y === pos.y));
    return pos;
  }

  function update() {
    if (!gameRunning) return;
    if (isPaused) return;

    dir = nextDir;

    const newHead = {
      x: snake[0].x + dir.x,
      y: snake[0].y + dir.y
    };

    // wall collision
    if (newHead.x < 0 || newHead.x >= GRID_SIZE || newHead.y < 0 || newHead.y >= GRID_SIZE) {
      endGame();
      return;
    }

    // self collision
    if (snake.some(s => s.x === newHead.x && s.y === newHead.y)) {
      endGame();
      return;
    }

    snake.unshift(newHead);

    if (newHead.x === food.x && newHead.y === food.y) {
      score += 10;
      scoreEl.textContent = score;
      if (score > best) {
        best = score;
        bestEl.textContent = best;
      }
      food = randomFood();
      spawnParticles(newHead);
    } else {
      snake.pop();
    }
  }

  function spawnParticles(pos) {
    const particles = 12;
    for (let i = 0; i < particles; i++) {
      const p = {
        x: pos.x + (Math.random() - 0.5) * 0.5,
        y: pos.y + (Math.random() - 0.5) * 0.5,
        life: 1,
        size: 2 + Math.random() * 3
      };
      particlesList.push(p);
    }
  }

  const particles = [];

  function updateParticles() {
    for (let i = particles.length - 1; i >= 0; i--) {
      const p = particles[i];
      p.life -= 0.02;
      p.size *= 0.98;
      if (p.life <= 0) {
        particles.splice(i, 1);
      }
    }
  }

  function draw() {
    // clear
    ctx.fillStyle = '#222';
    ctx.fillRect(0, 0, canvas.width, canvas.height);

    // draw food
    ctx.fillStyle = '#f00';
    ctx.beginPath();
    ctx.arc(
      (food.x + 0.5) * CELL_PX + CELL_PX/2,
      (food.y + 0.5) * CELL_PX + CELL_PX/2,
      CELL_PX/2 - 2, 0, Math.PI*2);
    ctx.fill();

    // draw snake
    snake.forEach((segment, idx) => {
      const x = segment.x + 0.5;
      const y = segment.y + 0.5;
      const cx = x * CELL_PX + CELL_PX/2;
      const cy = y * CELL_PX + CELL_PX/2;

      // body
      ctx.fillStyle = (idx===0) ? '#0f0' : '#0a0';
      ctx.fillRect(cx - CELL_PX/2, cy - CELL_PX/2, CELL_PX, CELL_PX);

      // head eyes
      if (idx===0) {
        const eyeSize = CELL_PX * 0.2;
        ctx.fillStyle = '#fff';
        const dirX = Math.abs(dir.x);
        const dirY = Math.abs(dir.y);
        const eyeX = dirX > dirY ? cx - eyeSize : cx + eyeSize;
        const eyeY = dirY > dirX ? cy - eyeSize : cy + eyeSize;
        ctx.fillRect(eyeX, cy - eyeSize/2, eyeSize/2, eyeSize/2);
        ctx.fillRect(cx - eyeSize/2, eyeY, eyeSize/2, eyeSize/2);
      }
    });

    // draw particles
    particles.forEach(p => {
      ctx.fillStyle = `rgba(255,255,255,${p.life})`;
      ctx.beginPath();
      ctx.arc(
        (p.x + 0.5) * CELL_PX + CELL_PX/2,
        (p.y + 0.5) * CELL_PX + CELL_PX/2,
        p.size, 0, Math.PI*2);
      ctx.fill();
    });
  }

  function loop() {
    update();
    draw();
    requestAnimationFrame(loop);
  }

  function startGame() {
    snake = [{x: 9, y: 9}];
    dir = {x:0, y:0};
    nextDir = {x:0, y:0};
    food = randomFood();
    score = 0;
    scoreEl.textContent = score;
    best = Math.max(best, score);
    bestEl.textContent = best;
    gameRunning = true;
    isPaused = false;
    overlay.classList.remove('show');
  }

  function endGame() {
    gameRunning = false;
    overlay.classList.add('show');
  }

  function handleKey(e) {
    if (!gameRunning) {
      if (e.code === 'Space' || e.code === 'Enter') {
        startGame();
      }
      return;
    }

    if (e.code in DIRECTIONS) {
      const newDir = DIRECTIONS[e.code];
      if (newDir.x === -dir.x && newDir.y === -dir.y) return; // prevent reverse
      nextDir = newDir;
    }

    if (e.code === 'KeyP') {
      isPaused = !isPaused;
    }
  }

  // input
  window.addEventListener('keydown', handleKey);
  canvas.addEventListener('click', () => {
    if (!gameRunning) startGame();
  });

  // init
  best = Math.max(best, score);
  bestEl.textContent = best;
  requestAnimationFrame(loop);
})();
</script>
</body>
</html>