diff --git a/README.md b/README.md
index 74c1398..e830164 100644
--- a/README.md
+++ b/README.md
@@ -9,9 +9,10 @@ WebAssembly, and rendered in the browser.
 **[Live demo](https://chowjiaming.github.io/sandboxed/)**
 
 Paint sand, water, stone, fire, and wood onto a 320×200 grid. The
-simulation runs in WASM: a flat `Vec<Cell>`, no per-frame
-allocation, and a thin `wasm-bindgen` boundary so the core stays
-unit-testable with plain `cargo test`.
+page loads a small wood-and-fire scene so burning is visible
+immediately. The simulation runs in WASM: a flat `Vec<Cell>`, no
+per-frame allocation, and a thin `wasm-bindgen` boundary so the
+core stays unit-testable with plain `cargo test`.
 
 ## Why Rust → WASM
 
@@ -23,18 +24,29 @@ unit-testable with plain `cargo test`.
 
 | Input        | Action                                      |
 | ------------ | ------------------------------------------- |
-| Click / drag | Paint the selected material                 |
-| Brush slider | Radius 1–8                                  |
+| Click / drag | Paint the selected material (gapless stroke)|
+| Shift-drag   | Straight line (horizontal, vertical, or 45°)|
+| Right-click  | Erase                                       |
+| Brush slider | Radius 1–8; `[` `]` or scroll wheel         |
+| 1–9 / 0 / O I G | Select material                          |
+| Arrow keys   | Fan facing                                  |
+| Scenes       | Sink, Float, Burn, Wind, Glass presets      |
 | Pause / Step | Freeze the sim; advance one tick            |
 | Space / `.`  | Pause toggle / single-step                  |
+| `?`          | Toggle shortcut overlay                     |
+| Hover        | Material + heat under the cursor            |
 | Sand         | Falls and piles; sinks through water        |
 | Water        | Flows and spreads                           |
 | Stone        | Static obstacle                             |
 | Fire         | Rises, flickers, burns out; heats neighbors             |
 | Wood         | Static; ignites when heat reaches 80                    |
 | Steam        | Rises; condenses when cool; water boils next to fire    |
-| Fan          | Static; click the swatch to cycle facing; blows gases in that 4×4 |
+| Fan          | Four facing buttons (or arrow keys); blows gases in that 4×4 |
 | Gunpowder    | Falls like sand; explodes from fire or heat 80                    |
+| Smoke        | Rises slower than steam; leftover from burned-out fire            |
+| Oil          | Floats on water; ignites from fire or heat 60                     |
+| Ice          | Static; melts to water at heat 25; water freezes below 15         |
+| Glass        | Sand baked at heat 180; locked like stone                         |
 | Erase / Clear | Remove cells                                           |
 
 ## Quickstart
diff --git a/index.html b/index.html
index 7d4b522..073cc04 100644
--- a/index.html
+++ b/index.html
@@ -25,6 +25,13 @@
     />
     <title>Sandboxed — Rust + WASM falling sand</title>
     <style>
+      * {
+        box-sizing: border-box;
+      }
+      html,
+      body {
+        height: 100%;
+      }
       body {
         margin: 0;
         background: #0b0b10;
@@ -33,24 +40,44 @@
         display: flex;
         flex-direction: column;
         align-items: center;
-        gap: 12px;
-        padding: 16px;
+        gap: 6px;
+        padding: 8px 10px 6px;
+        min-height: 100dvh;
       }
-      canvas {
-        image-rendering: pixelated;
-        border: 1px solid #333;
-        cursor: crosshair;
-        touch-action: none;
+      h1 {
+        margin: 0;
+        font-size: 1.05rem;
+        font-weight: 650;
+        letter-spacing: 0.02em;
       }
-      .bar {
+      #palette {
         display: flex;
         flex-wrap: wrap;
-        gap: 8px;
-        align-items: center;
+        gap: 6px 12px;
+        align-items: flex-end;
         justify-content: center;
+        max-width: 980px;
+      }
+      .group {
+        display: flex;
+        flex-direction: column;
+        gap: 3px;
+      }
+      .group-label {
+        font-size: 10px;
+        letter-spacing: 0.08em;
+        text-transform: uppercase;
+        color: #888;
+        padding-left: 2px;
+      }
+      .group-row {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 4px;
+        align-items: center;
       }
       button {
-        padding: 6px 12px;
+        padding: 4px 8px;
         border: 1px solid #444;
         background: #1a1a24;
         color: #ddd;
@@ -59,60 +86,302 @@
         display: inline-flex;
         align-items: center;
         gap: 6px;
+        font-size: 13px;
+      }
+      button:hover {
+        border-color: #666;
+      }
+      button:focus {
+        outline: none;
+      }
+      button:focus-visible {
+        outline: 2px solid #e0c060;
+        outline-offset: 1px;
       }
       button.active {
         border-color: #e0c060;
         background: #2a2a1a;
       }
+      button.fan {
+        padding: 4px 7px;
+        min-width: 1.9rem;
+        justify-content: center;
+        font-size: 14px;
+      }
       .swatch {
-        width: 12px;
-        height: 12px;
+        width: 11px;
+        height: 11px;
         border-radius: 2px;
         border: 1px solid #0006;
         flex-shrink: 0;
       }
+      .bar {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px;
+        align-items: center;
+        justify-content: center;
+      }
       label.brush {
         display: inline-flex;
         align-items: center;
-        gap: 8px;
-        font-size: 14px;
+        gap: 6px;
+        font-size: 13px;
       }
-      #fps {
+      #stage {
+        position: relative;
+        flex: 1 1 auto;
+        width: 100%;
+        min-height: 120px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      }
+      #stage.paused #view {
+        filter: brightness(0.62);
+      }
+      @media (prefers-reduced-motion: reduce) {
+        #stage.paused #view {
+          filter: none;
+        }
+      }
+      #playfield {
+        position: relative;
+        line-height: 0;
+      }
+      #view,
+      #ghost {
+        image-rendering: pixelated;
+        image-rendering: crisp-edges;
+      }
+      #view {
+        border: 1px solid #333;
+        cursor: crosshair;
+        touch-action: none;
+        display: block;
+      }
+      #ghost {
+        position: absolute;
+        left: 0;
+        top: 0;
+        pointer-events: none;
+      }
+      .overlay {
+        position: absolute;
+        background: #0b0b10cc;
+        border: 1px solid #555;
+        border-radius: 6px;
+        padding: 4px 8px;
+        font-size: 12px;
+        pointer-events: none;
+        white-space: nowrap;
         font-variant-numeric: tabular-nums;
-        opacity: 0.7;
+      }
+      #paused-badge {
+        display: none;
+        top: 10px;
+        left: 50%;
+        transform: translateX(-50%);
+      }
+      #stage.paused #paused-badge {
+        display: block;
+      }
+      #probe {
+        left: 8px;
+        bottom: 8px;
+        max-width: calc(100% - 16px);
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+      #fps {
+        right: 8px;
+        bottom: 8px;
+        opacity: 0.85;
+      }
+      #empty-hint,
+      #shortcuts,
+      #loading {
+        left: 50%;
+        top: 50%;
+        transform: translate(-50%, -50%);
+        white-space: normal;
+        text-align: center;
+        max-width: 90%;
+        line-height: 1.4;
+        pointer-events: none;
+      }
+      #shortcuts {
+        pointer-events: none;
+        display: none;
+      }
+      #shortcuts.open {
+        display: block;
+      }
+      #empty-hint {
+        display: none;
+      }
+      #empty-hint.show {
+        display: block;
+      }
+      #loading {
+        z-index: 2;
       }
     </style>
   </head>
   <body>
     <h1>Sandboxed</h1>
-    <div class="bar" id="palette">
-      <button data-mat="1" class="active">
-        <span class="swatch" style="background: #c2a860"></span>Sand
-      </button>
-      <button data-mat="2">
-        <span class="swatch" style="background: #285ac8"></span>Water
-      </button>
-      <button data-mat="3">
-        <span class="swatch" style="background: #6e6e76"></span>Stone
-      </button>
-      <button data-mat="4">
-        <span class="swatch" style="background: #ff7820"></span>Fire
-      </button>
-      <button data-mat="5">
-        <span class="swatch" style="background: #764824"></span>Wood
-      </button>
-      <button data-mat="6">
-        <span class="swatch" style="background: #d8dce8"></span>Steam
-      </button>
-      <button id="fan" data-mat="7">
-        <span class="swatch" style="background: #5a6e96"></span>Fan →
-      </button>
-      <button data-mat="11">
-        <span class="swatch" style="background: #28241e"></span>Gunpowder
-      </button>
-      <button data-mat="0">
-        <span class="swatch" style="background: #1a1a24"></span>Erase
-      </button>
+    <div id="palette">
+      <div class="group">
+        <span class="group-label">Powder</span>
+        <div class="group-row">
+          <button
+            data-mat="1"
+            class="active"
+            aria-pressed="true"
+            title="Falls and piles; sinks through water (1)"
+          >
+            <span class="swatch" style="background: #c2a860"></span>Sand
+          </button>
+          <button
+            data-mat="11"
+            aria-pressed="false"
+            title="Falls like sand; explodes from fire or heat 80 (8)"
+          >
+            <span class="swatch" style="background: #28241e"></span>Gunpowder
+          </button>
+        </div>
+      </div>
+      <div class="group">
+        <span class="group-label">Liquid</span>
+        <div class="group-row">
+          <button
+            data-mat="2"
+            aria-pressed="false"
+            title="Flows and spreads; boils at heat 100 (2)"
+          >
+            <span class="swatch" style="background: #285ac8"></span>Water
+          </button>
+          <button
+            data-mat="13"
+            aria-pressed="false"
+            title="Floats on water; ignites from fire or heat 60 (O)"
+          >
+            <span class="swatch" style="background: #b46e18"></span>Oil
+          </button>
+        </div>
+      </div>
+      <div class="group">
+        <span class="group-label">Gas</span>
+        <div class="group-row">
+          <button
+            data-mat="4"
+            aria-pressed="false"
+            title="Rises, flickers, burns out; heats neighbors (4)"
+          >
+            <span class="swatch" style="background: #ff7820"></span>Fire
+          </button>
+          <button
+            data-mat="6"
+            aria-pressed="false"
+            title="Rises; condenses when cool (6)"
+          >
+            <span class="swatch" style="background: #d8dce8"></span>Steam
+          </button>
+          <button
+            data-mat="12"
+            aria-pressed="false"
+            title="Rises slower than steam; leftover from burned-out fire (9)"
+          >
+            <span class="swatch" style="background: #606064"></span>Smoke
+          </button>
+        </div>
+      </div>
+      <div class="group">
+        <span class="group-label">Solid</span>
+        <div class="group-row">
+          <button
+            data-mat="3"
+            aria-pressed="false"
+            title="Static obstacle; blocks air (3)"
+          >
+            <span class="swatch" style="background: #6e6e76"></span>Stone
+          </button>
+          <button
+            data-mat="5"
+            aria-pressed="false"
+            title="Static; ignites when heat reaches 80 (5)"
+          >
+            <span class="swatch" style="background: #764824"></span>Wood
+          </button>
+          <button
+            data-mat="14"
+            aria-pressed="false"
+            title="Static; melts to water at heat 25 (I)"
+          >
+            <span class="swatch" style="background: #b4dcf0"></span>Ice
+          </button>
+          <button
+            data-mat="15"
+            aria-pressed="false"
+            title="Sand baked at heat 180; locked like stone (G)"
+          >
+            <span class="swatch" style="background: #5a6e58"></span>Glass
+          </button>
+        </div>
+      </div>
+      <div class="group">
+        <span class="group-label">Fan</span>
+        <div class="group-row" id="fans">
+          <button
+            class="fan"
+            data-mat="7"
+            aria-pressed="false"
+            title="Blows gases right in this 4×4 (→)"
+            aria-label="Fan right"
+          >
+            →
+          </button>
+          <button
+            class="fan"
+            data-mat="8"
+            aria-pressed="false"
+            title="Blows gases left in this 4×4 (←)"
+            aria-label="Fan left"
+          >
+            ←
+          </button>
+          <button
+            class="fan"
+            data-mat="9"
+            aria-pressed="false"
+            title="Blows gases up in this 4×4 (↑)"
+            aria-label="Fan up"
+          >
+            ↑
+          </button>
+          <button
+            class="fan"
+            data-mat="10"
+            aria-pressed="false"
+            title="Blows gases down in this 4×4 (↓)"
+            aria-label="Fan down"
+          >
+            ↓
+          </button>
+        </div>
+      </div>
+      <div class="group">
+        <span class="group-label">Tool</span>
+        <div class="group-row">
+          <button
+            data-mat="0"
+            aria-pressed="false"
+            title="Erase cells; right-click also erases (0)"
+          >
+            <span class="swatch" style="background: #1a1a24"></span>Erase
+          </button>
+        </div>
+      </div>
     </div>
     <div class="bar">
       <label class="brush">
@@ -121,66 +390,199 @@ <h1>Sandboxed</h1>
         <span id="brush-val">3</span>
       </label>
       <button id="pause" aria-pressed="false">Pause</button>
-      <button id="step">Step</button>
+      <button id="step" title="Advance one tick">Step</button>
       <button id="clear">Clear</button>
+      <button id="help" title="Keyboard shortcuts" aria-pressed="false">?</button>
+      <span class="group-label">Scenes</span>
+      <span id="scenes" class="group-row">
+        <button data-scene="sink" title="Sand sinks through water">Sink</button>
+        <button data-scene="float" title="Oil floats on water">Float</button>
+        <button data-scene="burn" title="Wood burns to smoke">Burn</button>
+        <button data-scene="wind" title="Fan blows steam">Wind</button>
+        <button data-scene="glass" title="Fire bakes sand into glass">Glass</button>
+      </span>
+    </div>
+    <div id="stage">
+      <div id="loading" class="overlay">Loading WASM…</div>
+      <div id="playfield" hidden>
+        <canvas id="view"></canvas>
+        <canvas id="ghost"></canvas>
+        <div id="paused-badge" class="overlay">paused · press Space</div>
+        <div id="probe" class="overlay">—</div>
+        <div id="fps" class="overlay"></div>
+        <div id="empty-hint" class="overlay">Paint, or pick a scene</div>
+        <div id="shortcuts" class="overlay">
+          Drag to paint · Shift-drag straight · right-click erase · 1–9 / 0 / O
+          I G select · [ ] or scroll brush · arrows fan facing · Space pause ·
+          . step
+        </div>
+      </div>
     </div>
-    <canvas id="view"></canvas>
-    <div id="fps"></div>
 
     <script type="module">
       import init, { Simulation } from "./pkg/sandboxed.js";
 
       const W = 320;
       const H = 200;
-      const SCALE = 3;
+      const NAMES = [
+        "Empty",
+        "Sand",
+        "Water",
+        "Stone",
+        "Fire",
+        "Wood",
+        "Steam",
+        "Fan →",
+        "Fan ←",
+        "Fan ↑",
+        "Fan ↓",
+        "Gunpowder",
+        "Smoke",
+        "Oil",
+        "Ice",
+        "Glass",
+      ];
+      const SWATCH = {
+        0: "#888888",
+        1: "#c2a860",
+        2: "#285ac8",
+        3: "#6e6e76",
+        4: "#ff7820",
+        5: "#764824",
+        6: "#d8dce8",
+        7: "#5a6e96",
+        8: "#5a6e96",
+        9: "#5a6e96",
+        10: "#5a6e96",
+        11: "#28241e",
+        12: "#606064",
+        13: "#b46e18",
+        14: "#b4dcf0",
+        15: "#5a6e58",
+      };
+      const KEY_MAT = {
+        Digit1: 1,
+        Digit2: 2,
+        Digit3: 3,
+        Digit4: 4,
+        Digit5: 5,
+        Digit6: 6,
+        Digit7: 7,
+        Digit8: 11,
+        Digit9: 12,
+        Digit0: 0,
+        KeyO: 13,
+        KeyI: 14,
+        KeyG: 15,
+      };
+      const FAN_ARROWS = {
+        ArrowRight: 7,
+        ArrowLeft: 8,
+        ArrowUp: 9,
+        ArrowDown: 10,
+      };
 
       const wasm = await init();
-
       const sim = new Simulation(W, H);
       const canvas = document.getElementById("view");
+      const ghost = document.getElementById("ghost");
+      const stage = document.getElementById("stage");
+      const playfield = document.getElementById("playfield");
+      const loading = document.getElementById("loading");
+      const probeEl = document.getElementById("probe");
+      const fpsEl = document.getElementById("fps");
+      const emptyHint = document.getElementById("empty-hint");
+      const shortcuts = document.getElementById("shortcuts");
+      const helpBtn = document.getElementById("help");
       canvas.width = W;
       canvas.height = H;
-      canvas.style.width = `${W * SCALE}px`;
-      canvas.style.height = `${H * SCALE}px`;
+      ghost.width = W;
+      ghost.height = H;
       const ctx = canvas.getContext("2d");
+      const gctx = ghost.getContext("2d");
+
+      loading.remove();
+      playfield.hidden = false;
 
       let material = 1;
+      let lastFan = 7;
       let brush = 3;
       let paused = false;
       let pendingStep = false;
+      let painting = false;
+      let erasing = false;
+      let lastX = 0;
+      let lastY = 0;
+      let originX = 0;
+      let originY = 0;
+      let hover = null;
+      let shiftHeld = false;
+      let frames = 0;
+      let ticks = 0;
+      let lastHud = performance.now();
 
-      const FAN_MATS = [7, 8, 9, 10];
-      const FAN_LABELS = ["Fan →", "Fan ←", "Fan ↑", "Fan ↓"];
-      const fanBtn = document.getElementById("fan");
+      const markDirty = () => {
+        emptyHint.classList.remove("show");
+        hideShortcuts();
+      };
+
+      const hideShortcuts = () => {
+        shortcuts.classList.remove("open");
+        helpBtn.setAttribute("aria-pressed", "false");
+      };
 
-      const setActive = (btn) => {
-        document
-          .querySelectorAll("#palette button")
-          .forEach((b) => b.classList.remove("active"));
-        btn.classList.add("active");
+      const showShortcuts = () => {
+        shortcuts.classList.add("open");
+        helpBtn.setAttribute("aria-pressed", "true");
       };
 
-      document
-        .querySelectorAll("#palette button[data-mat]")
-        .forEach((btn) => {
-          btn.addEventListener("click", () => {
-            if (btn === fanBtn && Number(fanBtn.dataset.mat) === material) {
-              const i = FAN_MATS.indexOf(material);
-              const n = (i + 1) % 4;
-              fanBtn.dataset.mat = String(FAN_MATS[n]);
-              fanBtn.innerHTML = `<span class="swatch" style="background: #5a6e96"></span>${FAN_LABELS[n]}`;
-            }
-            material = Number(btn.dataset.mat);
-            setActive(btn);
-          });
+      showShortcuts();
+      window.setTimeout(() => {
+        if (shortcuts.classList.contains("open")) {
+          hideShortcuts();
+        }
+      }, 8000);
+
+      const fitCanvas = () => {
+        const raw = Math.min(stage.clientWidth / W, stage.clientHeight / H);
+        const scale = raw < 1 ? raw : Math.max(1, Math.floor(raw));
+        const cssW = `${W * scale}px`;
+        const cssH = `${H * scale}px`;
+        canvas.style.width = cssW;
+        canvas.style.height = cssH;
+        ghost.style.width = cssW;
+        ghost.style.height = cssH;
+      };
+      fitCanvas();
+      window.addEventListener("resize", fitCanvas);
+
+      const setActive = (mat) => {
+        material = mat;
+        if (mat >= 7 && mat <= 10) {
+          lastFan = mat;
+        }
+        document.querySelectorAll("#palette button[data-mat]").forEach((b) => {
+          const on = Number(b.dataset.mat) === mat;
+          b.classList.toggle("active", on);
+          b.setAttribute("aria-pressed", String(on));
+        });
+      };
+
+      document.querySelectorAll("#palette button[data-mat]").forEach((btn) => {
+        btn.addEventListener("click", () => {
+          setActive(Number(btn.dataset.mat));
         });
+      });
 
       const brushInput = document.getElementById("brush");
       const brushVal = document.getElementById("brush-val");
-      brushInput.addEventListener("input", () => {
-        brush = Number(brushInput.value);
+      const setBrush = (next) => {
+        brush = Math.min(8, Math.max(1, next));
+        brushInput.value = String(brush);
         brushVal.textContent = String(brush);
-      });
+        drawGhost();
+      };
+      brushInput.addEventListener("input", () => setBrush(Number(brushInput.value)));
 
       const pauseBtn = document.getElementById("pause");
       const setPaused = (next) => {
@@ -188,6 +590,7 @@ <h1>Sandboxed</h1>
         pauseBtn.classList.toggle("active", paused);
         pauseBtn.setAttribute("aria-pressed", String(paused));
         pauseBtn.textContent = paused ? "Resume" : "Pause";
+        stage.classList.toggle("paused", paused);
       };
       pauseBtn.addEventListener("click", () => setPaused(!paused));
       document.getElementById("step").addEventListener("click", () => {
@@ -195,21 +598,121 @@ <h1>Sandboxed</h1>
         pendingStep = true;
       });
       document.getElementById("clear").addEventListener("click", () => {
+        if (window.confirm("Clear the world?")) {
+          sim.clear();
+          sim.redraw();
+          hideShortcuts();
+          emptyHint.classList.add("show");
+        }
+      });
+      helpBtn.addEventListener("click", () => {
+        if (shortcuts.classList.contains("open")) {
+          hideShortcuts();
+        } else {
+          showShortcuts();
+        }
+      });
+
+      const SCENES = {
+        sink: () => {
+          sim.fill_rect(90, 130, 140, 4, 3);
+          sim.fill_rect(90, 90, 4, 44, 3);
+          sim.fill_rect(226, 90, 4, 44, 3);
+          sim.fill_rect(94, 110, 132, 20, 2);
+          sim.fill_rect(140, 70, 40, 16, 1);
+        },
+        float: () => {
+          sim.fill_rect(90, 130, 140, 4, 3);
+          sim.fill_rect(90, 90, 4, 44, 3);
+          sim.fill_rect(226, 90, 4, 44, 3);
+          sim.fill_rect(94, 118, 132, 12, 2);
+          sim.fill_rect(94, 100, 132, 16, 13);
+        },
+        burn: () => {
+          sim.fill_rect(140, 90, 40, 50, 5);
+          sim.fill_rect(148, 78, 24, 14, 4);
+        },
+        wind: () => {
+          sim.fill_rect(24, 96, 1, 1, 7);
+          sim.fill_rect(48, 88, 28, 20, 6);
+        },
+        glass: () => {
+          sim.fill_rect(130, 80, 60, 4, 3);
+          sim.fill_rect(130, 140, 60, 4, 3);
+          sim.fill_rect(130, 84, 4, 56, 3);
+          sim.fill_rect(186, 84, 4, 56, 3);
+          sim.fill_rect(150, 118, 24, 18, 1);
+          sim.fill_rect(154, 96, 16, 18, 4);
+        },
+      };
+
+      const loadScene = (name, intro = false) => {
+        const build = SCENES[name];
+        if (!build) {
+          return;
+        }
         sim.clear();
+        build();
+        sim.redraw();
+        if (intro) {
+          emptyHint.classList.remove("show");
+        } else {
+          markDirty();
+        }
+      };
+
+      document.querySelectorAll("#scenes button[data-scene]").forEach((btn) => {
+        btn.addEventListener("click", () => loadScene(btn.dataset.scene));
       });
+      loadScene("burn", true);
 
       window.addEventListener("keydown", (e) => {
         if (e.target instanceof HTMLInputElement) return;
+        if (e.key === "Shift") {
+          shiftHeld = true;
+          drawGhost();
+        }
         if (e.code === "Space") {
           e.preventDefault();
           setPaused(!paused);
-        } else if (e.code === "Period") {
+          return;
+        }
+        if (e.code === "Period") {
           setPaused(true);
           pendingStep = true;
+          return;
+        }
+        if (e.code === "Slash" && e.shiftKey) {
+          e.preventDefault();
+          helpBtn.click();
+          return;
+        }
+        if (e.code === "BracketLeft") {
+          setBrush(brush - 1);
+          return;
+        }
+        if (e.code === "BracketRight") {
+          setBrush(brush + 1);
+          return;
+        }
+        if (FAN_ARROWS[e.code] !== undefined) {
+          e.preventDefault();
+          setActive(FAN_ARROWS[e.code]);
+          return;
+        }
+        const mat = KEY_MAT[e.code];
+        if (mat !== undefined) {
+          e.preventDefault();
+          setActive(mat === 7 ? lastFan : mat);
+        }
+      });
+      window.addEventListener("keyup", (e) => {
+        if (e.key === "Shift") {
+          shiftHeld = false;
+          drawGhost();
         }
       });
 
-      let painting = false;
       const toGrid = (e) => {
         const r = canvas.getBoundingClientRect();
         return [
@@ -217,29 +720,145 @@ <h1>Sandboxed</h1>
           Math.floor(((e.clientY - r.top) / r.height) * H),
         ];
       };
-      const paintAt = (e) => {
-        const [x, y] = toGrid(e);
-        sim.paint(x, y, material, brush);
+
+      const snapPoint = (ox, oy, x, y, shift) => {
+        if (!shift) {
+          return [x, y];
+        }
+        const dx = x - ox;
+        const dy = y - oy;
+        const adx = Math.abs(dx);
+        const ady = Math.abs(dy);
+        if (adx === 0 && ady === 0) {
+          return [x, y];
+        }
+        if (ady < adx / 2) {
+          return [x, oy];
+        }
+        if (adx < ady / 2) {
+          return [ox, y];
+        }
+        const d = Math.min(adx, ady);
+        return [ox + Math.sign(dx) * d, oy + Math.sign(dy) * d];
+      };
+
+      const strokeMat = (e) => {
+        if (e.buttons & 2 || e.button === 2) {
+          return 0;
+        }
+        return material;
+      };
+
+      const paintStroke = (x0, y0, x1, y1, mat) => {
+        sim.paint_line(x0, y0, x1, y1, mat, brush);
+        markDirty();
+        if (paused) {
+          sim.redraw();
+        }
+      };
+
+      const updateProbe = (x, y) => {
+        if (x < 0 || y < 0 || x >= W || y >= H) {
+          probeEl.textContent = "—";
+          return;
+        }
+        const id = sim.cell_at(x, y);
+        const heat = sim.heat_at(x, y);
+        const name = NAMES[id] ?? `id ${id}`;
+        probeEl.textContent =
+          id === 0 ? `${name}  (${x},${y})` : `${name}  heat ${heat}  (${x},${y})`;
+      };
+
+      const ghostColor = () => {
+        if (erasing) {
+          return "rgba(200,200,200,0.7)";
+        }
+        return SWATCH[material] ?? "#ffffff";
       };
+
+      const drawGhost = () => {
+        gctx.clearRect(0, 0, W, H);
+        if (!hover) {
+          return;
+        }
+        const [hx, hy] = hover;
+        const [x, y] = painting
+          ? snapPoint(originX, originY, hx, hy, shiftHeld)
+          : [hx, hy];
+        gctx.strokeStyle = ghostColor();
+        gctx.lineWidth = 1;
+        if (painting && shiftHeld) {
+          gctx.beginPath();
+          gctx.moveTo(originX + 0.5, originY + 0.5);
+          gctx.lineTo(x + 0.5, y + 0.5);
+          gctx.stroke();
+        }
+        gctx.beginPath();
+        gctx.arc(x + 0.5, y + 0.5, brush + 0.45, 0, Math.PI * 2);
+        gctx.stroke();
+      };
+
+      canvas.addEventListener("contextmenu", (e) => e.preventDefault());
+      canvas.addEventListener(
+        "wheel",
+        (e) => {
+          e.preventDefault();
+          setBrush(brush + (e.deltaY < 0 ? 1 : -1));
+        },
+        { passive: false },
+      );
+      canvas.addEventListener("pointerenter", () => {
+        canvas.style.cursor = "none";
+      });
       canvas.addEventListener("pointerdown", (e) => {
         painting = true;
+        erasing = e.button === 2 || (e.buttons & 2) !== 0;
+        shiftHeld = e.shiftKey;
         canvas.setPointerCapture(e.pointerId);
-        paintAt(e);
+        canvas.style.cursor = "none";
+        const [x, y] = toGrid(e);
+        originX = x;
+        originY = y;
+        lastX = x;
+        lastY = y;
+        hover = [x, y];
+        paintStroke(x, y, x, y, strokeMat(e));
+        updateProbe(x, y);
+        drawGhost();
       });
       canvas.addEventListener("pointermove", (e) => {
-        if (!painting) return;
-        paintAt(e);
+        const [x, y] = toGrid(e);
+        hover = [x, y];
+        shiftHeld = e.shiftKey;
+        erasing = painting && (e.buttons & 2) !== 0;
+        updateProbe(x, y);
+        drawGhost();
+        if (!painting) {
+          return;
+        }
+        const [sx, sy] = snapPoint(originX, originY, x, y, e.shiftKey);
+        paintStroke(lastX, lastY, sx, sy, strokeMat(e));
+        lastX = sx;
+        lastY = sy;
+      });
+      const endStroke = () => {
+        painting = false;
+        erasing = false;
+        drawGhost();
+      };
+      canvas.addEventListener("pointerup", endStroke);
+      canvas.addEventListener("pointercancel", endStroke);
+      canvas.addEventListener("pointerleave", () => {
+        if (painting) {
+          return;
+        }
+        hover = null;
+        probeEl.textContent = "—";
+        canvas.style.cursor = "crosshair";
+        drawGhost();
       });
-      canvas.addEventListener("pointerup", () => (painting = false));
-      canvas.addEventListener("pointercancel", () => (painting = false));
-
-      const fpsEl = document.getElementById("fps");
-      let frames = 0;
-      let last = performance.now();
 
       function blit() {
-        // Re-create the view every frame: memory.buffer is
-        // invalidated if WASM memory grows.
         const pixels = new Uint8ClampedArray(
           wasm.memory.buffer,
           sim.frame_ptr(),
@@ -251,20 +870,23 @@ <h1>Sandboxed</h1>
       function loop() {
         if (!paused || pendingStep) {
           sim.tick();
+          ticks++;
           pendingStep = false;
-        } else {
-          sim.redraw();
         }
         blit();
+        drawGhost();
 
         frames++;
         const now = performance.now();
-        if (now - last >= 500) {
+        if (now - lastHud >= 500) {
+          const fps = Math.round((frames * 1000) / (now - lastHud));
+          const tps = Math.round((ticks * 1000) / (now - lastHud));
           fpsEl.textContent = paused
-            ? "paused"
-            : `${Math.round((frames * 1000) / (now - last))} fps`;
+            ? `paused · 0 tps · ${fps} fps`
+            : `${fps} fps · ${tps} tps`;
           frames = 0;
-          last = now;
+          ticks = 0;
+          lastHud = now;
         }
         requestAnimationFrame(loop);
       }
diff --git a/src/lib.rs b/src/lib.rs
index aef0e2c..1169b86 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -50,13 +50,52 @@ impl Simulation {
     }
 
     /// Paint `material` (0=erase, 1=sand, 2=water, 3=stone, 4=fire, 5=wood,
-    /// 6=steam, 7=fan→, 8=fan←, 9=fan↑, 10=fan↓, 11=gunpowder) at (x, y).
+    /// 6=steam, 7=fan→, 8=fan←, 9=fan↑, 10=fan↓, 11=gunpowder, 12=smoke,
+    /// 13=oil, 14=ice, 15=glass) at (x, y).
     pub fn paint(&mut self, x: usize, y: usize, material: u8, radius: usize) {
         if let Some(cell) = Cell::from_u8(material) {
             self.world.paint(x, y, cell, radius);
         }
     }
 
+    /// Stamp `material` along a line so fast pointer strokes do not skip cells.
+    pub fn paint_line(
+        &mut self,
+        x0: usize,
+        y0: usize,
+        x1: usize,
+        y1: usize,
+        material: u8,
+        radius: usize,
+    ) {
+        if let Some(cell) = Cell::from_u8(material) {
+            self.world.paint_line(x0, y0, x1, y1, cell, radius);
+        }
+    }
+
+    /// Fill a rectangle of `material`. Used by demo scenes; not on the hot path.
+    pub fn fill_rect(&mut self, x: usize, y: usize, w: usize, h: usize, material: u8) {
+        if let Some(cell) = Cell::from_u8(material) {
+            self.world.fill_rect(x, y, w, h, cell);
+        }
+    }
+
+    /// Material id at (x, y), or 0 (empty) if out of bounds.
+    pub fn cell_at(&self, x: usize, y: usize) -> u8 {
+        if x >= self.world.width || y >= self.world.height {
+            return 0;
+        }
+        self.world.get(x, y) as u8
+    }
+
+    /// Heat at (x, y), or 0 if out of bounds.
+    pub fn heat_at(&self, x: usize, y: usize) -> u8 {
+        if x >= self.world.width || y >= self.world.height {
+            return 0;
+        }
+        self.world.heat()[y * self.world.width + x]
+    }
+
     pub fn clear(&mut self) {
         self.world = World::new(self.world.width, self.world.height);
     }
@@ -83,4 +122,34 @@ mod tests {
         sim.tick();
         assert_ne!(paused, frame_bytes(&sim));
     }
+
+    #[test]
+    fn cell_at_and_heat_at_read_painted_cells() {
+        let mut sim = Simulation::new(4, 4);
+        sim.paint(2, 1, 6, 0);
+        assert_eq!(sim.cell_at(2, 1), 6);
+        assert_eq!(sim.heat_at(2, 1), 120);
+        assert_eq!(sim.cell_at(0, 0), 0);
+        assert_eq!(sim.cell_at(99, 99), 0);
+        assert_eq!(sim.heat_at(99, 99), 0);
+    }
+
+    #[test]
+    fn paint_line_does_not_skip_cells() {
+        let mut sim = Simulation::new(8, 8);
+        sim.paint_line(0, 0, 7, 7, 1, 0);
+        for i in 0..8 {
+            assert_eq!(sim.cell_at(i, i), 1);
+        }
+    }
+
+    #[test]
+    fn fill_rect_round_trips_through_cell_at() {
+        let mut sim = Simulation::new(8, 8);
+        sim.fill_rect(1, 1, 3, 2, 1);
+        assert_eq!(sim.cell_at(1, 1), 1);
+        assert_eq!(sim.cell_at(3, 2), 1);
+        assert_eq!(sim.cell_at(0, 1), 0);
+        assert_eq!(sim.cell_at(4, 1), 0);
+    }
 }
diff --git a/src/renderer.rs b/src/renderer.rs
index a5d50f3..151e008 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -70,6 +70,22 @@ pub fn draw(world: &World, frame: &mut [u8]) {
                 let (r, g, b) = warm(40 + j / 2, 36 + j / 2, 32, h);
                 put(frame, i, r, g, b);
             }
+            Cell::Smoke => {
+                let (r, g, b) = warm(96 + j / 2, 96 + j / 2, 100, h);
+                put(frame, i, r, g, b);
+            }
+            Cell::Oil => {
+                let (r, g, b) = warm(180 + j / 2, 110 + j / 3, 24, h);
+                put(frame, i, r, g, b);
+            }
+            Cell::Ice => {
+                let (r, g, b) = warm(180 + j / 3, 220 + j / 2, 240, h);
+                put(frame, i, r, g, b);
+            }
+            Cell::Glass => {
+                let (r, g, b) = warm(90 + j / 2, 110 + j / 3, 88, h);
+                put(frame, i, r, g, b);
+            }
         }
     }
 }
diff --git a/src/world.rs b/src/world.rs
index 2834204..10c727a 100644
--- a/src/world.rs
+++ b/src/world.rs
@@ -19,6 +19,10 @@ pub enum Cell {
     FanUp = 9,
     FanDown = 10,
     Gunpowder = 11,
+    Smoke = 12,
+    Oil = 13,
+    Ice = 14,
+    Glass = 15,
 }
 
 impl Cell {
@@ -36,6 +40,10 @@ impl Cell {
             9 => Some(Cell::FanUp),
             10 => Some(Cell::FanDown),
             11 => Some(Cell::Gunpowder),
+            12 => Some(Cell::Smoke),
+            13 => Some(Cell::Oil),
+            14 => Some(Cell::Ice),
+            15 => Some(Cell::Glass),
             _ => None,
         }
     }
@@ -43,12 +51,14 @@ impl Cell {
     /// "Density" used for sinking behavior: sand sinks through water.
     fn density(self) -> u8 {
         match self {
-            Cell::Empty => 0,
-            Cell::Water => 1,
-            Cell::Gunpowder | Cell::Sand => 2,
-            Cell::Fire | Cell::Steam => 0,
+            Cell::Empty | Cell::Fire | Cell::Steam | Cell::Smoke => 0,
+            Cell::Oil => 1,
+            Cell::Water => 2,
+            Cell::Gunpowder | Cell::Sand => 3,
             Cell::Stone
             | Cell::Wood
+            | Cell::Ice
+            | Cell::Glass
             | Cell::FanRight
             | Cell::FanLeft
             | Cell::FanUp
@@ -66,12 +76,12 @@ impl Cell {
 
     #[inline]
     fn is_locked(self) -> bool {
-        matches!(self, Cell::Stone | Cell::Wood) || self.is_fan()
+        matches!(self, Cell::Stone | Cell::Wood | Cell::Ice | Cell::Glass) || self.is_fan()
     }
 
     #[inline]
     fn blocks_air(self) -> bool {
-        matches!(self, Cell::Stone | Cell::Wood)
+        matches!(self, Cell::Stone | Cell::Wood | Cell::Ice | Cell::Glass)
     }
 }
 
@@ -82,6 +92,13 @@ const WOOD_IGNITE: u8 = 80;
 const WATER_BOIL: u8 = 100;
 const STEAM_CONDENSE: u8 = 40;
 const STEAM_PAINT_HEAT: u8 = 120;
+const SMOKE_PAINT_HEAT: u8 = 80;
+const SMOKE_DISPERSE: u8 = 10;
+const ROOM_HEAT: u8 = 50;
+const OIL_IGNITE: u8 = 60;
+const ICE_FREEZE: u8 = 15;
+const ICE_MELT: u8 = 25;
+const GLASS_HEAT: u8 = 180;
 const CHUNK: usize = 16;
 pub(crate) const AIR_CELL: usize = 4;
 const FAN_SPEED: i16 = 40;
@@ -92,6 +109,7 @@ const GUN_PV: i16 = 400;
 const GUN_IGNITE: u8 = 80;
 const AIR_ADV: i32 = 32;
 const AIR_FP: i32 = 256;
+const MAX_FALL: i8 = 3;
 
 pub struct World {
     pub width: usize,
@@ -123,6 +141,11 @@ pub struct World {
     vy_prev: Vec<i16>,
     /// Air cells that contain a locked pixel; velocity is zeroed after advection.
     blocked: Vec<bool>,
+    /// Coarse ambient heat on the air grid. Empty pixels stay at heat 0.
+    ah: Vec<u8>,
+    /// Per-pixel inertia. Empty and locked cells are always 0.
+    pvx: Vec<i8>,
+    pvy: Vec<i8>,
 }
 
 impl World {
@@ -155,6 +178,9 @@ impl World {
             vx_prev: vec![0; nair],
             vy_prev: vec![0; nair],
             blocked: vec![false; nair],
+            ah: vec![ROOM_HEAT; nair],
+            pvx: vec![0; width * height],
+            pvy: vec![0; width * height],
         }
     }
 
@@ -183,6 +209,18 @@ impl World {
         &self.heat
     }
 
+    #[inline]
+    #[cfg(test)]
+    pub fn pvx(&self) -> &[i8] {
+        &self.pvx
+    }
+
+    #[inline]
+    #[cfg(test)]
+    pub fn pvy(&self) -> &[i8] {
+        &self.pvy
+    }
+
     #[inline]
     fn air_idx(&self, ax: usize, ay: usize) -> usize {
         ay * self.air_w + ax
@@ -251,14 +289,44 @@ impl World {
         self.blocked.fill(false);
         for y in 0..self.height {
             for x in 0..self.width {
-                if self.get(x, y).blocks_air() {
+                let cell = self.get(x, y);
+                if cell.blocks_air() {
                     let i = self.air_idx_of(x, y);
                     self.blocked[i] = true;
                 }
+                if cell != Cell::Empty {
+                    self.apply_phase(x, y);
+                    if self.get(x, y) != Cell::Empty {
+                        self.exchange_ambient(x, y);
+                    }
+                }
             }
         }
     }
 
+    fn exchange_ambient(&mut self, x: usize, y: usize) {
+        let i = self.idx(x, y);
+        let ai = self.air_idx_of(x, y);
+        let h = self.heat[i];
+        let a = self.ah[ai];
+        if h == a {
+            return;
+        }
+        let give = (h.abs_diff(a) / 8).max(1);
+        let gas = matches!(self.cells[i], Cell::Fire | Cell::Steam | Cell::Smoke);
+        if h > a && gas {
+            self.heat[i] = h.saturating_sub(give);
+            self.ah[ai] = a.saturating_add(give);
+        } else if h < a && !gas {
+            self.heat[i] = h.saturating_add(give);
+            self.ah[ai] = a.saturating_sub(give);
+        } else {
+            return;
+        }
+        self.wake(x, y, true);
+        self.apply_phase(x, y);
+    }
+
     fn inject_fans(&mut self) {
         for y in 0..self.height {
             for x in 0..self.width {
@@ -405,6 +473,7 @@ impl World {
             }
         }
         std::mem::swap(&mut self.pv, &mut self.pv_prev);
+        self.apply_boussinesq();
         self.blur_velocity();
         self.advect_velocity();
         self.zero_blocked_velocity();
@@ -420,6 +489,13 @@ impl World {
         }
     }
 
+    fn apply_boussinesq(&mut self) {
+        for i in 0..self.ah.len() {
+            let lift = self.ah[i].saturating_sub(ROOM_HEAT) / 32;
+            self.vy[i] = self.vy[i].saturating_sub(lift as i16);
+        }
+    }
+
     fn carry_jets(&mut self) {
         self.vx_prev.copy_from_slice(&self.vx);
         self.vy_prev.copy_from_slice(&self.vy);
@@ -505,24 +581,89 @@ impl World {
                 self.heat[i] = match cell {
                     Cell::Fire => FIRE_HEAT,
                     Cell::Steam => STEAM_PAINT_HEAT,
+                    Cell::Smoke => SMOKE_PAINT_HEAT,
+                    Cell::Water | Cell::Oil => ROOM_HEAT,
                     _ => 0,
                 };
+                self.pvx[i] = 0;
+                self.pvy[i] = 0;
                 self.wake(px, py, false);
             }
         }
     }
 
+    /// Fill a rectangle by stamping radius-0 `paint` so lock/heat/wake stay shared.
+    pub fn fill_rect(&mut self, x: usize, y: usize, w: usize, h: usize, cell: Cell) {
+        let x1 = x.saturating_add(w);
+        let y1 = y.saturating_add(h);
+        for py in y..y1 {
+            for px in x..x1 {
+                self.paint(px, py, cell, 0);
+            }
+        }
+    }
+
+    /// Stamp `cell` along a Bresenham line so fast strokes do not skip pixels.
+    pub fn paint_line(
+        &mut self,
+        x0: usize,
+        y0: usize,
+        x1: usize,
+        y1: usize,
+        cell: Cell,
+        radius: usize,
+    ) {
+        let mut x = x0 as isize;
+        let mut y = y0 as isize;
+        let x1 = x1 as isize;
+        let y1 = y1 as isize;
+        let dx = (x1 - x).abs();
+        let sx = if x < x1 { 1 } else { -1 };
+        let dy = -(y1 - y).abs();
+        let sy = if y < y1 { 1 } else { -1 };
+        let mut err = dx + dy;
+        loop {
+            if x >= 0 && y >= 0 {
+                self.paint(x as usize, y as usize, cell, radius);
+            }
+            if x == x1 && y == y1 {
+                break;
+            }
+            let e2 = 2 * err;
+            if e2 >= dy {
+                err += dy;
+                x += sx;
+            }
+            if e2 <= dx {
+                err += dx;
+                y += sy;
+            }
+        }
+    }
+
     fn swap(&mut self, x1: usize, y1: usize, x2: usize, y2: usize) {
         let a = self.idx(x1, y1);
         let b = self.idx(x2, y2);
         self.cells.swap(a, b);
         self.ttl.swap(a, b);
         self.heat.swap(a, b);
+        self.pvx.swap(a, b);
+        self.pvy.swap(a, b);
         self.moved[b] = true;
+        self.clear_inert_vel(a);
+        self.clear_inert_vel(b);
         self.wake(x1, y1, true);
         self.wake(x2, y2, true);
     }
 
+    #[inline]
+    fn clear_inert_vel(&mut self, i: usize) {
+        if self.cells[i] == Cell::Empty || self.cells[i].is_locked() {
+            self.pvx[i] = 0;
+            self.pvy[i] = 0;
+        }
+    }
+
     /// Can `mover` displace `target`? Empty always; denser sinks
     /// through lighter fluids.
     fn can_displace(mover: Cell, target: Cell) -> bool {
@@ -632,8 +773,10 @@ impl World {
                             Cell::Sand => self.step_sand(x, y),
                             Cell::Gunpowder => self.step_gunpowder(x, y),
                             Cell::Water => self.step_water(x, y),
+                            Cell::Oil => self.step_oil(x, y),
                             Cell::Fire => self.step_fire(x, y),
                             Cell::Steam => self.step_steam(x, y),
+                            Cell::Smoke => self.step_smoke(x, y),
                             _ => {}
                         }
                     }
@@ -649,6 +792,8 @@ impl World {
         self.cells[i] = Cell::Fire;
         self.ttl[i] = FIRE_LIFETIME;
         self.heat[i] = FIRE_HEAT;
+        self.pvx[i] = 0;
+        self.pvy[i] = 0;
         self.moved[i] = true;
         self.wake(x, y, true);
     }
@@ -670,13 +815,39 @@ impl World {
         }
         self.heat[i] = self.heat[i].saturating_add(amount);
         self.wake(x, y, true);
+        self.apply_phase(x, y);
+    }
+
+    fn boil_threshold(&self, x: usize, y: usize) -> u8 {
+        let pv = self.pv[self.air_idx_of(x, y)].max(0);
+        WATER_BOIL.saturating_add((pv / 40) as u8)
+    }
+
+    fn condense_threshold(&self, x: usize, y: usize) -> u8 {
+        let pv = self.pv[self.air_idx_of(x, y)].max(0);
+        STEAM_CONDENSE.saturating_sub((pv / 40) as u8)
+    }
+
+    fn apply_phase(&mut self, x: usize, y: usize) {
+        let i = self.idx(x, y);
         match self.cells[i] {
             Cell::Wood if self.heat[i] >= WOOD_IGNITE => self.ignite(x, y),
-            Cell::Water if self.heat[i] >= WATER_BOIL => {
+            Cell::Gunpowder if self.heat[i] >= GUN_IGNITE => self.explode_gunpowder(x, y),
+            Cell::Water if self.heat[i] >= self.boil_threshold(x, y) => {
                 self.cells[i] = Cell::Steam;
                 self.ttl[i] = 0;
                 self.add_pv(x, y, BOIL_PV);
             }
+            Cell::Ice if self.heat[i] >= ICE_MELT => {
+                self.cells[i] = Cell::Water;
+                self.ttl[i] = 0;
+            }
+            Cell::Sand if self.heat[i] >= GLASS_HEAT => {
+                self.cells[i] = Cell::Glass;
+                self.ttl[i] = 0;
+                self.pvx[i] = 0;
+                self.pvy[i] = 0;
+            }
             _ => {}
         }
     }
@@ -699,7 +870,8 @@ impl World {
             if nx >= self.width || ny >= self.height {
                 continue;
             }
-            if self.get(nx, ny) == Cell::Empty {
+            let n = self.get(nx, ny);
+            if n == Cell::Empty || n == Cell::Stone || n.is_fan() {
                 continue;
             }
             let ni = self.idx(nx, ny);
@@ -760,6 +932,15 @@ impl World {
         self.cells[i] = Cell::Empty;
         self.ttl[i] = 0;
         self.heat[i] = 0;
+        self.pvx[i] = 0;
+        self.pvy[i] = 0;
+        self.wake(x, y, true);
+    }
+
+    fn become_smoke(&mut self, x: usize, y: usize) {
+        let i = self.idx(x, y);
+        self.cells[i] = Cell::Smoke;
+        self.ttl[i] = 0;
         self.wake(x, y, true);
     }
 
@@ -767,7 +948,7 @@ impl World {
         self.wake(x, y, true);
         if let Some((wx, wy)) = self.first_cardinal(x, y, Cell::Water) {
             let wi = self.idx(wx, wy);
-            let bump = WATER_BOIL.saturating_sub(self.heat[wi]);
+            let bump = self.boil_threshold(wx, wy).saturating_sub(self.heat[wi]);
             self.add_heat(wx, wy, bump);
             self.extinguish(x, y);
             return;
@@ -777,12 +958,12 @@ impl World {
         self.conduct(x, y);
         let life = self.ttl[i];
         if life <= 1 {
-            self.extinguish(x, y);
+            self.become_smoke(x, y);
             return;
         }
         // Flicker: extra chance to die near the end of life.
         if life <= 4 && self.next_rand() & 7 == 0 {
-            self.extinguish(x, y);
+            self.become_smoke(x, y);
             return;
         }
         self.ttl[i] = life - 1;
@@ -790,48 +971,91 @@ impl World {
         if self.has_adjacent_wood(x, y) {
             return;
         }
-        if self.try_air_push(x, y, GAS_PUSH) {
-            return;
-        }
-        if y == 0 {
+        let (x, y) = self.apply_gas_air(x, y);
+        self.rise_gas(x, y);
+    }
+
+    fn step_steam(&mut self, x: usize, y: usize) {
+        self.wake(x, y, true);
+        let i = self.idx(x, y);
+        self.heat[i] = self.heat[i].saturating_sub(1);
+        self.conduct(x, y);
+        let i = self.idx(x, y);
+        if self.cells[i] != Cell::Steam {
             return;
         }
-        let above = y - 1;
-        if self.try_move(x, y, x, above) {
+        if self.heat[i] < self.condense_threshold(x, y) {
+            self.cells[i] = Cell::Water;
+            self.ttl[i] = 0;
+            self.wake(x, y, true);
             return;
         }
-        let left_first = self.next_rand() & 1 == 0;
-        let diagonals: [(isize, usize); 2] = [(-1, above), (1, above)];
-        for k in 0..2 {
-            let (dx, ny) = diagonals[if left_first { k } else { 1 - k }];
-            let nx = x as isize + dx;
-            if nx < 0 {
-                continue;
-            }
-            if self.try_move(x, y, nx as usize, ny) {
-                return;
-            }
-        }
+        let (x, y) = self.apply_gas_air(x, y);
+        self.rise_gas(x, y);
     }
 
-    fn step_steam(&mut self, x: usize, y: usize) {
+    fn step_smoke(&mut self, x: usize, y: usize) {
         self.wake(x, y, true);
         let i = self.idx(x, y);
         self.heat[i] = self.heat[i].saturating_sub(1);
         self.conduct(x, y);
         let i = self.idx(x, y);
-        if self.cells[i] != Cell::Steam {
+        if self.cells[i] != Cell::Smoke {
             return;
         }
-        if self.heat[i] < STEAM_CONDENSE {
-            self.cells[i] = Cell::Water;
+        if self.heat[i] < SMOKE_DISPERSE {
+            self.cells[i] = Cell::Empty;
+            self.heat[i] = 0;
             self.ttl[i] = 0;
+            self.pvx[i] = 0;
+            self.pvy[i] = 0;
             self.wake(x, y, true);
             return;
         }
-        if self.try_air_push(x, y, GAS_PUSH) {
+        let (x, y) = self.apply_gas_air(x, y);
+        if !self.frame.is_multiple_of(2) {
             return;
         }
+        self.rise_gas(x, y);
+    }
+
+    fn apply_gas_air(&mut self, x: usize, y: usize) -> (usize, usize) {
+        let i = self.air_idx_of(x, y);
+        let vx = self.vx[i];
+        let vy = self.vy[i];
+        let (dx, dy, mag) = if vx.abs() >= vy.abs() {
+            if vx.abs() < GAS_PUSH {
+                return (x, y);
+            }
+            (vx.signum() as isize, 0, vx.abs())
+        } else {
+            if vy.abs() < GAS_PUSH {
+                return (x, y);
+            }
+            (0, vy.signum() as isize, vy.abs())
+        };
+        let steps = if mag >= GAS_PUSH * 2 { 2 } else { 1 };
+        let pi = self.idx(x, y);
+        self.pvx[pi] = (dx as i8) * steps as i8;
+        self.pvy[pi] = (dy as i8) * steps as i8;
+        let mut cx = x;
+        let mut cy = y;
+        for _ in 0..steps {
+            let nx = cx as isize + dx;
+            let ny = cy as isize + dy;
+            if nx < 0 || ny < 0 {
+                break;
+            }
+            if !self.try_move(cx, cy, nx as usize, ny as usize) {
+                break;
+            }
+            cx = nx as usize;
+            cy = ny as usize;
+        }
+        (cx, cy)
+    }
+
+    fn rise_gas(&mut self, x: usize, y: usize) {
         if y == 0 {
             return;
         }
@@ -873,7 +1097,13 @@ impl World {
         if nx < 0 || ny < 0 {
             return false;
         }
-        self.try_move(x, y, nx as usize, ny as usize)
+        if !self.try_move(x, y, nx as usize, ny as usize) {
+            return false;
+        }
+        let pi = self.idx(nx as usize, ny as usize);
+        self.pvx[pi] = dx as i8;
+        self.pvy[pi] = dy as i8;
+        true
     }
 
     fn try_move(&mut self, x: usize, y: usize, nx: usize, ny: usize) -> bool {
@@ -889,16 +1119,30 @@ impl World {
         }
     }
 
-    fn step_sand(&mut self, x: usize, y: usize) {
+    fn apply_gravity(&mut self, x: usize, y: usize) -> (usize, usize, bool) {
+        let i = self.idx(x, y);
+        let next = self.pvy[i].saturating_add(1).min(MAX_FALL);
+        self.pvy[i] = next;
+        let steps = 1 + next.unsigned_abs() as usize;
+        let cx = x;
+        let mut cy = y;
+        for _ in 0..steps {
+            let below = cy + 1;
+            if below >= self.height || !self.try_move(cx, cy, cx, below) {
+                let i = self.idx(cx, cy);
+                self.pvy[i] = 0;
+                return (cx, cy, true);
+            }
+            cy += 1;
+        }
+        (cx, cy, false)
+    }
+
+    fn pile_diagonals(&mut self, x: usize, y: usize) {
         let below = y + 1;
         if below >= self.height {
             return;
         }
-        // Straight down first (sand sinks through water via density).
-        if self.try_move(x, y, x, below) {
-            return;
-        }
-        // Then a random diagonal.
         let left_first = self.next_rand() & 1 == 0;
         let diagonals: [(isize, usize); 2] = [(-1, below), (1, below)];
         for k in 0..2 {
@@ -913,6 +1157,13 @@ impl World {
         }
     }
 
+    fn step_sand(&mut self, x: usize, y: usize) {
+        let (x, y, rest) = self.apply_gravity(x, y);
+        if rest {
+            self.pile_diagonals(x, y);
+        }
+    }
+
     fn explode_gunpowder(&mut self, x: usize, y: usize) {
         for dy in -1isize..=1 {
             for dx in -1isize..=1 {
@@ -926,7 +1177,8 @@ impl World {
                     continue;
                 }
                 let cell = self.get(nx, ny);
-                if cell == Cell::Stone || cell.is_fan() {
+                if cell == Cell::Stone || cell == Cell::Ice || cell == Cell::Glass || cell.is_fan()
+                {
                     continue;
                 }
                 self.ignite(nx, ny);
@@ -954,6 +1206,19 @@ impl World {
         self.swap(x1, y1, x2, y2);
     }
 
+    #[cfg(test)]
+    pub(crate) fn set_pixel_vel_for_test(&mut self, x: usize, y: usize, vx: i8, vy: i8) {
+        let i = self.idx(x, y);
+        self.pvx[i] = vx;
+        self.pvy[i] = vy;
+    }
+
+    #[cfg(test)]
+    pub(crate) fn set_pv_for_test(&mut self, x: usize, y: usize, pv: i16) {
+        let i = self.air_idx_of(x, y);
+        self.pv[i] = pv;
+    }
+
     fn step_water(&mut self, x: usize, y: usize) {
         let i = self.idx(x, y);
         if self.heat[i] > 0 {
@@ -962,18 +1227,51 @@ impl World {
                 return;
             }
         }
+        let i = self.idx(x, y);
+        if self.heat[i] < ICE_FREEZE {
+            self.cells[i] = Cell::Ice;
+            self.ttl[i] = 0;
+            self.pvx[i] = 0;
+            self.pvy[i] = 0;
+            self.wake(x, y, true);
+            return;
+        }
         if let Some((fx, fy)) = self.first_cardinal(x, y, Cell::Fire) {
-            let bump = WATER_BOIL.saturating_sub(self.heat[i]);
+            let bump = self.boil_threshold(x, y).saturating_sub(self.heat[i]);
             self.add_heat(x, y, bump);
             self.extinguish(fx, fy);
             return;
         }
-        let below = y + 1;
-        if below < self.height && self.try_move(x, y, x, below) {
+        self.slide_liquid(x, y);
+    }
+
+    fn step_oil(&mut self, x: usize, y: usize) {
+        let i = self.idx(x, y);
+        if self.heat[i] > 0 {
+            self.conduct(x, y);
+            if self.get(x, y) != Cell::Oil {
+                return;
+            }
+        }
+        if self.heat[i] >= OIL_IGNITE || self.first_cardinal(x, y, Cell::Fire).is_some() {
+            self.ignite(x, y);
             return;
         }
-        let left_first = self.next_rand() & 1 == 0;
-        // Diagonals, then horizontal slide (water spreads).
+        self.slide_liquid(x, y);
+    }
+
+    fn slide_liquid(&mut self, x: usize, y: usize) {
+        let is_water = self.get(x, y) == Cell::Water;
+        let (x, y, rest) = self.apply_gravity(x, y);
+        if !rest {
+            return;
+        }
+        let i = self.idx(x, y);
+        let left_first = if is_water && self.pvx[i] != 0 {
+            self.pvx[i] < 0
+        } else {
+            self.next_rand() & 1 == 0
+        };
         let moves: [(isize, isize); 4] = [(-1, 1), (1, 1), (-1, 0), (1, 0)];
         for k in 0..4 {
             let (dx, dy) = moves[if left_first { k } else { 3 - k }];
@@ -983,6 +1281,10 @@ impl World {
                 continue;
             }
             if self.try_move(x, y, nx as usize, ny) {
+                if is_water && dy == 0 {
+                    let pi = self.idx(nx as usize, ny);
+                    self.pvx[pi] = dx as i8;
+                }
                 return;
             }
         }
@@ -1004,6 +1306,33 @@ mod tests {
         assert_eq!(w.get(4, 7), Cell::Sand);
     }
 
+    #[test]
+    fn paint_line_fills_a_diagonal() {
+        let mut w = World::new(8, 8);
+        w.paint_line(0, 0, 7, 7, Cell::Sand, 0);
+        for i in 0..8 {
+            assert_eq!(w.get(i, i), Cell::Sand, "gap at ({i},{i})");
+        }
+        assert_eq!(w.get(1, 0), Cell::Empty);
+    }
+
+    #[test]
+    fn fill_rect_stamps_exact_block() {
+        let mut w = World::new(8, 8);
+        w.fill_rect(1, 1, 3, 2, Cell::Sand);
+        for y in 1..3 {
+            for x in 1..4 {
+                assert_eq!(w.get(x, y), Cell::Sand);
+            }
+        }
+        assert_eq!(w.get(0, 1), Cell::Empty);
+        assert_eq!(w.get(4, 1), Cell::Empty);
+        assert_eq!(w.get(1, 3), Cell::Empty);
+        w.fill_rect(6, 6, 8, 8, Cell::Sand);
+        assert_eq!(w.get(7, 7), Cell::Sand);
+        assert_eq!(w.get(5, 5), Cell::Empty);
+    }
+
     #[test]
     fn stone_never_moves() {
         let mut w = World::new(8, 8);
@@ -1181,6 +1510,58 @@ mod tests {
         assert_eq!(count(&w, Cell::Fire), 0);
     }
 
+    #[test]
+    fn fire_burns_to_smoke_then_empty() {
+        let mut w = World::new(8, 8);
+        w.paint(4, 3, Cell::Fire, 0);
+        let mut saw_smoke = false;
+        for _ in 0..400 {
+            w.step();
+            if count(&w, Cell::Smoke) > 0 {
+                saw_smoke = true;
+            }
+            if saw_smoke && count(&w, Cell::Fire) == 0 && count(&w, Cell::Smoke) == 0 {
+                break;
+            }
+        }
+        assert!(saw_smoke, "isolated fire should leave smoke");
+        assert_eq!(count(&w, Cell::Fire), 0);
+        assert_eq!(count(&w, Cell::Smoke), 0);
+    }
+
+    #[test]
+    fn water_quench_does_not_spawn_smoke() {
+        let mut w = World::new(8, 8);
+        w.paint(3, 4, Cell::Fire, 0);
+        w.paint(4, 4, Cell::Water, 0);
+        for _ in 0..16 {
+            w.step();
+            assert_eq!(count(&w, Cell::Smoke), 0);
+        }
+    }
+
+    #[test]
+    fn smoke_rises_slower_than_steam() {
+        let mut steam = World::new(8, 16);
+        let mut smoke = World::new(8, 16);
+        steam.paint(4, 14, Cell::Steam, 0);
+        smoke.paint(4, 14, Cell::Smoke, 0);
+        for _ in 0..8 {
+            steam.step();
+            smoke.step();
+        }
+        let steam_y = (0..16)
+            .find(|&y| (0..8).any(|x| steam.get(x, y) == Cell::Steam))
+            .expect("steam still present");
+        let smoke_y = (0..16)
+            .find(|&y| (0..8).any(|x| smoke.get(x, y) == Cell::Smoke))
+            .expect("smoke still present");
+        assert!(
+            smoke_y > steam_y,
+            "smoke should lag steam: smoke_y={smoke_y} steam_y={steam_y}"
+        );
+    }
+
     #[test]
     fn fire_rises() {
         let mut w = World::new(8, 8);
@@ -1445,7 +1826,11 @@ mod tests {
         assert_eq!(Cell::from_u8(9), Some(Cell::FanUp));
         assert_eq!(Cell::from_u8(10), Some(Cell::FanDown));
         assert_eq!(Cell::from_u8(11), Some(Cell::Gunpowder));
-        assert_eq!(Cell::from_u8(12), None);
+        assert_eq!(Cell::from_u8(12), Some(Cell::Smoke));
+        assert_eq!(Cell::from_u8(13), Some(Cell::Oil));
+        assert_eq!(Cell::from_u8(14), Some(Cell::Ice));
+        assert_eq!(Cell::from_u8(15), Some(Cell::Glass));
+        assert_eq!(Cell::from_u8(16), None);
     }
 
     #[test]
@@ -1458,6 +1843,196 @@ mod tests {
         assert_eq!(w.get(1, 1), Cell::Empty);
     }
 
+    #[test]
+    fn paint_cannot_overwrite_ice_except_eraser() {
+        let mut w = World::new(4, 4);
+        w.paint(1, 1, Cell::Ice, 0);
+        w.paint(1, 1, Cell::Sand, 0);
+        assert_eq!(w.get(1, 1), Cell::Ice);
+        w.paint(1, 1, Cell::Empty, 0);
+        assert_eq!(w.get(1, 1), Cell::Empty);
+    }
+
+    #[test]
+    fn oil_floats_on_water() {
+        let mut w = World::new(4, 8);
+        for y in 0..8 {
+            w.paint(1, y, Cell::Stone, 0);
+            w.paint(3, y, Cell::Stone, 0);
+        }
+        w.paint(2, 0, Cell::Oil, 0);
+        w.paint(2, 1, Cell::Water, 0);
+        for _ in 0..16 {
+            w.step();
+        }
+        let oil_y = (0..8)
+            .find(|&y| (0..4).any(|x| w.get(x, y) == Cell::Oil))
+            .expect("oil");
+        let water_y = (0..8)
+            .find(|&y| (0..4).any(|x| w.get(x, y) == Cell::Water))
+            .expect("water");
+        assert!(
+            oil_y < water_y,
+            "oil should rest above water: oil_y={oil_y} water_y={water_y}"
+        );
+    }
+
+    #[test]
+    fn oil_ignites_from_fire() {
+        let mut w = World::new(8, 8);
+        w.paint(4, 4, Cell::Fire, 0);
+        w.paint(5, 4, Cell::Oil, 0);
+        w.step();
+        assert_eq!(count(&w, Cell::Oil), 0);
+        assert!(count(&w, Cell::Fire) > 0);
+    }
+
+    #[test]
+    fn painted_water_does_not_freeze() {
+        let mut w = World::new(4, 4);
+        w.paint(1, 1, Cell::Water, 0);
+        for _ in 0..16 {
+            w.step();
+        }
+        assert_eq!(count(&w, Cell::Ice), 0);
+        assert_eq!(count(&w, Cell::Water), 1);
+    }
+
+    #[test]
+    fn ice_melts_from_adjacent_fire() {
+        let mut w = World::new(8, 8);
+        w.paint(4, 3, Cell::Ice, 0);
+        w.paint(4, 4, Cell::Fire, 0);
+        for _ in 0..32 {
+            w.step();
+            if count(&w, Cell::Ice) == 0 {
+                break;
+            }
+        }
+        assert_eq!(count(&w, Cell::Ice), 0);
+        assert!(count(&w, Cell::Water) + count(&w, Cell::Steam) > 0);
+    }
+
+    #[test]
+    fn sand_falls_faster_than_one_cell_per_tick() {
+        let mut w = World::new(4, 16);
+        w.paint(2, 0, Cell::Sand, 0);
+        let mut ticks = 0;
+        while ticks < 20 && w.get(2, 15) != Cell::Sand {
+            w.step();
+            ticks += 1;
+        }
+        assert_eq!(w.get(2, 15), Cell::Sand);
+        assert!(ticks < 15, "inertia should beat 1-cell/tick: ticks={ticks}");
+    }
+
+    #[test]
+    fn water_keeps_slide_direction() {
+        let mut w = World::new(16, 4);
+        for x in 0..16 {
+            w.paint(x, 3, Cell::Stone, 0);
+        }
+        w.paint(1, 2, Cell::Water, 0);
+        w.set_pixel_vel_for_test(1, 2, 1, 0);
+        let mut prev = 1usize;
+        let mut increased = 0;
+        for _ in 0..4 {
+            w.step();
+            let x = (0..16)
+                .find(|&x| w.get(x, 2) == Cell::Water)
+                .expect("water on floor channel");
+            if x > prev {
+                increased += 1;
+            }
+            prev = x;
+        }
+        assert!(
+            increased >= 3,
+            "water should keep sliding right: increased={increased} x={prev}"
+        );
+    }
+
+    #[test]
+    fn empty_has_zero_pvy_after_swap_out() {
+        let mut w = World::new(4, 4);
+        w.paint(0, 0, Cell::Sand, 0);
+        w.set_pixel_vel_for_test(0, 0, 0, 2);
+        w.swap_for_test(0, 0, 1, 0);
+        assert_eq!(w.get(0, 0), Cell::Empty);
+        assert_eq!(w.pvy()[0], 0);
+        assert_eq!(w.get(1, 0), Cell::Sand);
+        assert_eq!(w.pvy()[1], 2);
+        assert_eq!(w.pvx().len(), w.cells().len());
+        assert_eq!(w.pvy().len(), w.cells().len());
+    }
+
+    #[test]
+    fn high_pressure_raises_boil_point() {
+        let mut still = World::new(4, 4);
+        still.paint(1, 1, Cell::Water, 0);
+        still.add_heat_for_test(1, 1, WATER_BOIL - ROOM_HEAT);
+        assert_eq!(still.get(1, 1), Cell::Steam);
+
+        let mut pressurized = World::new(4, 4);
+        pressurized.paint(1, 1, Cell::Water, 0);
+        pressurized.set_pv_for_test(1, 1, 400);
+        pressurized.add_heat_for_test(1, 1, WATER_BOIL - ROOM_HEAT);
+        assert_eq!(pressurized.get(1, 1), Cell::Water);
+        pressurized.add_heat_for_test(1, 1, 10);
+        assert_eq!(pressurized.get(1, 1), Cell::Steam);
+    }
+
+    #[test]
+    fn sand_bakes_into_glass() {
+        let mut w = World::new(8, 8);
+        w.paint(4, 6, Cell::Sand, 0);
+        w.add_heat_for_test(4, 6, GLASS_HEAT);
+        assert_eq!(w.get(4, 6), Cell::Glass);
+
+        let mut fire = World::new(8, 8);
+        for x in 2..=5 {
+            fire.paint(x, 5, Cell::Stone, 0);
+            fire.paint(x, 7, Cell::Stone, 0);
+        }
+        fire.paint(2, 6, Cell::Stone, 0);
+        fire.paint(5, 6, Cell::Stone, 0);
+        fire.paint(3, 6, Cell::Fire, 0);
+        fire.paint(4, 6, Cell::Sand, 0);
+        for _ in 0..64 {
+            fire.step();
+            if count(&fire, Cell::Glass) > 0 {
+                break;
+            }
+        }
+        assert!(count(&fire, Cell::Glass) > 0);
+    }
+
+    #[test]
+    fn empty_heat_stays_zero_next_to_fire() {
+        let mut w = World::new(8, 8);
+        w.paint(4, 4, Cell::Fire, 0);
+        for _ in 0..16 {
+            w.step();
+        }
+        for (i, &cell) in w.cells().iter().enumerate() {
+            if cell == Cell::Empty {
+                assert_eq!(w.heat()[i], 0);
+            }
+        }
+    }
+
+    #[test]
+    fn paint_cannot_overwrite_glass_except_eraser() {
+        let mut w = World::new(4, 4);
+        w.paint(1, 1, Cell::Sand, 0);
+        w.add_heat_for_test(1, 1, GLASS_HEAT);
+        assert_eq!(w.get(1, 1), Cell::Glass);
+        w.paint(1, 1, Cell::Water, 0);
+        assert_eq!(w.get(1, 1), Cell::Glass);
+        w.paint(1, 1, Cell::Empty, 0);
+        assert_eq!(w.get(1, 1), Cell::Empty);
+    }
+
     #[test]
     fn air_buffers_match_grid() {
         let w = World::new(320, 200);
@@ -1466,6 +2041,7 @@ mod tests {
         assert_eq!(w.pv().len(), 80 * 50);
         assert_eq!(w.vx().len(), w.pv().len());
         assert_eq!(w.vy().len(), w.pv().len());
+        assert_eq!(w.pv().len(), w.air_w * w.air_h);
     }
 
     #[test]
@@ -1610,7 +2186,10 @@ mod tests {
         w.step();
         assert_eq!(w.get(4, 4), Cell::Steam);
         assert_eq!(w.get(4, 5), Cell::Empty);
-        assert_eq!(w.heat()[4 * 8 + 4], 119);
+        assert!(
+            w.heat()[4 * 8 + 4] < STEAM_PAINT_HEAT,
+            "steam should cool as it rises"
+        );
         assert_eq!(w.heat()[4 * 8 + 5], 0);
     }
 
@@ -1624,12 +2203,6 @@ mod tests {
         }
         assert_eq!(count(&w, Cell::Steam), 0);
         assert_eq!(count(&w, Cell::Water), 1);
-        let wi = w
-            .cells()
-            .iter()
-            .position(|&c| c == Cell::Water)
-            .expect("water");
-        assert!(w.heat()[wi] < STEAM_CONDENSE);
     }
 
     #[test]