diff --git a/README.md b/README.md
index f158751..975fd92 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,17 @@
 <div align="center">
 
-<img src="assets/logo-mark.png" alt="pixelcat logo" width="112" />
+<img src="assets/logo-mark.png" alt="pixelpets logo" width="112" />
 
-# pixelcat
+# pixelpets
 
-### A pixel cat that lives on your desktop.
+### A pixel cat or dog that lives on your desktop.
 
 It sits in the corner, watches your cursor, kneads the keyboard when you type,
-purrs when you pet it, and stretches like mochi when you drag it. A desktop pet
-built from scratch: nearly every sprite, animation, and sound is original and procedural.
+purrs when you pet it, and stretches like mochi when you drag it. Prefer a dog?
+Switch species from the tray and you get a real one: 14 breeds, a wagging tail
+that reads your pet's mood, a play bow instead of a hunting crouch, and a tennis
+ball it will actually chase down and bring back. A desktop pet built from
+scratch: nearly every sprite, animation, and sound is original and procedural.
 
 <br />
 
@@ -34,6 +37,32 @@ built from scratch: nearly every sprite, animation, and sound is original and pr
 
 </div>
 
+## Two pets, one app
+
+Pick your species from the tray (**Pet → Cat / Dog**). Each one keeps its own
+coat choice, so switching back and forth never loses your pick.
+
+|  | Cat | Dog |
+|---|---|---|
+| Coats | 14 coats, from Orange Tabby to Russian Blue | 14 breeds, from Golden Retriever to Chihuahua |
+| Resting | loafs into a "cat bread" | curls nose-to-tail into a ring |
+| Excited | hunting crouch, ears back | **play bow**: chest down, rump up, tail flagged |
+| Tail | slow rolling S-curve, tip flicks | fast wag from the base, shaped per breed (curl / plume / feather / stub / straight) |
+| Play | bats a butterfly | **fetch**: chases the thrown ball, carries it home, drops it |
+| After exertion | grooms | pants, tongue out |
+| Reward | a fish treat | a tennis ball |
+
+The dog is not a recoloured cat. It has its own sprite module with a muzzle that
+protrudes past the skull line, ears that hang or perk per breed, a broader chest,
+and short legs on the dwarf breeds. Markings are coat *structures*, not palette
+swaps: the Dalmatian is spotted, the shepherd wears a saddle, the beagle is
+tricolour, the husky has a mask, and the Aussie is merle.
+
+```bash
+npm run sheet:dog   # renders previews/dog-sheet.png - every breed x every pose
+npm run sheet:cat
+```
+
 ## See it in action
 
 <table align="center">
diff --git a/eslint.config.js b/eslint.config.js
index ebd6785..bc88171 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -9,6 +9,13 @@ const sharedOverlay = {
   CELL: 'readonly', setCell: 'readonly', ellipse: 'readonly', triangle: 'readonly',
   outlineHalo: 'readonly', eyeBox: 'readonly', muzzlePt: 'readonly', buildSprite: 'readonly',
   composeSit: 'readonly', PATTERNS: 'readonly', PATTERN_NAMES: 'readonly',
+  // dog-sprite.js (loaded after cat-sprite.js) provides the canine composers + tables:
+  composeSitDog: 'readonly', composeBowDog: 'readonly', composeTypeDog: 'readonly',
+  composeCurlDog: 'readonly', composeBegDog: 'readonly', applyMarking: 'readonly',
+  DOG_PATTERNS: 'readonly', DOG_BUILDS: 'readonly', DOG_PATTERN_BUILD: 'readonly', DOG_TAILS: 'readonly',
+  // pets.js provides the species registry:
+  PET_SPECIES: 'readonly', SPECIES_IDS: 'readonly', speciesOf: 'readonly', coatsFor: 'readonly',
+  isSpecies: 'readonly', defaultCoatIndex: 'readonly', CAT_COATS: 'readonly', DOG_COATS: 'readonly',
   BUILDS: 'readonly', TABBY: 'readonly', PATTERN_BUILD: 'readonly',
   BODY: 'readonly', G: 'readonly', GC: 'readonly', GR: 'readonly', HALO: 'readonly',
   rgbStr: 'readonly', toRgb: 'readonly', shadeStr: 'readonly', lerpHex: 'readonly',
@@ -31,7 +38,7 @@ module.exports = [
   {
     // Node / CommonJS: main process, workers, scripts, tests, configs, template.js
     files: ['**/*.js'],
-    ignores: [...CONSUMER_OVERLAY, 'src/cat-sprite.js', 'src/patterns.js', 'src/audio.js', 'src/effects.js', 'src/jam.js'],
+    ignores: [...CONSUMER_OVERLAY, 'src/cat-sprite.js', 'src/dog-sprite.js', 'src/patterns.js', 'src/pets.js', 'src/audio.js', 'src/effects.js', 'src/jam.js'],
     languageOptions: { sourceType: 'commonjs', ecmaVersion: 2023, globals: { ...globals.node } },
   },
   {
@@ -58,7 +65,7 @@ module.exports = [
   {
     // cat-sprite.js / patterns.js are dual-loaded: classic <script> in the overlay AND
     // CommonJS modules in Node (make-app-icon.js / main.js). They DEFINE shared globals.
-    files: ['src/cat-sprite.js', 'src/patterns.js'],
+    files: ['src/cat-sprite.js', 'src/dog-sprite.js', 'src/patterns.js', 'src/pets.js'],
     languageOptions: { sourceType: 'commonjs', ecmaVersion: 2023, globals: { ...globals.node, ...globals.browser } },
   },
   {
diff --git a/package.json b/package.json
index 439f441..637c21a 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
-  "name": "pixelcat",
+  "name": "pixelpets",
   "version": "0.2.0",
-  "description": "A pixel cat that lives on your desktop",
+  "description": "A pixel cat or dog that lives on your desktop",
   "main": "src/main.js",
   "author": "JOhnsonKC201",
   "license": "MIT",
@@ -13,6 +13,8 @@
     "start": "electron .",
     "autostart:off": "electron . --autostart=off",
     "sheet": "electron . --sheet",
+    "sheet:dog": "node scripts/pet-sheet.js dog",
+    "sheet:cat": "node scripts/pet-sheet.js cat",
     "icon": "node scripts/make-logo-icons.js",
     "social": "node scripts/make-social-card.js",
     "climb-frames": "node scripts/embed-climb-frames.js",
@@ -45,7 +47,7 @@
   },
   "build": {
     "appId": "com.johnsonkc.pixelcat",
-    "productName": "pixelcat",
+    "productName": "pixelpets",
     "npmRebuild": false,
     "directories": {
       "output": "dist"
diff --git a/scripts/pet-sheet.js b/scripts/pet-sheet.js
new file mode 100644
index 0000000..229c77d
--- /dev/null
+++ b/scripts/pet-sheet.js
@@ -0,0 +1,113 @@
+// Headless QA contact sheet: renders every breed x pose for a species straight to
+// a PNG, with no Electron and no canvas dependency. This is how the dog poses get
+// checked while they are being drawn - reading grid code cannot tell you whether a
+// silhouette actually reads as a dog.
+//   node scripts/pet-sheet.js dog   -> previews/dog-sheet.png
+//   node scripts/pet-sheet.js cat   -> previews/cat-sheet.png
+const fs = require('fs');
+const zlib = require('zlib');
+const path = require('path');
+
+const cat = require('../src/cat-sprite.js');
+const dog = require('../src/dog-sprite.js');
+dog.attach(cat);   // the dog module composes with cat-sprite's grid primitives
+
+const SCALE = 3;                 // px per sprite cell in the sheet
+const PAD = 10;
+const BG = [24, 26, 34, 255];
+
+const SPECIES = {
+  cat: {
+    patterns: cat.PATTERNS,
+    build: cat.PATTERN_BUILD,
+    builds: cat.BUILDS,
+    extra: (i) => ({ tabby: cat.TABBY[i] }),
+    poses: [
+      ['sit', 24, 30, (B) => cat.composeSit(B)],
+    ],
+  },
+  dog: {
+    patterns: dog.DOG_PATTERNS,
+    build: dog.DOG_PATTERN_BUILD,
+    builds: dog.DOG_BUILDS,
+    extra: () => ({}),
+    poses: [
+      ['sit', 24, 30, (B) => dog.composeSitDog(B)],
+      ['bow', 30, 22, (B) => dog.composeBowDog(B)],
+      ['type', 24, 24, (B) => dog.composeTypeDog(B)],
+      ['curl', 24, 30, (B) => dog.composeCurlDog(B)],
+      ['beg', 24, 30, (B) => dog.composeBegDog(B)],
+    ],
+  },
+};
+
+// role char -> palette key
+const ROLE = { C: 'coat', K: 'mark', W: 'white', X: 'patch', I: 'inner', N: 'nose', E: 'eye', O: 'outline', T: 'tongue' };
+
+function hexToRgb(h) { const n = parseInt(String(h).slice(1), 16); return [(n >> 16) & 255, (n >> 8) & 255, n & 255]; }
+
+function blitSprite(buf, W, sp, ox, oy, pal) {
+  for (let r = 0; r < sp.ROWS; r++) for (let c = 0; c < sp.COLS; c++) {
+    const ch = sp.grid[r][c];
+    if (ch === '.') continue;
+    let rgb, a = 255;
+    if (ch === 'H') { rgb = [251, 253, 255]; a = 110; }
+    else {
+      const key = ROLE[ch];
+      if (!key || !pal[key]) continue;
+      rgb = hexToRgb(pal[key]);
+      // same top-lit body shading the renderer uses, so the sheet matches the app
+      if ('CKWXI'.includes(ch)) { const f = Math.max(0.82, 1.12 - (r / sp.ROWS) * 0.34); rgb = rgb.map((v) => Math.min(255, Math.round(v * f))); }
+      else if (ch === 'O') { const f = 1.16 - (r / sp.ROWS) * 0.30; rgb = rgb.map((v) => Math.min(255, Math.round(v * f))); }
+    }
+    for (let dy = 0; dy < SCALE; dy++) for (let dx = 0; dx < SCALE; dx++) {
+      const X = ox + c * SCALE + dx, Y = oy + r * SCALE + dy;
+      const i = (Y * W + X) * 4, al = a / 255;
+      buf[i] = Math.round(rgb[0] * al + buf[i] * (1 - al));
+      buf[i + 1] = Math.round(rgb[1] * al + buf[i + 1] * (1 - al));
+      buf[i + 2] = Math.round(rgb[2] * al + buf[i + 2] * (1 - al));
+      buf[i + 3] = 255;
+    }
+  }
+}
+
+function crc(b) { let c = ~0; for (let i = 0; i < b.length; i++) { c ^= b[i]; for (let k = 0; k < 8; k++) c = (c >>> 1) ^ (0xEDB88320 & -(c & 1)); } return ~c >>> 0; }
+function chunk(t, d) { const l = Buffer.alloc(4); l.writeUInt32BE(d.length, 0); const b = Buffer.concat([Buffer.from(t), d]); const cc = Buffer.alloc(4); cc.writeUInt32BE(crc(b), 0); return Buffer.concat([l, b, cc]); }
+function encodePng(rgba, w, h) {
+  const ih = Buffer.alloc(13); ih.writeUInt32BE(w, 0); ih.writeUInt32BE(h, 4); ih[8] = 8; ih[9] = 6;
+  const stride = w * 4, raw = Buffer.alloc(h * (stride + 1));
+  for (let y = 0; y < h; y++) { raw[y * (stride + 1)] = 0; for (let x = 0; x < stride; x++) raw[y * (stride + 1) + 1 + x] = rgba[y * stride + x]; }
+  return Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), chunk('IHDR', ih), chunk('IDAT', zlib.deflateSync(raw, { level: 9 })), chunk('IEND', Buffer.alloc(0))]);
+}
+
+function main() {
+  const which = (process.argv[2] || 'dog').toLowerCase();
+  const S = SPECIES[which];
+  if (!S) { console.error(`unknown species "${which}" (expected cat|dog)`); process.exit(1); }
+
+  const maxW = Math.max(...S.poses.map((p) => p[1])) * SCALE;
+  const maxH = Math.max(...S.poses.map((p) => p[2])) * SCALE;
+  const cellW = maxW + PAD, cellH = maxH + PAD;
+  const W = S.poses.length * cellW + PAD, H = S.patterns.length * cellH + PAD;
+
+  const buf = new Uint8ClampedArray(W * H * 4);
+  for (let i = 0; i < W * H; i++) { buf[i * 4] = BG[0]; buf[i * 4 + 1] = BG[1]; buf[i * 4 + 2] = BG[2]; buf[i * 4 + 3] = 255; }
+
+  S.patterns.forEach((pal, i) => {
+    const B = { ...S.builds[S.build[i]], ...S.extra(i) };
+    S.poses.forEach(([, cols, rows, compose], j) => {
+      const sp = cat.buildSprite(cols, rows, () => compose(B));
+      const ox = PAD + j * cellW + Math.floor((maxW - cols * SCALE) / 2);
+      const oy = PAD + i * cellH + (maxH - rows * SCALE);
+      blitSprite(buf, W, sp, ox, oy, pal);
+    });
+  });
+
+  const out = path.join(__dirname, '..', 'previews', `${which}-sheet.png`);
+  fs.mkdirSync(path.dirname(out), { recursive: true });
+  fs.writeFileSync(out, encodePng(buf, W, H));
+  console.log(`${out}  (${W}x${H})  ${S.patterns.length} breeds x ${S.poses.length} poses`);
+  S.patterns.forEach((p, i) => console.log(`  ${String(i).padStart(2)} ${p.name.padEnd(22)} ${S.build[i]}`));
+}
+
+main();
diff --git a/site/cat-preview.js b/site/cat-preview.js
index f57270e..091416f 100644
--- a/site/cat-preview.js
+++ b/site/cat-preview.js
@@ -2,9 +2,12 @@
 // come from the shared cat-sprite.js (loaded first); this only adds the static
 // single-frame sit-sprite draw. Ported verbatim from src/cat-preview.js so the
 // gallery cats match the desktop sprite exactly. Exposes
-// window.PixelcatPreview = { PATTERNS, PATTERN_BUILD, TABBY, BUILDS, draw }.
+// window.PixelcatPreview = { PATTERNS, PATTERN_BUILD, TABBY, BUILDS, draw, drawDog }.
+// drawDog is a no-op on the site: it guards on composeSitDog, which the site's
+// cat-sprite.js bundle does not define.
 (function () {
-  function drawCatStatic(g, sp, palRGB) {
+  function drawCatStatic(g, sp, palRGB, opts) {
+    const noWhiskers = !!(opts && opts.noWhiskers);
     const grid = sp.grid, COLS = sp.COLS, ROWS = sp.ROWS;
     for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
       const ch = grid[r][c]; if (ch === '.') continue;
@@ -13,9 +16,11 @@
       g.fillStyle = f === 1 ? rgbStr(base) : shadeStr(base, f);
       g.fillRect(c * CELL, r * CELL, CELL, CELL);
     }
-    g.strokeStyle = 'rgba(245,245,245,0.6)'; g.lineWidth = 1; g.lineCap = 'round';
-    const my = sp.muzzle.y, cl = sp.muzzle.x - 4.5 * CELL, cr = sp.muzzle.x + 4.5 * CELL;
-    for (const [sx, dir] of [[cl, -1], [cr, 1]]) for (let i = 0; i < 3; i++) { g.beginPath(); g.moveTo(sx, my + i * 3 - 2); g.lineTo(sx + dir * 13, my + i * 5 - 1); g.stroke(); }
+    if (!noWhiskers) {
+      g.strokeStyle = 'rgba(245,245,245,0.6)'; g.lineWidth = 1; g.lineCap = 'round';
+      const my = sp.muzzle.y, cl = sp.muzzle.x - 4.5 * CELL, cr = sp.muzzle.x + 4.5 * CELL;
+      for (const [sx, dir] of [[cl, -1], [cr, 1]]) for (let i = 0; i < 3; i++) { g.beginPath(); g.moveTo(sx, my + i * 3 - 2); g.lineTo(sx + dir * 13, my + i * 5 - 1); g.stroke(); }
+    }
     for (const e of sp.eyes) {
       if (!isFinite(e.cx) || e.w <= 0) continue;
       const pw = Math.max(4, Math.round(e.w * 0.46)), ph = Math.max(5, Math.round(e.h * 0.7));
@@ -39,5 +44,20 @@
     const dw = sp.SW * scale, dh = sp.SH * scale;
     ctx.drawImage(oc, 0, 0, sp.SW, sp.SH, (canvas.width - dw) / 2, (canvas.height - dh) / 2, dw, dh);
   }
-  window.PixelcatPreview = { PATTERNS, PATTERN_BUILD, TABBY, BUILDS, draw };
+  // Same preview for the dog, using the canine composer and no whiskers.
+  function drawDog(canvas, pal, build) {
+    if (!canvas || !pal || typeof composeSitDog !== 'function') return;
+    const ctx = canvas.getContext('2d'); ctx.imageSmoothingEnabled = false;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    const B = Object.assign({}, DOG_BUILDS[build] || DOG_BUILDS[DOG_PATTERN_BUILD[0]]);
+    const sp = buildSprite(24, 30, () => composeSitDog(B));
+    const palRGB = { O: toRgb(pal.outline), C: toRgb(pal.coat), K: toRgb(pal.mark), W: toRgb(pal.white), X: toRgb(pal.patch), I: toRgb(pal.inner), N: toRgb(pal.nose), E: toRgb(pal.eye), H: toRgb(HALO), T: toRgb(pal.tongue || '#e8747f') };
+    const oc = document.createElement('canvas'); oc.width = sp.SW; oc.height = sp.SH;
+    const octx = oc.getContext('2d'); octx.imageSmoothingEnabled = false;
+    drawCatStatic(octx, sp, palRGB, { noWhiskers: true });
+    const scale = Math.min((canvas.width - 8) / sp.SW, (canvas.height - 8) / sp.SH);
+    const dw = sp.SW * scale, dh = sp.SH * scale;
+    ctx.drawImage(oc, 0, 0, sp.SW, sp.SH, (canvas.width - dw) / 2, (canvas.height - dh) / 2, dw, dh);
+  }
+  window.PixelcatPreview = { PATTERNS, PATTERN_BUILD, TABBY, BUILDS, draw, drawDog };
 })();
diff --git a/src/cat-preview.js b/src/cat-preview.js
index c6f1ec8..34bc8c4 100644
--- a/src/cat-preview.js
+++ b/src/cat-preview.js
@@ -4,7 +4,8 @@
 // BUILDS, draw } (the palette arrays are re-exported from cat-sprite for the
 // settings dropdown/preview).
 (function () {
-  function drawCatStatic(g, sp, palRGB) {
+  function drawCatStatic(g, sp, palRGB, opts) {
+    const noWhiskers = !!(opts && opts.noWhiskers);
     const grid = sp.grid, COLS = sp.COLS, ROWS = sp.ROWS;
     for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
       const ch = grid[r][c]; if (ch === '.') continue;
@@ -13,9 +14,11 @@
       g.fillStyle = f === 1 ? rgbStr(base) : shadeStr(base, f);
       g.fillRect(c * CELL, r * CELL, CELL, CELL);
     }
-    g.strokeStyle = 'rgba(245,245,245,0.6)'; g.lineWidth = 1; g.lineCap = 'round';
-    const my = sp.muzzle.y, cl = sp.muzzle.x - 4.5 * CELL, cr = sp.muzzle.x + 4.5 * CELL;
-    for (const [sx, dir] of [[cl, -1], [cr, 1]]) for (let i = 0; i < 3; i++) { g.beginPath(); g.moveTo(sx, my + i * 3 - 2); g.lineTo(sx + dir * 13, my + i * 5 - 1); g.stroke(); }
+    if (!noWhiskers) {
+      g.strokeStyle = 'rgba(245,245,245,0.6)'; g.lineWidth = 1; g.lineCap = 'round';
+      const my = sp.muzzle.y, cl = sp.muzzle.x - 4.5 * CELL, cr = sp.muzzle.x + 4.5 * CELL;
+      for (const [sx, dir] of [[cl, -1], [cr, 1]]) for (let i = 0; i < 3; i++) { g.beginPath(); g.moveTo(sx, my + i * 3 - 2); g.lineTo(sx + dir * 13, my + i * 5 - 1); g.stroke(); }
+    }
     for (const e of sp.eyes) {
       if (!isFinite(e.cx) || e.w <= 0) continue;
       const pw = Math.max(4, Math.round(e.w * 0.46)), ph = Math.max(5, Math.round(e.h * 0.7));
@@ -39,5 +42,20 @@
     const dw = sp.SW * scale, dh = sp.SH * scale;
     ctx.drawImage(oc, 0, 0, sp.SW, sp.SH, (canvas.width - dw) / 2, (canvas.height - dh) / 2, dw, dh);
   }
-  window.PixelcatPreview = { PATTERNS, PATTERN_BUILD, TABBY, BUILDS, draw };
+  // Same preview for the dog, using the canine composer and no whiskers.
+  function drawDog(canvas, pal, build) {
+    if (!canvas || !pal || typeof composeSitDog !== 'function') return;
+    const ctx = canvas.getContext('2d'); ctx.imageSmoothingEnabled = false;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    const B = Object.assign({}, DOG_BUILDS[build] || DOG_BUILDS[DOG_PATTERN_BUILD[0]]);
+    const sp = buildSprite(24, 30, () => composeSitDog(B));
+    const palRGB = { O: toRgb(pal.outline), C: toRgb(pal.coat), K: toRgb(pal.mark), W: toRgb(pal.white), X: toRgb(pal.patch), I: toRgb(pal.inner), N: toRgb(pal.nose), E: toRgb(pal.eye), H: toRgb(HALO), T: toRgb(pal.tongue || '#e8747f') };
+    const oc = document.createElement('canvas'); oc.width = sp.SW; oc.height = sp.SH;
+    const octx = oc.getContext('2d'); octx.imageSmoothingEnabled = false;
+    drawCatStatic(octx, sp, palRGB, { noWhiskers: true });
+    const scale = Math.min((canvas.width - 8) / sp.SW, (canvas.height - 8) / sp.SH);
+    const dw = sp.SW * scale, dh = sp.SH * scale;
+    ctx.drawImage(oc, 0, 0, sp.SW, sp.SH, (canvas.width - dw) / 2, (canvas.height - dh) / 2, dw, dh);
+  }
+  window.PixelcatPreview = { PATTERNS, PATTERN_BUILD, TABBY, BUILDS, draw, drawDog };
 })();
diff --git a/src/config.js b/src/config.js
index 32f5051..7e78b1d 100644
--- a/src/config.js
+++ b/src/config.js
@@ -7,12 +7,16 @@ const fs = require('fs');
 const path = require('path');
 
 const { PATTERN_NAMES } = require('./patterns');
+const { isSpecies, coatsFor, defaultCoatIndex } = require('./pets');
 const MAX_PATTERN = PATTERN_NAMES.length - 1;
 const DEFAULT_PATTERN = Math.max(0, PATTERN_NAMES.indexOf('Tuxedo'));   // tuxedo is the out-of-box coat
 
 const DEFAULTS = {
   name: '',
+  species: 'cat',      // 'cat' | 'dog' - which pet lives on the desktop
   pattern: DEFAULT_PATTERN,
+  dogPattern: defaultCoatIndex('dog'),  // the dog's breed, kept separately so switching
+                                        // species back and forth never loses either choice
   breakMinutes: 0,     // 0 = break timer off
   soundOn: true,
   huntOn: true,        // Comnyang hunts the cursor by default; user-toggleable
@@ -66,7 +70,9 @@ function normalize(cfg) {
   const reminders = Array.isArray(c.reminders) ? c.reminders : [];
   return {
     name: String(c.name == null ? '' : c.name).trim().slice(0, 24),
+    species: isSpecies(c.species) ? c.species : 'cat',
     pattern: clampInt(c.pattern, 0, MAX_PATTERN, DEFAULT_PATTERN),
+    dogPattern: clampInt(c.dogPattern, 0, coatsFor('dog').length - 1, defaultCoatIndex('dog')),
     breakMinutes: clampInt(c.breakMinutes, 0, 240, 0),
     soundOn: c.soundOn === undefined ? true : !!c.soundOn,
     huntOn: c.huntOn === undefined ? true : !!c.huntOn,
diff --git a/src/dog-sprite.js b/src/dog-sprite.js
new file mode 100644
index 0000000..ac5ffb7
--- /dev/null
+++ b/src/dog-sprite.js
@@ -0,0 +1,459 @@
+// Shared dog-sprite core - the dog counterpart to cat-sprite.js. Loaded as a
+// classic script by the overlay (index.html) and the settings window
+// (settings.html), so it reads cat-sprite.js's grid primitives (setCell/ellipse/
+// triangle/buildSprite) as bare identifiers off the shared global lexical scope.
+// cat-sprite.js MUST be loaded first. Also required as a CommonJS module by the
+// icon/preview scripts, which pass those primitives in via `attach()`.
+//
+// A dog is NOT a recoloured cat. Four things carry the read at this size:
+//   1. a muzzle that PROTRUDES past the skull line (cats are flat-faced here)
+//   2. ears that hang or flop rather than sit as sharp triangles
+//   3. a broader chest and a thicker neck
+//   4. a nose that is big, dark, and sits at the TIP of the snout
+// Everything below is in service of those four.
+
+// In the browser these come from cat-sprite.js's global scope. In Node the
+// module has no globals to read, so `attach()` injects them before use.
+/* global CELL, setCell, ellipse, triangle, buildSprite */
+let P = null;   // primitives, when running under Node
+const _c = () => (P || { CELL, setCell, ellipse, triangle, buildSprite });
+
+// ---- sitting dog ------------------------------------------------------------
+// Parametric like composeSit: a build descriptor B varies the silhouette so each
+// breed is a different DOG, not a palette swap.
+//   B = { bodyW, headRx, headRy, snoutRx, snoutRy, snoutY, ear, legLen,
+//         eyeRx, eyeRy, brows, fluff, marking }
+function composeSitDog(B) {
+  const { setCell, ellipse, triangle } = _c();
+  B = B || {};
+  const CX = 12;
+  const bw = B.bodyW || 1;
+  // Head deliberately SMALLER than the cat's relative to the body. An oversized
+  // round skull is what makes a small pixel quadruped read as a meerkat or a
+  // teddy; a dog's head is roughly a third of its seated height.
+  const headRx = B.headRx || 5.6, headRy = B.headRy || 4.7;
+  const headY = 6.8;
+  const snoutRx = B.snoutRx || 3.3, snoutRy = B.snoutRy || 2.8;
+  const snoutY = B.snoutY == null ? 10.6 : B.snoutY;
+  const ear = B.ear || 'floppy';
+  const legLen = B.legLen == null ? 1 : B.legLen;
+  const eRx = B.eyeRx || 1.7, eRy = B.eyeRy || 1.8;
+  const fluff = !!B.fluff;
+
+  // --- body: rump, then a BROAD chest, then a neck ---------------------------
+  // The chest is the tell. A cat's sitting silhouette tapers to a narrow front;
+  // a dog's flares out. The neck sits LOW so it never swallows the muzzle - that
+  // was what flattened the face into a cat's in the first pass.
+  ellipse(CX, 25.6, 7.7 * bw, 4.4, 'C');                       // haunch / seated rump
+  ellipse(CX, 20.0, 5.9 * bw, 6.2, 'C');                       // chest (wider than the cat's 5.2)
+  ellipse(CX, 15.2, 3.7 * bw, 3.0, 'C');                       // neck
+  if (fluff) { ellipse(CX - 5.2 * bw, 18.0, 2.2, 3.2, 'C'); ellipse(CX + 5.2 * bw, 18.0, 2.2, 3.2, 'C'); }  // shoulder floof
+
+  // --- hanging ears go BEHIND the skull so they read as attached -------------
+  // They must extend clearly BELOW the jaw or they just look like a lumpy head.
+  const earOx = headRx - 0.6;
+  if (ear === 'floppy' || ear === 'long' || ear === 'round') {
+    const drop = ear === 'long' ? 5.6 : ear === 'round' ? 3.6 : 4.4;
+    const eyC = ear === 'long' ? 10.4 : ear === 'round' ? 7.6 : 9.0;
+    const exr = ear === 'round' ? 2.6 : 2.2;
+    ellipse(CX - earOx, eyC, exr, drop, 'K');
+    ellipse(CX + earOx, eyC, exr, drop, 'K');
+  }
+
+  // --- skull ---------------------------------------------------------------
+  ellipse(CX, headY, headRx, headRy, 'C');
+
+  // --- perked ears sit ON TOP of the skull ---------------------------------
+  // Dog perk-ears are broader at the base and less needle-like than a cat's.
+  if (ear === 'perk' || ear === 'semi' || ear === 'big') {
+    const ew = ear === 'big' ? 2.9 : 2.5, eo = ear === 'big' ? 3.9 : 3.6;
+    const apex = ear === 'big' ? -1.6 : ear === 'semi' ? 0.6 : -0.6;
+    triangle(CX - eo - 0.6, apex, CX - eo - ew, 7.4, CX - eo + ew, 5.6, 'K');
+    triangle(CX + eo + 0.6, apex, CX + eo + ew, 7.4, CX + eo - ew, 5.6, 'K');
+    const iw = ew * 0.5;
+    triangle(CX - eo - 0.4, apex + 2.0, CX - eo - iw, 6.9, CX - eo + iw, 5.8, 'I');
+    triangle(CX + eo + 0.4, apex + 2.0, CX + eo + iw, 6.9, CX + eo - iw, 5.8, 'I');
+    // semi-perk (collie / shiba): the top third folds forward over itself
+    if (ear === 'semi') {
+      ellipse(CX - eo - 0.2, apex + 1.2, 1.7, 1.3, 'K');
+      ellipse(CX + eo + 0.2, apex + 1.2, 1.7, 1.3, 'K');
+    }
+  }
+  // rose ear (pug/bulldog): a small folded nub tucked high on the skull
+  if (ear === 'rose') {
+    ellipse(CX - headRx + 0.8, 3.8, 1.8, 1.9, 'K');
+    ellipse(CX + headRx - 0.8, 3.8, 1.8, 1.9, 'K');
+  }
+
+  // --- THE SNOUT: the single most important dog cue -------------------------
+  // Drawn after the skull, centred low enough that its lower arc breaks the
+  // skull's silhouette. The carve pass at the bottom of this function then traces
+  // a jaw line around it, which is what actually sells the protrusion at 4px/cell.
+  ellipse(CX, snoutY, snoutRx, snoutRy, 'W');
+  if (B.snoutDark) ellipse(CX, snoutY - snoutRy * 0.2, snoutRx * 0.95, snoutRy * 0.78, 'K');   // muzzle mask (shepherd/husky/pug)
+
+  // nose: big, dark, and parked at the TIP of the snout, not up on the face
+  const noseY = snoutY - snoutRy * 0.30;
+  ellipse(CX, noseY, 1.6, 1.1, 'N');
+
+  // mouth: carved to '.' so outlineHalo() paints it dark on ANY coat, including
+  // solid blacks where a drawn line would vanish. A shallow dog grin, not a cat's
+  // tight w-mouth: a short stem under the nose, then two flares.
+  const my = Math.round(noseY + 1.4);
+  setCell(CX, my, '.');
+  setCell(CX - 1, my + 1, '.'); setCell(CX + 1, my + 1, '.');
+  setCell(CX - 2, my + 1, '.'); setCell(CX + 2, my + 1, '.');
+
+  // --- eyes ----------------------------------------------------------------
+  // Set wide and high on the skull, ABOVE the muzzle line, which is what gives a
+  // dog its forward-facing look. Smaller than the cat's - big round eyes read as
+  // kitten, not canine.
+  const eyeY = headY - 0.6;
+  ellipse(CX - 3.0, eyeY, eRx, eRy, 'E');
+  ellipse(CX + 3.0, eyeY, eRx, eRy, 'E');
+  // tan "eyebrow" pips - a strong breed cue on shepherds, beagles, rotties
+  if (B.brows) { ellipse(CX - 3.0, eyeY - 2.5, 1.3, 0.9, 'X'); ellipse(CX + 3.0, eyeY - 2.5, 1.3, 0.9, 'X'); }
+
+  // --- front legs + paws ----------------------------------------------------
+  // legLen shrinks for the dwarf breeds (corgi, dachshund) - short legs are the
+  // whole point of those silhouettes, so they scale rather than just recolour.
+  const pawY = 28.4;
+  const legRy = 5.0 * legLen, legCy = pawY - legRy * 0.84;
+  ellipse(CX - 2.3, legCy, 1.8, legRy, 'C');
+  ellipse(CX + 2.3, legCy, 1.8, legRy, 'C');
+  ellipse(CX - 2.3, pawY, 2.1, 1.7, 'W', ['C']);
+  ellipse(CX + 2.3, pawY, 2.1, 1.7, 'W', ['C']);
+
+  // --- chest blaze ----------------------------------------------------------
+  // Most dogs carry a lighter bib; on solid coats white==coat so this is a no-op.
+  ellipse(CX, 20.5, fluff ? 3.0 : 2.4, 4.8, 'W', ['C']);
+
+  applyMarking(B.marking, { cx: CX, top: 14.0, bot: 29.0, w: 6.6 * bw, headY, headRx });
+
+  // --- carve separations LAST so the halo traces them on every coat ----------
+  // This is the only way internal edges survive on solid blacks, where every
+  // drawn line is the same colour as the coat.
+  carveJaw(CX, snoutY, snoutRx, snoutRy);
+  if (ear === 'floppy' || ear === 'long' || ear === 'round') {
+    // seam each hanging ear off the cheek so it reads as a separate flap
+    const seamTop = Math.round(headY - 1), seamBot = Math.round(headY + headRy + 1.6);
+    for (let r = seamTop; r <= seamBot; r++) {
+      setCell(Math.round(CX - earOx + 2.0), r, '.');
+      setCell(Math.round(CX + earOx - 2.0), r, '.');
+    }
+  }
+  for (let r = 22; r <= 29; r++) setCell(CX, r, '.');                                  // between the front legs
+  for (let r = 24; r <= 29; r++) { setCell(CX - 5, r, '.'); setCell(CX + 5, r, '.'); }  // leg vs haunch
+  setCell(CX - 2, 29, '.'); setCell(CX + 2, 29, '.');                                   // toe splits
+}
+
+// Trace the underside of the muzzle so it reads as a volume standing proud of the
+// skull rather than a paler patch painted on a flat face. Used by every pose.
+function carveJaw(cx, sy, srx, sry) {
+  const { setCell } = _c();
+  const wide = Math.round(srx + 0.4);
+  for (let dc = -wide; dc <= wide; dc++) {
+    const t = dc / (wide || 1);
+    const r = Math.round(sy + sry * Math.sqrt(Math.max(0, 1 - t * t)) + 0.9);
+    setCell(cx + dc, r, '.');
+  }
+}
+
+// ---- breed markings ---------------------------------------------------------
+// Each is a distinct coat STRUCTURE, applied over the built body. Positions are
+// RELATIVE to a body box the calling pose describes, so the same breed composes
+// correctly whether it is sitting, bowing, curled or begging - absolute grid
+// coordinates would only ever be right for one pose.
+//   box = { cx, top, bot, w, headY, headRx }   (top/bot bound the torso+rump)
+function applyMarking(kind, box) {
+  const { setCell, ellipse } = _c();
+  if (!kind || kind === 'solid' || !box) return;
+  const { cx, top, bot, w } = box;
+  const headY = box.headY == null ? top - 4 : box.headY;
+  const headRx = box.headRx || 5.4;
+  const H = Math.max(1, bot - top);
+  const y = (f) => top + H * f;                 // fraction down the torso
+  const x = (f) => cx + w * f;                  // fraction across the half-width
+
+  if (kind === 'spots') {                                    // dalmatian
+    const pips = [[-0.62, 0.16], [-0.30, 0.44], [0.52, 0.28], [0.70, 0.62], [-0.66, 0.72],
+      [0.24, 0.06], [0.66, 0.02], [-0.10, 0.86], [0.34, 0.80], [-0.44, 0.32]];
+    for (const [fx, fy] of pips) ellipse(x(fx), y(fy), 1.2, 1.2, 'K', ['C', 'W']);
+    ellipse(cx - headRx * 0.72, headY - 0.4, 1.4, 1.3, 'K', ['C']);
+  } else if (kind === 'saddle') {                            // german shepherd: dark cape over the back
+    // A cape, not a coat of paint: it stops well short of the chest and the legs,
+    // otherwise the whole dog just turns black and the breed stops reading.
+    for (let r = Math.round(y(0.02)); r <= Math.round(y(0.68)); r++) {
+      const t = (r - y(0.02)) / Math.max(1, y(0.68) - y(0.02));
+      const half = w * (1.02 - t * 0.30);
+      for (let c = Math.round(cx - half); c <= Math.round(cx + half); c++) setCell(c, r, 'K');
+    }
+    ellipse(cx, y(0.42), w * 0.40, H * 0.36, 'C', ['K']);    // chest stays light under the cape
+  } else if (kind === 'tri') {                               // beagle / bernese: dark back + tan points
+    for (let r = Math.round(y(0.00)); r <= Math.round(y(0.46)); r++) {
+      const half = w * 0.98;
+      for (let c = Math.round(cx - half); c <= Math.round(cx + half); c++) setCell(c, r, 'K');
+    }
+    ellipse(cx, y(0.34), w * 0.44, H * 0.34, 'W', ['K']);
+    ellipse(x(-0.80), y(0.72), 1.8, 2.0, 'X', ['C', 'K']);
+    ellipse(x(0.80), y(0.72), 1.8, 2.0, 'X', ['C', 'K']);
+  } else if (kind === 'merle') {                             // australian shepherd: mottled patches
+    const blots = [[-0.72, 0.10], [0.62, 0.26], [-0.46, 0.62], [0.44, 0.76], [-0.14, 0.02], [0.78, 0.56], [-0.80, 0.86]];
+    for (const [fx, fy] of blots) ellipse(x(fx), y(fy), 1.8, 1.5, 'K', ['C']);
+    ellipse(cx + headRx * 0.66, headY - 0.2, 1.9, 1.8, 'K', ['C']);
+  } else if (kind === 'mask') {                              // husky: dark cap + goggle stripes
+    ellipse(cx, headY - 2.0, headRx * 0.94, 2.5, 'K', ['C']);
+    ellipse(cx - headRx * 0.80, headY + 1.0, 1.3, 2.3, 'K', ['C']);
+    ellipse(cx + headRx * 0.80, headY + 1.0, 1.3, 2.3, 'K', ['C']);
+  } else if (kind === 'patch') {                             // border collie / cow-patch
+    ellipse(x(-0.84), y(0.24), 2.7, H * 0.30, 'K', ['C', 'W']);
+    ellipse(x(0.78), y(0.70), 2.5, H * 0.22, 'K', ['C', 'W']);
+    ellipse(cx + headRx * 0.70, headY - 0.4, 2.2, 2.2, 'K', ['C']);
+  } else if (kind === 'points') {                            // rottweiler/dobie tan points, no cape
+    ellipse(cx, y(0.40), w * 0.34, H * 0.26, 'X', ['C', 'K']);
+    ellipse(x(-0.36), y(0.98), 1.9, 1.6, 'X', ['C', 'W']);
+    ellipse(x(0.36), y(0.98), 1.9, 1.6, 'X', ['C', 'W']);
+  } else if (kind === 'curly') {                             // poodle: scalloped rim reads as curls
+    // Nick the silhouette rather than dotting the middle - a curly coat shows at
+    // this size as a bumpy OUTLINE, and stray interior dots just look like dirt.
+    const rim = [[-0.96, 0.08], [0.96, 0.08], [-1.00, 0.40], [1.00, 0.40],
+      [-0.88, 0.72], [0.88, 0.72], [-0.66, 0.96], [0.66, 0.96]];
+    for (const [fx, fy] of rim) ellipse(x(fx), y(fy), 1.6, 1.6, 'C');
+    for (const [fx, fy] of rim) setCell(Math.round(x(fx)), Math.round(y(fy)), '.');
+  }
+}
+
+// ---- play bow (the dog answer to the cat's hunting crouch) -------------------
+// Front end flat on the floor, elbows down, rump HIGH, tail up. This is the
+// universal canine play invitation, so it is what the dog does when it wants to
+// chase the cursor or start a game of fetch.
+function composeBowDog(B) {
+  const { setCell, ellipse, triangle } = _c();
+  B = B || {};
+  const bw = B.bodyW || 1;
+  const ear = B.ear || 'floppy';
+  // 30x22, drawn in three-quarter profile facing LEFT. The whole read depends on
+  // one silhouette: a steep diagonal from a high rump down to a chest flat on the
+  // floor. Keep the rump strictly above the shoulders or it collapses into a loaf.
+  ellipse(22.0, 6.6, 4.8 * bw, 4.4, 'C');         // raised rump - the highest mass
+  ellipse(16.0, 11.4, 5.0 * bw, 3.4, 'C');        // back, raking steeply down to the front
+  ellipse(10.0, 15.6, 4.2, 3.0, 'C');             // shoulders, pressed flat to the floor
+  // tail flagged straight UP off the rump - with the chest down, this is the
+  // unmistakable read of a play bow rather than a dog simply lying down
+  for (let a = 0; a < 5; a++) ellipse(24.6 + a * 0.8, 4.4 - a * 1.05, 1.5 - a * 0.12, 1.5 - a * 0.12, 'C');
+  // rear legs folded under the hiked rump
+  ellipse(23.0, 14.6, 2.1, 4.2, 'C'); ellipse(23.0, 18.4, 2.3, 1.6, 'W', ['C']);
+  // front legs stretched FORWARD along the ground - the giveaway of a play bow
+  ellipse(7.0, 17.6, 3.6, 1.7, 'C'); ellipse(3.8, 18.0, 2.0, 1.5, 'W', ['C']);
+  ellipse(10.6, 18.2, 3.2, 1.6, 'C'); ellipse(7.8, 18.6, 1.9, 1.4, 'W', ['C']);
+  if (ear === 'floppy' || ear === 'long' || ear === 'round') {
+    ellipse(7.2, 16.2, 1.9, 3.2, 'K');            // ear swings forward and hangs
+  }
+  ellipse(5.4, 14.6, 3.9, 3.4, 'C');              // head, dropped to the floor
+  if (ear === 'perk' || ear === 'semi' || ear === 'big') {
+    triangle(3.8, 9.4, 2.4, 13.6, 6.4, 12.6, 'K');
+    triangle(7.4, 9.2, 6.2, 13.4, 10.0, 12.4, 'K');
+  }
+  ellipse(15.0, 14.4, 4.2, 1.7, 'W', ['C']);      // pale belly line along the underside
+  applyMarking(B.marking, { cx: 16.0, top: 7.0, bot: 17.5, w: 5.6 * bw, headY: 14.6, headRx: 3.9 });
+  ellipse(2.5, 16.2, 2.4, 1.9, 'W');              // snout laid flat on the ground
+  ellipse(1.5, 15.8, 1.3, 1.0, 'N');
+  ellipse(6.0, 13.6, 1.6, 1.7, 'E');              // one visible eye, looking up at you
+  if (B.brows) ellipse(6.2, 11.4, 1.2, 0.8, 'X');
+  carveJaw(2.5, 16.2, 2.4, 1.9);
+  for (let r = 13; r <= 19; r++) setCell(20, r, '.');   // seam the rear leg off the rump
+}
+
+// ---- keyboard dog (the type pose) -------------------------------------------
+// Same "paws on the home row" idea as the cat, but a dog leans its whole chest
+// onto the desk and lets the snout hang over the keys.
+function composeTypeDog(B) {
+  const { setCell, ellipse, triangle } = _c();
+  B = B || {};
+  const CX = 12;
+  const ear = B.ear || 'floppy';
+  const headRx = B.headRx || 5.5, headRy = B.headRy || 4.6;
+  const headY = 6.4;
+  const snoutRx = B.snoutRx || 3.2, snoutRy = B.snoutRy || 2.7;
+  const snoutY = B.snoutY == null ? 10.2 : B.snoutY - 0.4;
+  // The renderer paints the keys and the kneading paws over this, so the sprite is
+  // just head + a chest spread wide across the desk edge.
+  ellipse(CX, 18.6, 7.2, 5.2, 'C');               // chest, flattened onto the desk
+  ellipse(CX, 14.2, 3.6, 3.0, 'C');               // neck
+  const earOx = headRx - 0.6;
+  if (ear === 'floppy' || ear === 'long' || ear === 'round') {
+    const drop = ear === 'long' ? 5.4 : ear === 'round' ? 3.5 : 4.2;
+    ellipse(CX - earOx, 8.6, 2.2, drop, 'K');
+    ellipse(CX + earOx, 8.6, 2.2, drop, 'K');
+  }
+  ellipse(CX, headY, headRx, headRy, 'C');
+  if (ear === 'perk' || ear === 'semi' || ear === 'big') {
+    const ew = ear === 'big' ? 2.9 : 2.5, eo = ear === 'big' ? 3.9 : 3.6;
+    const apex = ear === 'big' ? -1.8 : -0.8;
+    triangle(CX - eo - 0.6, apex, CX - eo - ew, 7.0, CX - eo + ew, 5.2, 'K');
+    triangle(CX + eo + 0.6, apex, CX + eo + ew, 7.0, CX + eo - ew, 5.2, 'K');
+    const iw = ew * 0.5;
+    triangle(CX - eo - 0.4, apex + 2.0, CX - eo - iw, 6.5, CX - eo + iw, 5.4, 'I');
+    triangle(CX + eo + 0.4, apex + 2.0, CX + eo + iw, 6.5, CX + eo - iw, 5.4, 'I');
+  }
+  ellipse(CX, snoutY, snoutRx, snoutRy, 'W');     // snout hanging over the keys
+  if (B.snoutDark) ellipse(CX, snoutY - snoutRy * 0.2, snoutRx * 0.95, snoutRy * 0.78, 'K');
+  ellipse(CX, snoutY - snoutRy * 0.30, 1.6, 1.1, 'N');
+  ellipse(CX - 3.0, headY - 0.6, 1.7, 1.8, 'E');
+  ellipse(CX + 3.0, headY - 0.6, 1.7, 1.8, 'E');
+  if (B.brows) { ellipse(CX - 3.0, headY - 3.1, 1.3, 0.9, 'X'); ellipse(CX + 3.0, headY - 3.1, 1.3, 0.9, 'X'); }
+  ellipse(CX, 19.0, 2.6, 4.0, 'W', ['C']);        // chest blaze
+  applyMarking(B.marking, { cx: CX, top: 13.5, bot: 23.5, w: 6.6, headY, headRx });
+  carveJaw(CX, snoutY, snoutRx, snoutRy);
+  if (ear === 'floppy' || ear === 'long' || ear === 'round') {
+    for (let r = Math.round(headY - 1); r <= Math.round(headY + headRy + 1.4); r++) {
+      setCell(Math.round(CX - earOx + 2.0), r, '.');
+      setCell(Math.round(CX + earOx - 2.0), r, '.');
+    }
+  }
+}
+
+// ---- curled dog (the loaf answer): nose-to-tail donut ------------------------
+// Cats loaf into a brick. Dogs curl into a spiral with the nose tucked against a
+// hind leg and the tail wrapped over the face, so the silhouette is a ring.
+function composeCurlDog(B) {
+  const { setCell, ellipse, triangle } = _c();
+  B = B || {};
+  const CX = 12, CY = 22;
+  const bw = B.bodyW || 1;
+  const ear = B.ear || 'floppy';
+  // Cats loaf into a brick; dogs coil into a spiral with the nose tucked in and the
+  // tail wrapped over the paws, so the target silhouette is a RING. The tail arc
+  // along the lower left is what distinguishes it from a sleeping cat.
+  ellipse(CX - 0.5, CY - 0.4, 7.2 * bw, 4.6, 'C');// the coiled body mass
+  ellipse(CX - 4.8, CY - 1.8, 3.4, 3.6, 'C');     // hip, folded forward
+  ellipse(CX + 4.6, CY - 3.8, 3.9, 3.4, 'C');     // head laid down on the flank
+  if (ear === 'floppy' || ear === 'long' || ear === 'round') {
+    ellipse(CX + 7.8, CY - 1.8, 2.0, 3.2, 'K');   // ear draped over the shoulder
+  } else {
+    triangle(CX + 7.2, CY - 7.4, CX + 5.2, CY - 3.6, CX + 8.8, CY - 3.2, 'K');
+  }
+  // Face features are painted AFTER applyMarking below - in this pose the coiled
+  // body sits at the same rows as the head, so a solid marking (beagle tricolour)
+  // would otherwise bury the eye.
+  // the tail sweeps around the front and rests over the paws - closes the ring
+  for (let a = 0; a <= 14; a++) {
+    const th = Math.PI * (0.30 + a / 14 * 0.86);
+    ellipse(CX - 0.5 + Math.cos(th) * 8.4, CY - 0.4 + Math.sin(th) * 5.6, 1.8, 1.6, 'C');
+  }
+  ellipse(CX - 1.5, CY + 2.6, 4.8, 1.6, 'W', ['C']);// belly fur against the floor
+  applyMarking(B.marking, { cx: CX - 0.5, top: CY - 5.0, bot: CY + 5.0, w: 7.4 * bw, headY: CY - 3.2, headRx: 4.2 });
+  ellipse(CX + 1.6, CY - 1.6, 2.7, 2.1, 'W');     // snout tucked toward the tail
+  ellipse(CX + 0.2, CY - 1.2, 1.4, 1.0, 'N');
+  ellipse(CX + 5.2, CY - 4.2, 1.8, 0.7, 'E');     // eye closed to a contented slit
+  carveJaw(CX + 1.6, CY - 1.6, 2.7, 2.1);
+  // seam the tail off the body so the coil reads as two overlapping volumes
+  for (let a = 1; a <= 13; a++) {
+    const th = Math.PI * (0.30 + a / 14 * 0.86);
+    setCell(Math.round(CX - 0.5 + Math.cos(th) * 6.6), Math.round(CY - 0.4 + Math.sin(th) * 4.2), '.');
+  }
+}
+
+// ---- begging dog (the rear-up answer) ---------------------------------------
+// Up on the haunches with both front paws dangling at the chest. Cats bat at
+// things overhead; dogs BEG, so the paws hang loose rather than reaching.
+function composeBegDog(B) {
+  const { setCell, ellipse, triangle } = _c();
+  B = B || {};
+  const CX = 12;
+  const bw = B.bodyW || 1;
+  const ear = B.ear || 'floppy';
+  const headRx = B.headRx || 5.4, headRy = B.headRy || 4.6;
+  const headY = 5.6;
+  const snoutRx = B.snoutRx || 3.2, snoutRy = B.snoutRy || 2.7;
+  const snoutY = B.snoutY == null ? 9.3 : B.snoutY - 1.3;
+  ellipse(CX, 26.4, 6.8 * bw, 3.6, 'C');          // seated base
+  ellipse(CX, 19.4, 4.9 * bw, 7.4, 'C');          // torso stretched tall
+  ellipse(CX, 13.4, 3.5, 3.0, 'C');               // neck, extended upward
+  const earOx = headRx - 0.6;
+  if (ear === 'floppy' || ear === 'long' || ear === 'round') {
+    const drop = ear === 'long' ? 5.4 : ear === 'round' ? 3.5 : 4.2;
+    ellipse(CX - earOx, 7.8, 2.2, drop, 'K');
+    ellipse(CX + earOx, 7.8, 2.2, drop, 'K');
+  }
+  ellipse(CX, headY, headRx, headRy, 'C');
+  if (ear === 'perk' || ear === 'semi' || ear === 'big') {
+    const ew = ear === 'big' ? 2.9 : 2.5, eo = ear === 'big' ? 3.9 : 3.6;
+    const apex = ear === 'big' ? -2.6 : -1.6;
+    triangle(CX - eo - 0.6, apex, CX - eo - ew, 6.2, CX - eo + ew, 4.4, 'K');
+    triangle(CX + eo + 0.6, apex, CX + eo + ew, 6.2, CX + eo - ew, 4.4, 'K');
+    const iw = ew * 0.5;
+    triangle(CX - eo - 0.4, apex + 2.0, CX - eo - iw, 5.7, CX - eo + iw, 4.6, 'I');
+    triangle(CX + eo + 0.4, apex + 2.0, CX + eo + iw, 5.7, CX + eo - iw, 4.6, 'I');
+  }
+  ellipse(CX, snoutY, snoutRx, snoutRy, 'W');     // snout tipped up, hopeful
+  if (B.snoutDark) ellipse(CX, snoutY - snoutRy * 0.2, snoutRx * 0.95, snoutRy * 0.78, 'K');
+  ellipse(CX, snoutY - snoutRy * 0.30, 1.6, 1.1, 'N');
+  ellipse(CX - 3.0, headY - 0.6, 1.8, 1.9, 'E');
+  ellipse(CX + 3.0, headY - 0.6, 1.8, 1.9, 'E');
+  if (B.brows) { ellipse(CX - 3.0, headY - 3.1, 1.3, 0.9, 'X'); ellipse(CX + 3.0, headY - 3.1, 1.3, 0.9, 'X'); }
+  // dangling front paws held close to the chest, wrists limp - the beg tell
+  ellipse(CX - 3.0, 17.0, 1.5, 2.8, 'C'); ellipse(CX - 3.4, 19.6, 1.9, 1.5, 'W', ['C']);
+  ellipse(CX + 3.0, 17.4, 1.5, 2.8, 'C'); ellipse(CX + 3.4, 20.0, 1.9, 1.5, 'W', ['C']);
+  ellipse(CX, 19.6, 2.3, 4.6, 'W', ['C']);        // chest blaze
+  applyMarking(B.marking, { cx: CX, top: 13.0, bot: 29.0, w: 5.6 * bw, headY, headRx });
+  carveJaw(CX, snoutY, snoutRx, snoutRy);
+  for (let r = 22; r <= 28; r++) setCell(CX, r, '.');
+  // seam each dangling forearm off the chest
+  for (let r = 15; r <= 20; r++) { setCell(CX - 5, r, '.'); setCell(CX + 5, r, '.'); }
+}
+
+// ---- breed palettes ---------------------------------------------------------
+// Dog noses are overwhelmingly black or liver, never the pink a cat gets, so the
+// `nose` values here run dark on purpose. `tongue` is dog-only (panting).
+const DOG_PATTERNS = [
+  { name: 'Golden Retriever', coat: '#e0a95c', mark: '#c98f42', white: '#f4e0bb', patch: '#e0a95c', eye: '#6b4423', nose: '#2c2320', inner: '#c98f7a', outline: '#7a5326', tongue: '#e8747f' },
+  { name: 'Shiba Inu', coat: '#dd8a45', mark: '#c06f2e', white: '#f7efe0', patch: '#dd8a45', eye: '#4a3222', nose: '#241d1a', inner: '#d69a86', outline: '#6f3f18', tongue: '#e8747f' },
+  { name: 'Corgi', coat: '#e2984d', mark: '#c67b32', white: '#faf3e6', patch: '#e2984d', eye: '#4a3222', nose: '#241d1a', inner: '#d99e8b', outline: '#6d4118', tongue: '#e8747f' },
+  { name: 'Beagle', coat: '#d9a463', mark: '#33302e', white: '#f8f4ea', patch: '#b06a2c', eye: '#4a3222', nose: '#241d1a', inner: '#cf9583', outline: '#4a3520', tongue: '#e8747f' },
+  { name: 'Siberian Husky', coat: '#9aa6b4', mark: '#333a44', white: '#f6f8fb', patch: '#9aa6b4', eye: '#6db4d6', nose: '#20242a', inner: '#b9a0a4', outline: '#242a33', tongue: '#e8747f' },
+  { name: 'Dalmatian', coat: '#f4f3ef', mark: '#2b2d33', white: '#ffffff', patch: '#f4f3ef', eye: '#5a4433', nose: '#20222a', inner: '#e0b6b6', outline: '#6e6a63', tongue: '#e8747f' },
+  { name: 'German Shepherd', coat: '#c98f45', mark: '#2f2a26', white: '#dcb277', patch: '#c98f45', eye: '#4a3222', nose: '#1e1a18', inner: '#c08e7c', outline: '#3d2f1e', tongue: '#e8747f' },
+  { name: 'Border Collie', coat: '#f4f2ec', mark: '#2b2d33', white: '#ffffff', patch: '#2b2d33', eye: '#5a4433', nose: '#20222a', inner: '#dcb2b2', outline: '#6b665f', tongue: '#e8747f' },
+  { name: 'Dachshund', coat: '#8a4f28', mark: '#6b3a1c', white: '#a86a38', patch: '#8a4f28', eye: '#4a3222', nose: '#211a16', inner: '#b5837a', outline: '#3a2010', tongue: '#e8747f' },
+  { name: 'Pug', coat: '#e3c489', mark: '#33302e', white: '#eed9ae', patch: '#e3c489', eye: '#3f2c1f', nose: '#221e1c', inner: '#cfa192', outline: '#6e5730', tongue: '#e8747f' },
+  { name: 'Black Lab', coat: '#2f3138', mark: '#25272d', white: '#2f3138', patch: '#2f3138', eye: '#8a6a3a', nose: '#16181c', inner: '#6a4c52', outline: '#15171b', tongue: '#e8747f' },
+  { name: 'Poodle', coat: '#f0ece2', mark: '#ddd6c6', white: '#fbf8f1', patch: '#f0ece2', eye: '#4a3a2c', nose: '#22201e', inner: '#e2bcbc', outline: '#948d7e', tongue: '#e8747f' },
+  { name: 'Australian Shepherd', coat: '#9d9ba0', mark: '#3a3a42', white: '#f4f2ee', patch: '#a9702f', eye: '#6db4d6', nose: '#20222a', inner: '#c9a5a5', outline: '#33333c', tongue: '#e8747f' },
+  { name: 'Chihuahua', coat: '#dcb783', mark: '#c39a63', white: '#f2e4ca', patch: '#dcb783', eye: '#3f2c1f', nose: '#231d1a', inner: '#d6a794', outline: '#8a6636', tongue: '#e8747f' },
+];
+
+// Build archetypes. `ear`, `tail` and `legLen` do most of the visual work.
+const DOG_BUILDS = {
+  retriever:  { bodyW: 1.10, headRx: 6.7, headRy: 5.5, ear: 'floppy', tail: 'feather', fluff: true,  marking: 'solid'  },
+  spitz:      { bodyW: 1.00, headRx: 6.2, headRy: 5.3, ear: 'perk',   tail: 'curl',    snoutRx: 3.2, marking: 'solid'  },
+  dwarf:      { bodyW: 1.14, headRx: 6.6, headRy: 5.5, ear: 'big',    tail: 'stub',    legLen: 0.58, marking: 'solid'  },
+  hound:      { bodyW: 1.02, headRx: 6.4, headRy: 5.4, ear: 'long',   tail: 'straight', brows: true, marking: 'tri'    },
+  working:    { bodyW: 1.12, headRx: 6.8, headRy: 5.6, ear: 'perk',   tail: 'curl',    snoutDark: true, fluff: true, marking: 'mask' },
+  spotted:    { bodyW: 1.04, headRx: 6.4, headRy: 5.3, ear: 'floppy', tail: 'straight', marking: 'spots' },
+  shepherd:   { bodyW: 1.08, headRx: 6.6, headRy: 5.5, ear: 'big',    tail: 'plume',   snoutDark: true, brows: true, marking: 'saddle' },
+  collie:     { bodyW: 1.00, headRx: 6.3, headRy: 5.3, ear: 'semi',   tail: 'plume',   fluff: true,  marking: 'patch'  },
+  longdog:    { bodyW: 1.20, headRx: 5.9, headRy: 4.9, ear: 'long',   tail: 'straight', legLen: 0.50, snoutRx: 3.9, snoutRy: 2.6, marking: 'solid' },
+  brachy:     { bodyW: 1.16, headRx: 7.0, headRy: 5.8, ear: 'rose',   tail: 'curl',    snoutRx: 2.6, snoutRy: 2.0, snoutY: 11.2, snoutDark: true, eyeRx: 2.3, eyeRy: 2.4, marking: 'solid' },
+  labrador:   { bodyW: 1.12, headRx: 6.7, headRy: 5.5, ear: 'floppy', tail: 'straight', marking: 'solid' },
+  poodle:     { bodyW: 1.02, headRx: 6.3, headRy: 5.4, ear: 'round',  tail: 'plume',   fluff: true,  marking: 'curly'  },
+  merledog:   { bodyW: 1.06, headRx: 6.5, headRy: 5.4, ear: 'floppy', tail: 'plume',   fluff: true,  marking: 'merle'  },
+  toy:        { bodyW: 0.82, headRx: 6.0, headRy: 5.4, ear: 'big',    tail: 'curl',    snoutRx: 2.7, snoutRy: 2.3, eyeRx: 2.3, eyeRy: 2.4, marking: 'solid' },
+};
+
+//  Golden     Shiba    Corgi    Beagle   Husky      Dalmatian  Shepherd    Collie    Dachshund  Pug       Lab         Poodle    Aussie      Chihuahua
+const DOG_PATTERN_BUILD = ['retriever', 'spitz', 'dwarf', 'hound', 'working', 'spotted', 'shepherd', 'collie', 'longdog', 'brachy', 'labrador', 'poodle', 'merledog', 'toy'];
+
+// Tail shape per breed, read by the renderer's drawDogTail.
+const DOG_TAILS = DOG_PATTERN_BUILD.map((b) => DOG_BUILDS[b].tail || 'straight');
+
+// Node-only: hand in cat-sprite.js's primitives, since a CommonJS module has no
+// access to the browser's shared global script scope.
+function attach(prims) { P = prims; }
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    attach, composeSitDog, composeBowDog, composeTypeDog, composeCurlDog, composeBegDog,
+    applyMarking, DOG_PATTERNS, DOG_BUILDS, DOG_PATTERN_BUILD, DOG_TAILS,
+  };
+}
diff --git a/src/index.html b/src/index.html
index e0f9659..8c9c04d 100644
--- a/src/index.html
+++ b/src/index.html
@@ -22,6 +22,8 @@
 <body>
   <canvas id="cat"></canvas>
   <script src="cat-sprite.js"></script>
+  <script src="dog-sprite.js"></script>
+  <script src="pets.js"></script>
   <script src="template.js"></script>
   <script src="climb-frames.js"></script>
   <script src="audio.js"></script>
diff --git a/src/main.js b/src/main.js
index e7b1fdf..1167a20 100644
--- a/src/main.js
+++ b/src/main.js
@@ -8,6 +8,7 @@ const mail = require('./mail');
 const cal = require('./cal');
 const themes = require('./themes');
 const { PATTERN_NAMES } = require('./patterns');
+const { SPECIES, SPECIES_IDS, speciesOf, coatsFor, defaultCoatIndex } = require('./pets');
 
 // Let the overlay auto-resume the Lobby Jam music at launch without a click — Chromium
 // otherwise blocks autoplay until a user gesture.
@@ -255,7 +256,7 @@ function createWindow() {
       // sanitize fields from the untrusted bridge file before they reach Notification + renderer IPC
       const level = ['info', 'success', 'warn', 'alert'].includes(o.level) ? o.level : 'info';
       const ttl = Math.max(500, Math.min(30000, Math.round(Number(o.ttl)) || 5000));
-      const title = String(o.title || 'pixelcat').slice(0, 80);
+      const title = String(o.title || 'pixelpets').slice(0, 80);
       notify(String(o.message).slice(0, 300), { source: 'bridge', dedupeKey: 'bridge:' + id, title, level, ttl, sound: o.sound !== false });
     }
   };
@@ -366,17 +367,27 @@ function trayImage() {
 function createTray() {
   try {
     tray = new Tray(trayImage());
-    tray.setToolTip('pixelcat');
+    tray.setToolTip('pixelpets');
     tray.on('double-click', openSettings);
     rebuildTrayMenu();
   } catch (e) { console.log('[tray-error]', e.message); }
 }
 function rebuildTrayMenu() {
   if (!tray) return;
-  const allCoats = PATTERN_NAMES.concat(themesCache.map((t) => t.name));
+  // The tray follows the active species: a dog owner picks a BREED, not a coat,
+  // and each species remembers its own choice in its own config field.
+  const sp = speciesOf(cfg && cfg.species);
+  const isDogCfg = sp.id === 'dog';
+  const coatField = isDogCfg ? 'dogPattern' : 'pattern';
+  const curCoat = cfg ? cfg[coatField] : 0;
+  const allCoats = (isDogCfg ? coatsFor('dog') : PATTERN_NAMES).concat(isDogCfg ? [] : themesCache.map((t) => t.name));
   const coatItems = allCoats.map((name, i) => ({
-    label: name, type: 'radio', checked: cfg && cfg.pattern === i,
-    click: () => persistAndBroadcast({ ...cfg, pattern: i }),
+    label: name, type: 'radio', checked: curCoat === i,
+    click: () => persistAndBroadcast({ ...cfg, [coatField]: i }),
+  }));
+  const speciesItems = SPECIES_IDS.map((id) => ({
+    label: `${SPECIES[id].emoji}  ${SPECIES[id].label}`, type: 'radio', checked: sp.id === id,
+    click: () => persistAndBroadcast({ ...cfg, species: id }),
   }));
   const recent = notifyHistory.slice(-10).reverse();
   const recentItems = recent.length
@@ -388,7 +399,7 @@ function rebuildTrayMenu() {
   tray.setContextMenu(Menu.buildFromTemplate([
     { label: 'Settings…', click: openSettings },
     { label: 'Start break now', click: triggerBreak },
-    { label: 'Give a treat 🐟', click: giveTreat },
+    { label: sp.treatLabel, click: giveTreat },
     { label: 'Recent notifications', submenu: recentItems },
     { label: 'Snooze last reminder', submenu: [
       { label: '5 minutes', click: () => snoozeLast(5) },
@@ -396,7 +407,8 @@ function rebuildTrayMenu() {
       { label: '30 minutes', click: () => snoozeLast(30) },
     ] },
     { type: 'separator' },
-    { label: 'Coat', submenu: coatItems },
+    { label: 'Pet', submenu: speciesItems },
+    { label: sp.coatNoun, submenu: coatItems },
     { label: 'Follow cursor', type: 'checkbox', checked: !!(cfg && cfg.followCursor), click: () => persistAndBroadcast({ ...cfg, followCursor: !cfg.followCursor }) },
     { label: 'Mouse hunt', type: 'checkbox', checked: !!(cfg && cfg.huntOn), click: () => persistAndBroadcast({ ...cfg, huntOn: !cfg.huntOn }) },
     { label: 'Butterfly visits', type: 'checkbox', checked: !(cfg && cfg.butterflyOn === false), click: () => persistAndBroadcast({ ...cfg, butterflyOn: !(cfg && cfg.butterflyOn !== false) }) },
@@ -438,7 +450,7 @@ function rebuildTrayMenu() {
       ];
     })() },
     { type: 'separator' },
-    { label: 'Quit pixelcat', click: () => app.quit() },
+    { label: 'Quit pixelpets', click: () => app.quit() },
   ]));
 }
 
@@ -447,7 +459,7 @@ function openSettings() {
   if (settingsWin && !settingsWin.isDestroyed()) { settingsWin.show(); settingsWin.focus(); return; }
   settingsWin = new BrowserWindow({
     width: 400, height: 560, resizable: false, fullscreenable: false, maximizable: false,
-    title: 'pixelcat settings', skipTaskbar: false, alwaysOnTop: true,
+    title: 'pixelpets settings', skipTaskbar: false, alwaysOnTop: true,
     icon: path.join(__dirname, '..', 'assets', 'icon.png'),   // taskbar icon for the settings window
     show: false, backgroundColor: '#191b22',   // dark from the first paint - no white flash
     webPreferences: { preload: path.join(__dirname, 'settings-preload.js'), contextIsolation: true, nodeIntegration: false, sandbox: true },
@@ -471,7 +483,10 @@ function triggerBreak() {
   breakAnchor = Date.now();
 }
 function giveTreat() {
-  if (win && !win.isDestroyed()) win.webContents.send('treat');
+  if (!win || win.isDestroyed()) return;
+  // Same tray slot, species-appropriate payload: a cat is handed a fish, a dog
+  // gets a tennis ball thrown for it to chase down and bring back.
+  win.webContents.send(speciesOf(cfg && cfg.species).id === 'dog' ? 'ball' : 'treat');
 }
 
 // ---- Pomodoro: focus/break loops. Main owns the phase clock (the renderer may
@@ -556,7 +571,7 @@ function notify(message, opts) {
   }
   const wantOs = opts.os !== undefined ? opts.os : !(cfg && cfg.notifyOn === false);
   if (wantOs) {
-    try { if (Notification.isSupported()) new Notification({ title: opts.title || 'pixelcat', body: msg, silent: true }).show(); }
+    try { if (Notification.isSupported()) new Notification({ title: opts.title || 'pixelpets', body: msg, silent: true }).show(); }
     catch (e) { /* toasts are best-effort */ }
   }
 }
@@ -681,7 +696,17 @@ onSecure('sheet:image', (_e, dataUrl) => {
   app.quit();
 });
 onSecure('settings:open', () => openSettings());
-onSecure('settings:save-pattern', (_e, i) => { if (cfg) persistAndBroadcast({ ...cfg, pattern: i }); });
+onSecure('settings:save-pattern', (_e, i) => {
+  if (!cfg) return;
+  persistAndBroadcast({ ...cfg, [speciesOf(cfg.species).id === 'dog' ? 'dogPattern' : 'pattern']: i });
+});
+onSecure('settings:save-species', (_e, id) => {
+  if (!cfg) return;
+  const next = SPECIES[id] ? id : 'cat';
+  const patch = { ...cfg, species: next };
+  if (next === 'dog' && !Number.isFinite(cfg.dogPattern)) patch.dogPattern = defaultCoatIndex('dog');
+  persistAndBroadcast(patch);
+});
 onSecure('settings:close', () => { if (settingsWin && !settingsWin.isDestroyed()) settingsWin.close(); });
 onSecure('settings:testSound', () => {
   notify('Hi {name}!', { source: 'test', dedupeMs: 0, os: false });   // a sound test shouldn't also pop a desktop toast
@@ -703,7 +728,7 @@ handleSecure('themes:get', () => themesCache);
 handleSecure('themes:add', (_e, t) => { themesCache = themes.save([...themesCache, t]); broadcastThemes(); rebuildTrayMenu(); return themesCache; });
 handleSecure('themes:delete', (_e, name) => { themesCache = themes.save(themesCache.filter((x) => x.name !== name)); broadcastThemes(); rebuildTrayMenu(); return themesCache; });
 handleSecure('themes:export', async () => {
-  const r = await dialog.showSaveDialog(settingsWin || win, { title: 'Export custom coats', defaultPath: 'pixelcat-coats.json', filters: [{ name: 'JSON', extensions: ['json'] }] });
+  const r = await dialog.showSaveDialog(settingsWin || win, { title: 'Export custom coats', defaultPath: 'pixelpets-coats.json', filters: [{ name: 'JSON', extensions: ['json'] }] });
   if (r.canceled || !r.filePath) return false;
   try { fs.writeFileSync(r.filePath, JSON.stringify({ themes: themesCache }, null, 2)); return true; } catch (e) { return false; }
 });
diff --git a/src/pets.js b/src/pets.js
new file mode 100644
index 0000000..05ad22f
--- /dev/null
+++ b/src/pets.js
@@ -0,0 +1,61 @@
+// Species registry - the single source of truth for which pets exist and what
+// each one's coats are called. Mirrors patterns.js (which stays the cat's list so
+// nothing that already imports it breaks) and is consumed by the main process for
+// the tray menu, by the settings window for its dropdowns, and by the renderer to
+// decide which sprite composers to build with.
+//
+// Coat NAMES only. The full palettes live in cat-sprite.js / dog-sprite.js so
+// colour data is never duplicated.
+
+const CAT_COATS = [
+  'Orange Tabby', 'Mackerel Tabby', 'Brown Tabby', 'Siamese',
+  'Tuxedo', 'Black', 'Gray', 'White',
+  'Cream', 'Tortoiseshell', 'Calico', 'Slate',
+  'Chocolate', 'Russian Blue',
+];
+
+const DOG_COATS = [
+  'Golden Retriever', 'Shiba Inu', 'Corgi', 'Beagle',
+  'Siberian Husky', 'Dalmatian', 'German Shepherd', 'Border Collie',
+  'Dachshund', 'Pug', 'Black Lab', 'Poodle',
+  'Australian Shepherd', 'Chihuahua',
+];
+
+const SPECIES = {
+  cat: {
+    id: 'cat',
+    label: 'Cat',
+    emoji: '🐱',
+    coats: CAT_COATS,
+    coatNoun: 'Coat',
+    defaultCoat: 'Tuxedo',
+    // tray/menu wording differs per species so the app never says "treat" at a dog
+    // that is actually being handed a ball
+    treatLabel: 'Give a treat 🐟',
+    playLabel: 'Send a butterfly 🦋',
+  },
+  dog: {
+    id: 'dog',
+    label: 'Dog',
+    emoji: '🐶',
+    coats: DOG_COATS,
+    coatNoun: 'Breed',
+    defaultCoat: 'Golden Retriever',
+    treatLabel: 'Give a treat 🦴',
+    playLabel: 'Throw the ball 🎾',
+  },
+};
+
+const SPECIES_IDS = Object.keys(SPECIES);
+const isSpecies = (s) => Object.prototype.hasOwnProperty.call(SPECIES, s);
+const speciesOf = (s) => SPECIES[isSpecies(s) ? s : 'cat'];
+const coatsFor = (s) => speciesOf(s).coats;
+const defaultCoatIndex = (s) => {
+  const sp = speciesOf(s);
+  return Math.max(0, sp.coats.indexOf(sp.defaultCoat));
+};
+
+const api = { SPECIES, SPECIES_IDS, CAT_COATS, DOG_COATS, isSpecies, speciesOf, coatsFor, defaultCoatIndex };
+
+if (typeof module !== 'undefined' && module.exports) module.exports = api;
+else if (typeof window !== 'undefined') Object.assign(window, api, { PET_SPECIES: SPECIES });
diff --git a/src/preload.js b/src/preload.js
index 1263a11..42d59a5 100644
--- a/src/preload.js
+++ b/src/preload.js
@@ -20,6 +20,7 @@ contextBridge.exposeInMainWorld('cat', {
   onSetArea: sub('setarea:start'),
   onBreak: sub('break'),
   onTreat: sub('treat'),
+  onBall: sub('ball'),
   onPomo: sub('pomo', (d) => d),
   onGeom: sub('geom', (g) => g),
   onNotify: sub('notify', (d) => d),
diff --git a/src/renderer.js b/src/renderer.js
index 1ad730f..d9534e8 100644
--- a/src/renderer.js
+++ b/src/renderer.js
@@ -191,7 +191,63 @@ function composeRearUp(B) {
   ellipse(8, 20, 2.2, 2.8, 'X', ['C', 'K']); ellipse(16, 24, 2.0, 2.2, 'X', ['C', 'K']);
 }
 
-const spriteHunt = buildSprite(30, 20, composeHunt);
+// ---- species -----------------------------------------------------------------
+// The overlay hosts either a cat or a dog. Rather than branch at every draw site,
+// the active species REWRITES the shared sprite/palette tables, so everything
+// downstream (tray coats, settings, contact sheet, themes) keeps working unchanged.
+// The cat's built-in tables are snapshotted first because applyThemes() mutates
+// them in place and we need a clean copy to restore when switching back.
+const CAT_BASE = { patterns: PATTERNS.slice(), build: PATTERN_BUILD.slice(), tabby: TABBY.slice() };
+const forcedSpecies = qp.get('species');
+let species = forcedSpecies === 'dog' || forcedSpecies === 'cat'
+  ? forcedSpecies
+  : (localStorage.getItem('species') === 'dog' ? 'dog' : 'cat');
+const isDog = () => species === 'dog';
+
+function speciesDefs(sp) {
+  if (sp === 'dog') {
+    return {
+      patterns: DOG_PATTERNS, build: DOG_PATTERN_BUILD, tabby: DOG_PATTERN_BUILD.map(() => false),
+      builds: DOG_BUILDS,
+      sit: composeSitDog, type: composeTypeDog, loaf: composeCurlDog, rear: composeBegDog,
+      hunt: composeBowDog, huntCols: 30, huntRows: 22,
+      typeCols: 24, typeRows: 24,
+    };
+  }
+  return {
+    patterns: CAT_BASE.patterns, build: CAT_BASE.build, tabby: CAT_BASE.tabby,
+    builds: BUILDS,
+    sit: composeSit, type: composeTypeFront, loaf: composeLoaf, rear: composeRearUp,
+    hunt: composeHunt, huntCols: 30, huntRows: 20,
+    typeCols: 24, typeRows: 24,
+  };
+}
+
+// Build descriptor for coat i under the active species. Cats carry a `tabby`
+// flag; dogs carry breed geometry (ear/tail/leg length) straight off the build.
+function buildFor(i, D) {
+  const b = D.builds[D.build[i]] || {};
+  return { ...b, tabby: !!D.tabby[i] };
+}
+
+// Rewrite the shared coat tables in place. Everything that reads PATTERNS /
+// PATTERN_BUILD / TABBY (tray, settings, themes, contact sheet) then sees the
+// active species without needing to know a species exists at all.
+function installTables(D) {
+  PATTERNS.length = 0; for (const p of D.patterns) PATTERNS.push(p);
+  PATTERN_BUILD.length = 0; for (const b of D.build) PATTERN_BUILD.push(b);
+  TABBY.length = 0; for (const t of D.tabby) TABBY.push(t);
+}
+
+let SPECIES_DEFS = speciesDefs(species);
+installTables(SPECIES_DEFS);
+let spriteHunt = buildSprite(SPECIES_DEFS.huntCols, SPECIES_DEFS.huntRows, () => SPECIES_DEFS.hunt(buildFor(0, SPECIES_DEFS)));
+let huntSprites = null;   // dogs vary the bow by breed (markings); cats share one crouch
+function huntSpriteFor(i) { return (huntSprites && huntSprites[i]) || spriteHunt; }
+function buildHuntSprites(D) {
+  return D === null || !isDog() ? null
+    : D.build.map((b, i) => buildSprite(D.huntCols, D.huntRows, () => D.hunt(buildFor(i, D))));
+}
 const TW = 24 * CELL, TH = 24 * CELL;            // front-facing kneading-cat dims (per-coat sprites built below)
 // Sit grid is always 24x30, so SW/SH and the mochi bands stay constant across the
 // per-coat body builds (different shapes, same canvas). The sit sprites themselves
@@ -269,16 +325,18 @@ const octx = oc.getContext('2d'); octx.imageSmoothingEnabled = false;
 const HEAD_SRC = 14 * CELL, FEET_SRC = 7 * CELL, MID_SRC = SH - HEAD_SRC - FEET_SRC;
 
 
-const sprites = PATTERN_BUILD.map((b, i) => buildSprite(24, 30, () => composeSit({ ...BUILDS[b], tabby: TABBY[i] })));
+const sprites = PATTERN_BUILD.map((b, i) => buildSprite(24, 30, () => SPECIES_DEFS.sit(buildFor(i, SPECIES_DEFS))));
 // each coat also gets its own typing (kneading) body, so every breed types differently
 // one shared front "kneading cat" shape, recoloured per coat (+ tabby stripes / fluffy tufts)
-const typeSprites = PATTERN_BUILD.map((b, i) => buildSprite(24, 24, () => composeTypeFront({ tabby: TABBY[i], fluff: BUILDS[b].fluff })));
+const typeSprites = PATTERN_BUILD.map((b, i) => buildSprite(24, 24, () => SPECIES_DEFS.type(buildFor(i, SPECIES_DEFS))));
 // and a dedicated loaf (resting) body per coat - same 24x30 size as the sit sprite
-const loafSprites = PATTERN_BUILD.map((b, i) => buildSprite(24, 30, () => composeLoaf({ ...BUILDS[b], tabby: TABBY[i] })));
+const loafSprites = PATTERN_BUILD.map((b, i) => buildSprite(24, 30, () => SPECIES_DEFS.loaf(buildFor(i, SPECIES_DEFS))));
 // and a rear-up "bat the butterfly" body per coat - same 24x30 size as the sit sprite
-const rearSprites = PATTERN_BUILD.map((b, i) => buildSprite(24, 30, () => composeRearUp({ ...BUILDS[b], tabby: TABBY[i] })));
-const DEFAULT_PATTERN = Math.max(0, PATTERNS.findIndex((p) => p.name === 'Tuxedo'));   // tuxedo is the out-of-box coat
-const storedPattern = localStorage.getItem('pattern');
+const rearSprites = PATTERN_BUILD.map((b, i) => buildSprite(24, 30, () => SPECIES_DEFS.rear(buildFor(i, SPECIES_DEFS))));
+huntSprites = buildHuntSprites(SPECIES_DEFS);
+const DEFAULT_PATTERN = Math.max(0, PATTERNS.findIndex((p) => p.name === (species === 'dog' ? 'Golden Retriever' : 'Tuxedo')));
+const coatKey = (sp) => (sp === 'dog' ? 'dogPattern' : 'pattern');
+const storedPattern = localStorage.getItem(coatKey(species));
 let patternIndex = storedPattern != null ? Number(storedPattern) : DEFAULT_PATTERN;
 if (!(patternIndex >= 0 && patternIndex < PATTERNS.length)) patternIndex = DEFAULT_PATTERN;
 const forcedPattern = qp.get('pattern');
@@ -290,29 +348,70 @@ if (forcedPattern) { const i = PATTERNS.findIndex((p) => p.name.toLowerCase().in
 // Cached "cold" (non-overheat) palette, rebuilt only when the coat changes - avoids
 // recomputing ~12 colour conversions every single frame. Invalidated in applyThemes().
 let _palKey = -1, _coldPalRGB = null, _coldPal = null;
-const BASE_PATTERNS = PATTERNS.length;
+let BASE_PATTERNS = PATTERNS.length;
 function applyThemes(list) {
   _palKey = -1;   // coat palettes changed -> force a cold-palette rebuild next frame
   PATTERNS.length = BASE_PATTERNS; PATTERN_BUILD.length = BASE_PATTERNS; TABBY.length = BASE_PATTERNS;
   sprites.length = BASE_PATTERNS; typeSprites.length = BASE_PATTERNS; loafSprites.length = BASE_PATTERNS; rearSprites.length = BASE_PATTERNS;
   for (const th of (Array.isArray(list) ? list : [])) {
     if (!th || !th.name || !th.coat) continue;
-    const build = BUILDS[th.build] ? th.build : 'standard';
+    const build = (SPECIES_DEFS.builds[th.build] || BUILDS[th.build]) ? th.build : (isDog() ? DOG_PATTERN_BUILD[0] : 'standard');
     PATTERNS.push({ name: th.name, coat: th.coat, mark: th.mark || th.coat, white: th.white || th.coat,
       patch: th.patch || th.coat, eye: th.eye || '#8bbf5a', nose: th.nose || '#e0888f',
       inner: th.inner || '#f0b6a0', outline: th.outline || '#222831' });
     PATTERN_BUILD.push(build);
     TABBY.push(!!th.tabby);
-    sprites.push(buildSprite(24, 30, () => composeSit({ ...BUILDS[build], tabby: !!th.tabby })));
-    typeSprites.push(buildSprite(24, 24, () => composeTypeFront({ tabby: !!th.tabby, fluff: BUILDS[build].fluff })));
-    loafSprites.push(buildSprite(24, 30, () => composeLoaf({ ...BUILDS[build], tabby: !!th.tabby })));
-    rearSprites.push(buildSprite(24, 30, () => composeRearUp({ ...BUILDS[build], tabby: !!th.tabby })));
+    const D = SPECIES_DEFS, tb = { ...(D.builds[build] || BUILDS[build] || {}), tabby: !!th.tabby };
+    sprites.push(buildSprite(24, 30, () => D.sit(tb)));
+    typeSprites.push(buildSprite(24, 24, () => D.type(tb)));
+    loafSprites.push(buildSprite(24, 30, () => D.loaf(tb)));
+    rearSprites.push(buildSprite(24, 30, () => D.rear(tb)));
+    if (huntSprites) huntSprites.push(buildSprite(D.huntCols, D.huntRows, () => D.hunt(tb)));
   }
   if (!(patternIndex >= 0 && patternIndex < PATTERNS.length)) patternIndex = DEFAULT_PATTERN;
   if (forcedPattern) { const i = PATTERNS.findIndex((p) => p.name.toLowerCase().includes(forcedPattern.toLowerCase())); if (i >= 0) patternIndex = i; }
 }
 
+// Swap species live (tray or settings). Rebuilds every sprite table in place so
+// the running overlay never needs a restart.
+function setSpecies(next, coatIdx) {
+  const want = next === 'dog' ? 'dog' : 'cat';
+  if (want === species && coatIdx == null) return false;
+  const changed = want !== species;
+  if (changed) {
+    species = want;
+    localStorage.setItem('species', species);
+    SPECIES_DEFS = speciesDefs(species);
+    installTables(SPECIES_DEFS);
+    BASE_PATTERNS = PATTERNS.length;
+    const D = SPECIES_DEFS;
+    const rebuild = (arr, cols, rows, fn) => {
+      arr.length = 0;
+      for (let i = 0; i < D.build.length; i++) arr.push(buildSprite(cols, rows, () => fn(buildFor(i, D))));
+    };
+    rebuild(sprites, 24, 30, D.sit);
+    rebuild(typeSprites, 24, 24, D.type);
+    rebuild(loafSprites, 24, 30, D.loaf);
+    rebuild(rearSprites, 24, 30, D.rear);
+    spriteHunt = buildSprite(D.huntCols, D.huntRows, () => D.hunt(buildFor(0, D)));
+    huntSprites = buildHuntSprites(D);
+    _palKey = -1;                        // force a cold-palette rebuild for the new coats
+    climbImgs = {};                      // painted climb frames are cat-only art
+    ball = null; pantUntil = 0; wagBoost = 0;   // drop any in-flight dog-only state
+  }
+  const stored = coatIdx != null ? coatIdx : Number(localStorage.getItem(coatKey(species)));
+  patternIndex = Number.isFinite(stored) && stored >= 0 && stored < PATTERNS.length
+    ? stored
+    : Math.max(0, PATTERNS.findIndex((p) => p.name === (isDog() ? 'Golden Retriever' : 'Tuxedo')));
+  localStorage.setItem(coatKey(species), String(patternIndex));
+  _palKey = -1;
+  return changed;
+}
+
 const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+// Excitement bleeds off after a fetch/greeting rather than snapping back, so the
+// tail eases down instead of cutting from a whip to a sway in one frame.
+function decayWag(dt) { if (wagBoost > 0) wagBoost = Math.max(0, wagBoost - dt * 0.00035); }
 const HOT_BODY = '#d9534f', HOT_OUTLINE = '#7a1f1a';
 
 // ---- draw the cat body into context g (local origin 0,0) -------------------
@@ -350,7 +449,10 @@ function drawCat(g, sp, t, palRGB, o) {
     }
   }
   g.globalAlpha = 1;
-  if (!typing) {
+  // A dog with cat whiskers reads as a cat wearing a dog costume, so the whisker
+  // pass is skipped entirely and a panting tongue takes its place.
+  if (o.panting) drawTongue(g, sp, bob, t, palRGB);
+  if (!typing && !isDog()) {
     g.strokeStyle = 'rgba(245,245,245,0.6)'; g.lineWidth = 1; g.lineCap = 'round';
     const my = sp.muzzle.y + bob, cl = sp.muzzle.x - 4.5 * CELL, cr = sp.muzzle.x + 4.5 * CELL;
     // whiskers are alive: a slow waft plus a quick twitch every ~5s (t==0 on the
@@ -392,6 +494,80 @@ function drawCat(g, sp, t, palRGB, o) {
   }
 }
 
+// A lolling tongue under the muzzle. Dogs pant after exertion and when hot, and
+// it is the single cheapest way to make the sprite read as happy rather than blank.
+function drawTongue(g, sp, bob, t, palRGB) {
+  const mx = sp.muzzle.x, my = sp.muzzle.y + bob;
+  const lol = 3 + Math.sin(t / 260) * 1.6;             // the tongue bobs with the breath
+  const w = 5, h = 4 + lol;
+  g.fillStyle = 'rgb(90,32,40)';                        // dark rim so it reads on any coat
+  g.fillRect(Math.round(mx - w / 2) - 1, Math.round(my + 2), w + 2, Math.round(h) + 1);
+  g.fillStyle = (palRGB && palRGB.T) ? rgbStr(palRGB.T) : '#e8747f';
+  g.fillRect(Math.round(mx - w / 2), Math.round(my + 2), w, Math.round(h));
+  g.fillStyle = 'rgba(255,255,255,0.35)';
+  g.fillRect(Math.round(mx - 1), Math.round(my + 4), 1, Math.round(h) - 3);   // centre crease
+}
+
+// A dog's tail is a different instrument from a cat's: shorter, thicker, carried
+// HIGH, and it wags from the base in a wide fast arc instead of the cat's slow
+// rolling S. Shape varies by breed (curl / stub / plume / feather / straight),
+// which is a big part of telling the breeds apart at this size.
+const TAIL_SHAPE = {
+  straight: { n: 8, len: 0.055, rest: [-0.55, -0.45, -0.36, -0.28, -0.22, -0.16, -0.10, -0.05], thick: 7, taper: 3.2 },
+  feather:  { n: 9, len: 0.052, rest: [-0.70, -0.62, -0.55, -0.48, -0.42, -0.36, -0.30, -0.24, -0.18], thick: 9, taper: 4.6 },
+  plume:    { n: 9, len: 0.050, rest: [-0.95, -0.88, -0.80, -0.72, -0.64, -0.56, -0.48, -0.40, -0.32], thick: 8.5, taper: 4.2 },
+  curl:     { n: 9, len: 0.048, rest: [-1.30, -1.55, -1.85, -2.20, -2.60, -3.00, -3.40, -3.80, -4.15], thick: 7.5, taper: 3.4 },
+  stub:     { n: 4, len: 0.045, rest: [-0.85, -0.70, -0.55, -0.42], thick: 8, taper: 3.0 },
+};
+function dogTailShape() { return TAIL_SHAPE[DOG_TAILS[patternIndex] || 'straight'] || TAIL_SHAPE.straight; }
+
+function drawDogTail(footX, footY, t, pal, flickT0, petting, mood) {
+  const S = dogTailShape();
+  const baseX = footX + SW * 0.19, baseY = footY - SH * 0.30;
+  const segLen = SH * S.len;
+  const calm = !!(config && config.reducedMotion);
+  // Wag rate and amplitude both ride the mood: a calm dog sways, an excited one
+  // whips. `wagBoost` spikes on greetings, treats and a caught ball.
+  const excite = clamp((mood || 0) + wagBoost + (petting ? 0.55 : 0), 0, 1.6);
+  const rate = calm ? 620 : 260 - excite * 130;
+  const amp = (calm ? 0.10 : 0.20 + excite * 0.34) * (petting ? 1.25 : 1);
+  let flick = 0;
+  if (flickT0 >= 0 && t - flickT0 < 650) { const e = (t - flickT0) / 650; flick = Math.sin(e * Math.PI * 4) * (1 - e) * 0.5; }
+  const wag = Math.sin(t / rate) * amp + flick;
+  const pts = [[baseX, baseY]];
+  let x = baseX, y = baseY, dev = 0;
+  for (let i = 0; i < S.n; i++) {
+    const w = (i + 1) / S.n;
+    dev += wag * w * w * 0.9;                       // the whole tail swings from the base
+    const ang = S.rest[i] + dev;
+    x += Math.cos(ang) * segLen;
+    y = Math.min(y + Math.sin(ang) * segLen, footY - 2);
+    pts.push([x, y]);
+  }
+  let reach = 0; for (const p of pts) reach = Math.max(reach, Math.abs(p[0] - baseX));
+  if (reach > 52) { const f = 52 / reach; for (const p of pts) p[0] = baseX + (p[0] - baseX) * f; }
+  const sm = [pts[0]]; let px = pts[0][0], py = pts[0][1];
+  for (let i = 1; i < pts.length - 1; i++) {
+    const mx = (pts[i][0] + pts[i + 1][0]) / 2, my = (pts[i][1] + pts[i + 1][1]) / 2;
+    for (let k = 1; k <= 4; k++) {
+      const u = k / 4, v = 1 - u;
+      sm.push([v * v * px + 2 * v * u * pts[i][0] + u * u * mx, v * v * py + 2 * v * u * pts[i][1] + u * u * my]);
+    }
+    px = mx; py = my;
+  }
+  sm.push(pts[pts.length - 1]);
+  const n = sm.length - 1;
+  ctx.lineCap = 'round'; ctx.lineJoin = 'round';
+  for (const pass of [0, 1]) {
+    for (let j = 0; j < n; j++) {
+      const f = (j + 0.5) / n;
+      ctx.strokeStyle = pass === 0 ? pal.O : (f > 0.80 ? pal.W : pal.C);
+      ctx.lineWidth = S.thick - S.taper * f + (pass === 0 ? 3 : 0);
+      ctx.beginPath(); ctx.moveTo(sm[j][0], sm[j][1]); ctx.lineTo(sm[j + 1][0], sm[j + 1][1]); ctx.stroke();
+    }
+  }
+}
+
 function drawSteam(t, headCx, earTop) {
   for (let i = 0; i < 4; i++) {
     const ph = (((t + i * 240) % 960) / 960), x = Math.round(headCx + (i - 1.5) * 9), y = Math.round(earTop - 3 - ph * 12), h = Math.max(2, Math.round(5 - ph * 2));
@@ -658,6 +834,10 @@ let lookTarget = null, lookTargetUntil = 0;
 let nextIdleAt = 0, leanTarget = 0, lean = 0, cursorLean = 0, leanUntil = 0, tailFlickT0 = -1, loafUntil = 0, groomUntil = 0;
 let playUntil = 0, playT0 = -1, mote = null;   // idle paw-play: the cat bats a drifting leaf with a front paw
 let treat = null;   // a dropped treat (tray "Give a treat"): the cat trots over and noms it
+// --- dog-only state ---------------------------------------------------------
+let ball = null;          // { x, y, vx, vy, phase: 'fly'|'rest'|'carry'|'drop', ... } - fetch
+let wagBoost = 0;                         // transient wag speed-up (greeting, fetch, treats)
+let pantUntil = 0;                        // tongue out after exertion
 let yawnUntil = 0;   // occasional sleepy yawn (open mouth + squint)
 let nextRoam = 0, roamUntil = 0, roamFrom = null, roamTo = null, roamDur = 1500;   // autonomous wandering
 let lastDrawn = 0, wantHighFps = true, rafPaused = false;
@@ -783,13 +963,24 @@ if (window.cat) {
     else if (lj.on && jamRunning && lj.mood !== jamMoodCur) { if (window.jamSetMood) window.jamSetMood(lj.mood); jamMoodCur = lj.mood; }
     playArea = c.playArea || null;
     pos.x = zoneClampX(pos.x); pos.y = floorLockOn() ? restingY() : zoneClampY(pos.y); persistPos();
-    if (typeof c.pattern === 'number') patternIndex = clamp(c.pattern, 0, PATTERNS.length - 1);
+    // Species first: it rewrites the coat tables, so the coat index below must be
+    // read against the NEW species' list, not the outgoing one.
+    const wantSpecies = c.species === 'dog' ? 'dog' : 'cat';
+    const wantCoat = wantSpecies === 'dog' ? c.dogPattern : c.pattern;
+    if (wantSpecies !== species) {
+      setSpecies(wantSpecies, typeof wantCoat === 'number' ? wantCoat : null);
+      if (!SHOT) { wagBoost = 1.0; stretchT0 = performance.now(); }   // the new pet says hello
+    } else if (typeof wantCoat === 'number') {
+      patternIndex = clamp(wantCoat, 0, PATTERNS.length - 1);
+      localStorage.setItem(coatKey(species), String(patternIndex));
+    }
     resumeRaf();
   });
   if (window.cat.onPower) window.cat.onPower((p) => { lowPower = !!(p && p.lowPower); resumeRaf(); });
   if (window.cat.onNotify) window.cat.onNotify((d) => triggerNotify(d));
   if (window.cat.onBreak) window.cat.onBreak(() => triggerBreak());
   if (window.cat.onTreat) window.cat.onTreat(() => dropTreat());
+  if (window.cat.onBall) window.cat.onBall(() => throwBall());
   if (window.cat.onPomo) window.cat.onPomo((d) => { pomo = d || null; resumeRaf(); });
   if (window.cat.onGeom) window.cat.onGeom((g) => {
     if (g && Number.isFinite(g.bottomInset)) geomBottomInset = g.bottomInset;
@@ -823,6 +1014,91 @@ function triggerBreak() {
   if (config && config.soundOn) playMeow();
   resumeRaf();
 }
+// --- Fetch (dogs only): the tray throws a tennis ball. The ball arcs out under
+//     gravity, bounces, and settles; the dog bolts after it, picks it up, carries
+//     it back to its home corner, drops it, then wags and pants. This is the whole
+//     reason a dog is worth having as a desktop pet rather than a recoloured cat.
+const FETCH_GRAB = 22;        // how close the dog must get to pick the ball up
+const BALL_R = 5;
+function throwBall() {
+  if (SHOT || !pos || !isDog()) return;
+  const side = pos.x < viewW / 2 ? 1 : -1;
+  ball = {
+    x: pos.x, y: pos.y - SH * 0.55,
+    vx: side * (5.2 + Math.random() * 2.2), vy: -6.4 - Math.random() * 1.6,
+    phase: 'fly', spin: 0, restAt: 0,
+  };
+  addEnergy(16);                                  // a thrown ball is the best thing that has ever happened
+  wagBoost = 0.9;
+  if (config && config.soundOn) playChirp();
+  resumeRaf();
+}
+function ballApproachX() { return zoneClampX(ball.x); }
+function updateBall(t, dt, f) {
+  if (!ball) return;
+  const floor = restingY();
+  ball.spin += (ball.phase === 'fly' ? 0.4 : 0.08) * (dt / 16);
+
+  if (ball.phase === 'fly') {                     // ballistic arc + a couple of bounces
+    const k = dt / 16;
+    ball.vy += 0.62 * k;
+    ball.x += ball.vx * k; ball.y += ball.vy * k;
+    if (ball.y >= floor - BALL_R) {
+      ball.y = floor - BALL_R;
+      if (Math.abs(ball.vy) > 1.6) { ball.vy = -ball.vy * 0.46; ball.vx *= 0.72; }
+      else { ball.vy = 0; ball.vx = 0; ball.phase = 'rest'; ball.restAt = t; }
+    }
+    if (ball.x < EDGE_L || ball.x > viewW - EDGE_R) { ball.vx = -ball.vx * 0.5; ball.x = clamp(ball.x, EDGE_L, viewW - EDGE_R); }
+    return;
+  }
+  if (ball.phase === 'carry') {                   // held in the mouth, tracks the muzzle
+    ball.x = pos.x + (ball.side || 1) * 6;
+    ball.y = pos.y - SH * 0.52;
+    const home = homeX();
+    if (roamUntil <= t) {
+      if (Math.abs(pos.x - home) > 14) {
+        roamFrom = { x: pos.x, y: pos.y };
+        roamTo = { x: home, y: floorLockOn() ? restingY() : pos.y };
+        roamDur = clamp(Math.abs(pos.x - home) * 2.4, 400, 1700); roamUntil = t + roamDur; nextRoam = t + 20000;
+      } else {                                    // delivered: drop it, wag, pant, ask for another
+        ball.phase = 'rest'; ball.restAt = t; ball.y = floor - BALL_R;
+        wagBoost = 1.2; pantUntil = t + 4200; addEnergy(10);
+        popLove(t, pos.x, pos.y - SH * 0.8, 2, 16);
+        if (config && config.soundOn) playChirp();
+      }
+    }
+    return;
+  }
+  // 'rest': lying on the floor. The dog goes and gets it.
+  if (f.grabbing || f.hunting || f.startleActive || f.typing || paperLen > 1) return;
+  if (t - ball.restAt > 45000) { ball = null; return; }        // forgotten after a while
+  const dist = Math.abs(pos.x - ballApproachX());
+  if (dist <= FETCH_GRAB) {
+    ball.phase = 'carry'; ball.side = Math.sign(ball.x - pos.x) || 1;
+    wagBoost = 1.0; roamUntil = 0;
+    lookTarget = { x: ball.x, y: ball.y }; lookTargetUntil = t + 600;
+    return;
+  }
+  if (roamUntil <= t) {                                        // sprint after it
+    roamFrom = { x: pos.x, y: pos.y };
+    roamTo = { x: ballApproachX(), y: floorLockOn() ? restingY() : pos.y };
+    roamDur = clamp(dist * 1.9, 350, 1500); roamUntil = t + roamDur; nextRoam = t + 20000;
+    lookTarget = { x: ball.x, y: ball.y }; lookTargetUntil = t + roamDur;
+  }
+}
+function drawBall(t) {
+  if (!ball) return;
+  const x = Math.round(ball.x), y = Math.round(ball.y);
+  if (ball.phase !== 'carry') drawShadow(x, restingY(), 0.18, 7);
+  ctx.fillStyle = '#3f4a1e';                                   // dark rim keeps it readable on any wallpaper
+  ctx.beginPath(); ctx.arc(x, y, BALL_R + 1, 0, Math.PI * 2); ctx.fill();
+  ctx.fillStyle = '#d8e84a';                                   // tennis yellow-green
+  ctx.beginPath(); ctx.arc(x, y, BALL_R, 0, Math.PI * 2); ctx.fill();
+  ctx.strokeStyle = '#f4f7dd'; ctx.lineWidth = 1.4;            // the seam, rotating with the spin
+  ctx.beginPath(); ctx.arc(x - Math.cos(ball.spin) * 3, y, BALL_R - 0.6, -1.1, 1.1); ctx.stroke();
+  ctx.beginPath(); ctx.arc(x + Math.cos(ball.spin) * 3, y, BALL_R - 0.6, Math.PI - 1.1, Math.PI + 1.1); ctx.stroke();
+}
+
 // --- Treat: tray "Give a treat" drops a little fish nearby; the cat trots over and
 //     noms it (look down, hearts, a happy chirp, an energy bump). Uses the roam
 //     machinery to walk, re-aiming each time the walk expires until it arrives.
@@ -1215,6 +1491,13 @@ function isNight(t) {
 const STARTLE_RANGE = 160;   // only flinch when the cursor lunges NEAR the cat - not on every fast move across the screen
 function bandOf(e) { return e <= CALM_MAX ? 'calm' : e <= PLAYFUL_MAX ? 'playful' : 'zoomies'; }
 function addEnergy(n) { energy = clamp(energy + n, 0, 100); }
+// A dog that has just been sprinting pants. Tied to the zoomies band so it shows
+// up exactly when the sprite is already visibly worked up.
+function updateDogVitals(t, dt) {
+  if (!isDog()) { wagBoost = 0; pantUntil = 0; return; }
+  decayWag(dt);
+  if (energy > PLAYFUL_MAX && t > pantUntil) pantUntil = t + 3000;
+}
 
 function restSprings() { head = { x: pos.x, y: pos.y - SH, vx: 0, vy: 0 }; feet = { x: pos.x, y: pos.y, vx: 0, vy: 0 }; }
 function persistPos() { localStorage.setItem('pos', JSON.stringify({ x: pos.x, y: pos.y })); }
@@ -1567,6 +1850,7 @@ function draw(t) {
       W: toRgb(lerpHex(P.white, HOT_BODY, heatT * 0.5)),
       X: toRgb(lerpHex(P.patch, HOT_BODY, heatT)),
       I: toRgb(P.inner), N: toRgb(P.nose), E: toRgb(P.eye), H: toRgb(HALO),
+      T: toRgb(P.tongue || '#e8747f'),
     };
     pal = { O: rgbStr(palRGB.O), C: rgbStr(palRGB.C), W: rgbStr(palRGB.W), N: rgbStr(palRGB.N) };
   } else {                                  // common case: reuse the cached cold palette for this coat
@@ -1574,6 +1858,7 @@ function draw(t) {
       _coldPalRGB = {
         O: toRgb(P.outline), C: toRgb(P.coat), K: toRgb(P.mark), W: toRgb(P.white), X: toRgb(P.patch),
         I: toRgb(P.inner), N: toRgb(P.nose), E: toRgb(P.eye), H: toRgb(HALO),
+        T: toRgb(P.tongue || '#e8747f'),
       };
       _coldPal = { O: rgbStr(_coldPalRGB.O), C: rgbStr(_coldPalRGB.C), W: rgbStr(_coldPalRGB.W), N: rgbStr(_coldPalRGB.N) };
       _palKey = patternIndex;
@@ -1675,7 +1960,7 @@ function draw(t) {
     }
     drawShadow(pos.x, pos.y, 0.18, 26);
     octx.clearRect(0, 0, oc.width, oc.height);
-    drawCat(octx, spriteHunt, t, palRGB, { bob: creep, blinking, look, eyeMode: 'open', dilate: pouncing ? 1.5 : (windingUp ? 1.32 + coil * 0.2 : 1.32) });
+    drawCat(octx, huntSpriteFor(patternIndex), t, palRGB, { bob: creep, blinking, look, eyeMode: 'open', dilate: pouncing ? 1.5 : (windingUp ? 1.32 + coil * 0.2 : 1.32) });
     ctx.save();
     if (facingLeft) { ctx.translate(ox + HW, oy); ctx.scale(-1, stretchY); ctx.drawImage(oc, 0, 0, HW, HH, 0, 0, HW, HH); }
     else { ctx.translate(ox, oy); ctx.scale(1, stretchY); ctx.drawImage(oc, 0, 0, HW, HH, 0, 0, HW, HH); }
@@ -1795,6 +2080,8 @@ function draw(t) {
     lean += (leanTarget - lean) * 0.09 * step;
     updateButterflyDesk(t, dt, step, { follow, grabbing, hunting, typing, petting, startleActive, calm });
     updateTreat(t, { grabbing, hunting, typing, startleActive });
+    updateBall(t, dt, { grabbing, hunting, typing, startleActive });
+    updateDogVitals(t, dt);
     const gaze = lookTarget || look;
     smoothLook.x += (gaze.x - smoothLook.x) * 0.18 * step;   // snappier cursor tracking
     smoothLook.y += (gaze.y - smoothLook.y) * 0.18 * step;
@@ -1860,7 +2147,11 @@ function draw(t) {
       const ox = Math.round(pos.x - SW / 2) + wig, oy = Math.round(pos.y - SH) - Math.round(hop) - Math.round(petPush);
       const shadowA = (petting || bodyPet) ? 0.14 + Math.sin(t / 800) * 0.05 : 0.18;
       drawShadow(pos.x + wig, pos.y, shadowA);
-      if (!stretching && !thinking && !working && !loafing && !climbRaster) drawTail(pos.x + wig, pos.y, t, pal, tailFlickT0, petting);   // loaf has a baked, wrapped tail; the climb frame has its own tail
+      if (!stretching && !thinking && !working && !loafing && !climbRaster) {
+        // loaf/curl has a baked, wrapped tail; the climb frame has its own
+        if (isDog()) drawDogTail(pos.x + wig, pos.y, t, pal, tailFlickT0, petting, energy / 100 + (ball && ball.phase === 'carry' ? 0.5 : 0));
+        else drawTail(pos.x + wig, pos.y, t, pal, tailFlickT0, petting);
+      }
       if (!lowPower && restIdle && band === 'calm' && !paperActive && t > nextIdleSparkle) {   // ambient sparkles off in low power (they pin the loop at 60fps)
         idleSparkles.push({ x: pos.x + (Math.random() - 0.5) * 8, y: oy, t0: t });
         nextIdleSparkle = t + 5000 + Math.random() * 4000;
@@ -1876,7 +2167,7 @@ function draw(t) {
       } else {
       octx.clearRect(0, 0, oc.width, oc.height);
       const stareDilate = (staring && t - staringT0 < 1800) ? 1.12 : 1;   // subtle wide-eyed fixate
-      drawCat(octx, loafing ? loafSprite : catSprite, t, palRGB, { bob, blinking, look: eLook, eyeMode: emode, blush: petting || bodyPet, dilate: stareDilate });
+      drawCat(octx, loafing ? loafSprite : catSprite, t, palRGB, { bob, blinking, look: eLook, eyeMode: emode, blush: petting || bodyPet, dilate: stareDilate, panting: isDog() && t < pantUntil && !loafing });
       if (paperActive && !petting && !stretching) {
         // both front paws lift off the ground to grip the rope, so paint over the
         // baked planted front legs+paws on the offscreen sprite (so it scales/flips
@@ -1959,6 +2250,7 @@ function draw(t) {
     drawButterfly(ctx, bfX, bfY, BF_SCALE, BFLY_STYLES[bfPal], bfFlap, t, clamp(bfVx / 44, -0.22, 0.22));
   }
   drawTreat();   // the fish sits on the floor line, under the hearts
+  drawBall(t);   // the tennis ball rides above the floor line (and the muzzle when carried)
   // floating hearts (update + draw; persist after petting ends)
   if (hearts.length) hearts = hearts.filter((h) => t - h.t0 < (h.life || 1100));
   for (const h of hearts) {
diff --git a/src/settings-renderer.js b/src/settings-renderer.js
index b09385e..9ca0d2f 100644
--- a/src/settings-renderer.js
+++ b/src/settings-renderer.js
@@ -6,18 +6,33 @@ let cfg = null;
 
 // Populate the coat dropdown from the built-in names plus any custom coats.
 let themes = [];
+// Which species the window is currently editing, and therefore which list of
+// coats to show and which config field a pick writes to.
+function curSpecies() { return (cfg && cfg.species === 'dog') ? 'dog' : 'cat'; }
+function coatField() { return curSpecies() === 'dog' ? 'dogPattern' : 'pattern'; }
 function populateCoats() {
   const sel = $('pattern'); const cur = sel.value;
+  const dog = curSpecies() === 'dog';
   sel.innerHTML = '';
-  const names = (window.PATTERN_NAMES || []).concat(themes.map((t) => t.name));
+  // Custom coats are built from the cat's geometry, so they are only offered for cats.
+  const base = dog ? (window.DOG_COATS || []) : (window.PATTERN_NAMES || []);
+  const names = dog ? base.slice() : base.concat(themes.map((t) => t.name));
   names.forEach((name, i) => { const o = document.createElement('option'); o.value = String(i); o.textContent = name; sel.appendChild(o); });
-  if (cfg) sel.value = String(cfg.pattern || 0); else if (cur) sel.value = cur;
+  const lbl = $('coatLabel'); if (lbl) lbl.textContent = dog ? 'Breed' : 'Coat';
+  if (cfg) sel.value = String(cfg[coatField()] || 0); else if (cur) sel.value = cur;
+  const spSel = $('species'); if (spSel) spSel.value = curSpecies();
   drawPreview();
 }
 function drawPreview() {
   const P = window.PixelcatPreview, cv = $('coatPreview');
   if (!P || !cv) return;
   const i = Number($('pattern').value) || 0;
+  if (curSpecies() === 'dog') {
+    const pal = (window.DOG_PATTERNS || [])[i];
+    if (!pal || !P.drawDog) return;
+    P.drawDog(cv, pal, (window.DOG_PATTERN_BUILD || [])[i]);
+    return;
+  }
   let pal, build, tabby;
   if (i < P.PATTERNS.length) { pal = P.PATTERNS[i]; build = P.PATTERN_BUILD[i]; tabby = P.TABBY[i]; }
   else { const t = themes[i - P.PATTERNS.length]; if (!t) return; pal = t; build = t.build; tabby = t.tabby; }
@@ -42,7 +57,7 @@ function render() {
   // Don't stomp the name field while the user is typing in it (a broadcast config
   // echo would otherwise overwrite it with the normalized value and jump the caret).
   if (document.activeElement !== $('name')) $('name').value = cfg.name || '';
-  $('pattern').value = String(cfg.pattern || 0);
+  $('pattern').value = String(cfg[coatField()] || 0);
   $('breakMinutes').value = String(cfg.breakMinutes || 0);
   $('followCursor').checked = !!cfg.followCursor;
   $('huntOn').checked = !!cfg.huntOn;
@@ -115,7 +130,13 @@ $('name').addEventListener('input', () => {
   clearTimeout(nameTimer);
   nameTimer = setTimeout(() => save({ name: $('name').value }), 300);
 });
-$('pattern').addEventListener('change', () => { save({ pattern: Number($('pattern').value) }); drawPreview(); });
+$('pattern').addEventListener('change', () => { save({ [coatField()]: Number($('pattern').value) }); drawPreview(); });
+$('species').addEventListener('change', () => {
+  const next = $('species').value === 'dog' ? 'dog' : 'cat';
+  if (cfg) cfg.species = next;             // optimistic, so the list swaps before main echoes back
+  save({ species: next });
+  populateCoats();
+});
 $('breakMinutes').addEventListener('change', () => save({ breakMinutes: Number($('breakMinutes').value) }));
 $('followCursor').addEventListener('change', () => save({ followCursor: $('followCursor').checked }));
 $('huntOn').addEventListener('change', () => save({ huntOn: $('huntOn').checked }));
diff --git a/src/settings.html b/src/settings.html
index dcf5eb3..3e4af32 100644
--- a/src/settings.html
+++ b/src/settings.html
@@ -161,7 +161,12 @@
         <input type="text" id="name" maxlength="24" placeholder="e.g. John" />
       </div>
       <div class="row">
-        <label class="lbl" for="pattern">Coat</label>
+        <label class="lbl" for="species">Pet</label>
+        <select id="species">
+          <option value="cat">🐱  Cat</option>
+          <option value="dog">🐶  Dog</option>
+        </select>
+        <label class="lbl" for="pattern" id="coatLabel">Coat</label>
         <select id="pattern"></select>
         <div class="coatPreview-wrap">
           <canvas id="coatPreview" width="120" height="150"></canvas>
@@ -350,6 +355,8 @@
 
   <script src="patterns.js"></script>
   <script src="cat-sprite.js"></script>
+  <script src="dog-sprite.js"></script>
+  <script src="pets.js"></script>
   <script src="cat-preview.js"></script>
   <script src="settings-renderer.js"></script>
 </body>
diff --git a/tests/pets.test.js b/tests/pets.test.js
new file mode 100644
index 0000000..4636694
--- /dev/null
+++ b/tests/pets.test.js
@@ -0,0 +1,90 @@
+const test = require('node:test');
+const assert = require('node:assert');
+
+const cat = require('../src/cat-sprite.js');
+const dog = require('../src/dog-sprite.js');
+const pets = require('../src/pets.js');
+dog.attach(cat);
+
+const POSES = [
+  ['sit', 24, 30, dog.composeSitDog],
+  ['bow', 30, 22, dog.composeBowDog],
+  ['type', 24, 24, dog.composeTypeDog],
+  ['curl', 24, 30, dog.composeCurlDog],
+  ['beg', 24, 30, dog.composeBegDog],
+];
+
+const buildFor = (i) => dog.DOG_BUILDS[dog.DOG_PATTERN_BUILD[i]];
+
+test('every dog breed maps to a real build and a real tail', () => {
+  assert.equal(dog.DOG_PATTERNS.length, dog.DOG_PATTERN_BUILD.length);
+  assert.equal(dog.DOG_PATTERNS.length, dog.DOG_TAILS.length);
+  for (let i = 0; i < dog.DOG_PATTERNS.length; i++) {
+    assert.ok(dog.DOG_BUILDS[dog.DOG_PATTERN_BUILD[i]], `${dog.DOG_PATTERNS[i].name} has no build`);
+    assert.ok(dog.DOG_TAILS[i], `${dog.DOG_PATTERNS[i].name} has no tail shape`);
+  }
+});
+
+test('dog palettes define every role the renderer paints', () => {
+  // A missing key silently drops those cells (drawCat skips unknown roles), so the
+  // breed would render with holes rather than fail loudly. Catch it here instead.
+  const keys = ['name', 'coat', 'mark', 'white', 'patch', 'eye', 'nose', 'inner', 'outline', 'tongue'];
+  for (const p of dog.DOG_PATTERNS) {
+    for (const k of keys) assert.ok(p[k], `${p.name} is missing ${k}`);
+    for (const k of keys.slice(1)) assert.match(p[k], /^#[0-9a-f]{6}$/i, `${p.name}.${k} is not a hex colour`);
+  }
+});
+
+test('every breed composes every pose with a visible body and eyes', () => {
+  for (let i = 0; i < dog.DOG_PATTERNS.length; i++) {
+    const B = buildFor(i);
+    for (const [pose, cols, rows, compose] of POSES) {
+      const sp = cat.buildSprite(cols, rows, () => compose(B));
+      const flat = sp.grid.flat();
+      const body = flat.filter((c) => 'CKWXI'.includes(c)).length;
+      const label = `${dog.DOG_PATTERNS[i].name}/${pose}`;
+      assert.ok(body > 120, `${label} drew only ${body} body cells`);
+      assert.ok(flat.includes('E'), `${label} has no eye`);
+      assert.ok(flat.includes('N'), `${label} has no nose`);
+      assert.ok(flat.includes('O'), `${label} has no outline`);
+    }
+  }
+});
+
+test('the sitting dog keeps its muzzle below the eyes and inside the grid', () => {
+  // The muzzle protruding past the skull is the whole reason a dog does not read
+  // as a cat, so lock the geometry that produces it.
+  for (let i = 0; i < dog.DOG_PATTERNS.length; i++) {
+    const sp = cat.buildSprite(24, 30, () => dog.composeSitDog(buildFor(i)));
+    const name = dog.DOG_PATTERNS[i].name;
+    const eyeY = Math.min(...sp.eyes.filter((e) => e.w > 0).map((e) => e.cy));
+    assert.ok(sp.muzzle.y > eyeY, `${name}: muzzle is not below the eyes`);
+    assert.equal(sp.eyes.filter((e) => e.w > 0).length, 2, `${name}: expected two eyes facing forward`);
+  }
+});
+
+test('dwarf breeds really do get shorter legs than standard ones', () => {
+  const corgi = dog.DOG_PATTERNS.findIndex((p) => p.name === 'Corgi');
+  const golden = dog.DOG_PATTERNS.findIndex((p) => p.name === 'Golden Retriever');
+  assert.ok(corgi >= 0 && golden >= 0);
+  assert.ok(dog.DOG_BUILDS[dog.DOG_PATTERN_BUILD[corgi]].legLen < 1, 'corgi should be short-legged');
+  assert.equal(dog.DOG_BUILDS[dog.DOG_PATTERN_BUILD[golden]].legLen, undefined, 'golden should use full-length legs');
+});
+
+test('species registry agrees with the sprite modules', () => {
+  assert.deepEqual(pets.coatsFor('dog'), dog.DOG_PATTERNS.map((p) => p.name));
+  assert.deepEqual(pets.coatsFor('cat'), cat.PATTERNS.map((p) => p.name));
+  assert.equal(pets.speciesOf('nonsense').id, 'cat', 'unknown species must fall back to cat');
+  assert.ok(pets.defaultCoatIndex('dog') >= 0);
+  assert.ok(pets.defaultCoatIndex('cat') >= 0);
+});
+
+test('config normalises species and keeps a coat per species', () => {
+  // config.js pulls in electron for app.getPath, so exercise the pure helpers via
+  // the same rules rather than booting Electron here.
+  assert.equal(pets.isSpecies('dog'), true);
+  assert.equal(pets.isSpecies('cat'), true);
+  assert.equal(pets.isSpecies('ferret'), false);
+  const dogDefault = pets.defaultCoatIndex('dog');
+  assert.equal(pets.coatsFor('dog')[dogDefault], 'Golden Retriever');
+});