diff --git a/.gitignore b/.gitignore
index 54aa87d..4e2e7b0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,3 +20,6 @@ Thumbs.db
 desktop.ini
 .vscode/
 .idea/
+
+# Last design, restored at start-up
+GenerativeLineArt/session.json
diff --git a/GenerativeLineArt/Cli.pde b/GenerativeLineArt/Cli.pde
index 4783bdd..e53567a 100644
--- a/GenerativeLineArt/Cli.pde
+++ b/GenerativeLineArt/Cli.pde
@@ -24,10 +24,13 @@ final String CLI_HELP = String.join("\n",
   "  --location <place|lat,lon>   for --streets, --terrain and --weather",
   "  --streets [all|major|water|buildings]   --radius <m>   --terrain [zoom]   --weather",
   "  --text <text>            text for the Text pattern ( | = new line)",
+  "  --set \"<name>=<value>\"   any parameter by name: the layer's pattern, layer settings (Pattern, Pen colour,",
+  "                           Pen width, Scale, ...) or page settings (Paper colour, Margin (mm), ...)",
+  "  --list [json]            list every pattern, parameter and setting with its range, then quit",
   "  --seed <n>               seed of the layer;  --seed-text <s>  seed from text;  --design-text <s>  design from text",
   "  --prompt <description>   AI design (needs ANTHROPIC_API_KEY)",
   "  --paper A5|A4|A3|Square  --landscape  --portrait",
-  "  --format svg|gcode|hpgl  --out <file>  (default exports/lineart_<time>.<ext>)",
+  "  --format svg|gcode|hpgl  --out <file>  (default exports/lineart_<time>.<ext>; a .png file is a picture of the design)",
   "  --batch <n>              export n seed variations into exports/batch_<time>/",
   "  --watch <folder>         keep running: load and export every new file dropped into the folder",
   "  --help");
@@ -57,6 +60,7 @@ void cliArgs() {
     String next = i + 1 < args.length && !args[i + 1].startsWith("--") ? args[i + 1] : null;
     // flags take no value; --streets and --terrain take one only when it fits
     boolean flag = a.equals("--landscape") || a.equals("--portrait") || a.equals("--weather") || a.equals("--help") || a.equals("-h");
+    if (a.equals("--list") && next != null && !next.equalsIgnoreCase("json")) next = null;
     if (a.equals("--streets") && next != null && indexOf(STREET_OPTS, next.toLowerCase()) < 0) next = null;
     if (a.equals("--terrain") && next != null && !next.matches("\\d+")) next = null;
     if (flag) next = null;
@@ -79,6 +83,8 @@ void cliArgs() {
       if (L.pMode.i() != 34) { L.pMode.set(34); L.pEnabled.set(1); }
       L.text.set(need(a, next));
     }
+    else if (a.equals("--list")) { cliList(next != null); cliQuit(0); return; }
+    else if (a.equals("--set")) cliSet(need(a, next));
     else if (a.equals("--seed")) layers[curLayer].pSeed.set(needInt(a, next, 0, 9999));
     else if (a.equals("--seed-text")) seedFromText(layers[curLayer], need(a, next));
     else if (a.equals("--design-text")) designFromText(layers[curLayer], need(a, next));
@@ -158,9 +164,115 @@ boolean cliStep() {
   } else {
     File out = cliOut != null ? cliFile(cliOut) : new File(sketchPath("exports"), "lineart_" + timestamp() + "." + ext());
     if (out.getParentFile() != null) out.getParentFile().mkdirs();
+    if (extOf(out.getName()).equals("png")) {                // a picture of the design instead of plot data
+      if (!writeShareImage(out)) { System.err.println("Error: " + status); cliExitCode = 1; }
+      else println("Saved: " + out.getAbsolutePath());
+      exit();
+      return true;
+    }
     if (writeExport(out) == 0) { System.err.println("Error: " + status); cliExitCode = 1; exit(); return true; }
   }
   println(status);
   exit();
   return true;
 }
+
+// --list: every pattern with its parameters, the layer settings and the page
+// settings, as text or (--list json) as JSON for scripts.
+void cliList(boolean json) {
+  if (json) {
+    JSONObject root = new JSONObject();
+    JSONArray pats = new JSONArray();
+    for (int m = 0; m < PATTERN_NAMES.length; m++) {
+      JSONObject o = new JSONObject();
+      o.setString("name", PATTERN_NAMES[m]);
+      o.setJSONArray("params", paramsJSON(makeParams(null, m)));
+      pats.append(o);
+    }
+    root.setJSONArray("patterns", pats);
+    Layer L = layers[0];
+    root.setJSONArray("layer", paramsJSON(layerParams(L)));
+    root.setJSONArray("page", paramsJSON(globals));
+    println(root.format(2));
+    return;
+  }
+  StringBuilder sb = new StringBuilder("Patterns and their parameters (name [range] default):\n");
+  for (int m = 0; m < PATTERN_NAMES.length; m++) sb.append("  ").append(PATTERN_NAMES[m]).append(": ").append(paramsText(makeParams(null, m))).append('\n');
+  sb.append("\nLayer settings: ").append(paramsText(layerParams(layers[0]))).append('\n');
+  sb.append("\nPage settings: ").append(paramsText(globals)).append('\n');
+  sb.append("\nChange any of them with --set \"<name>=<value>\" (choices by name, e.g. --set \"Paper colour=Black\").");
+  println(sb.toString());
+}
+
+ArrayList<Param> layerParams(Layer L) {
+  ArrayList<Param> a = new ArrayList<Param>();
+  Collections.addAll(a, L.pEnabled, L.pMode, L.pColor, L.pPen, L.pSeed, L.pScale, L.pRot, L.pOffX, L.pOffY, L.pMask, L.pField);
+  return a;
+}
+
+String paramsText(ArrayList<Param> ps) {
+  StringBuilder sb = new StringBuilder();
+  for (int k = 0; k < ps.size(); k++) {
+    Param p = ps.get(k);
+    if (k > 0) sb.append("; ");
+    sb.append(p.label);
+    if (p.type == 1) sb.append(" [on/off] ").append(p.on() ? "on" : "off");
+    else if (p.type == 2) sb.append(" [").append(join(p.opts, "|")).append("] ").append(p.opts[p.i()]);
+    else sb.append(" [").append(fmtNum(p.min)).append("..").append(fmtNum(p.max)).append("] ").append(fmtNum(p.def));
+  }
+  return sb.toString();
+}
+
+JSONArray paramsJSON(ArrayList<Param> ps) {
+  JSONArray a = new JSONArray();
+  for (Param p : ps) {
+    JSONObject o = new JSONObject();
+    o.setString("name", p.label);
+    o.setString("type", p.type == 1 ? "toggle" : (p.type == 2 ? "choice" : (p.isInt ? "integer" : "number")));
+    if (p.type == 2) { JSONArray opts = new JSONArray(); for (String s : p.opts) opts.append(s); o.setJSONArray("options", opts); o.setString("default", p.opts[(int) p.def]); }
+    else if (p.type == 1) o.setBoolean("default", p.def > 0.5);
+    else { o.setDouble("min", Double.parseDouble(fmtNum(p.min))); o.setDouble("max", Double.parseDouble(fmtNum(p.max))); o.setDouble("default", Double.parseDouble(fmtNum(p.def))); }
+    a.append(o);
+  }
+  return a;
+}
+
+// --set "<name>=<value>": the current layer's pattern parameters first, then
+// its layer settings, then the page settings. Choices take the option name
+// (or its number), toggles on/off/true/false/1/0.
+void cliSet(String spec) {
+  int eq = spec.indexOf('=');
+  if (eq <= 0) cliError("--set needs <name>=<value>, e.g. --set \"Lines=80\"");
+  String name = spec.substring(0, eq).trim(), v = spec.substring(eq + 1).trim();
+  Layer L = layers[curLayer];
+  Param p = findParam(L.params(), name);
+  if (p == null) p = findParam(layerParams(L), name);
+  if (p == null && paramKey(name, true).equals("pen")) p = L.pColor;
+  if (p == null && paramKey(name, true).equals("pattern")) p = L.pMode;
+  if (p == null) p = findParam(globals, name);
+  if (p == null) {
+    ArrayList<String> near = new ArrayList<String>();
+    for (Param q : L.params()) near.add(q.label);
+    cliError("no parameter \"" + name + "\" (" + PATTERN_NAMES[L.pMode.i()] + " has: " + join(near.toArray(new String[0]), ", ") + "; --list shows all)");
+    return;
+  }
+  float val;
+  if (p.type == 2) {
+    int i = -1;
+    for (int k = 0; k < p.opts.length; k++) if (paramKey(p.opts[k], false).equals(paramKey(v, false))) i = k;
+    if (i < 0 && v.matches("\\d+")) i = Integer.parseInt(v);
+    if (i < 0 || i >= p.opts.length) { cliError(p.label + " is one of: " + join(p.opts, ", ")); return; }
+    val = i;
+  } else if (p.type == 1) {
+    String b = v.toLowerCase();
+    if (b.matches("on|true|yes|1")) val = 1;
+    else if (b.matches("off|false|no|0")) val = 0;
+    else { cliError(p.label + " is on or off, not \"" + v + "\""); return; }
+  } else {
+    try { val = Float.parseFloat(v.replace(',', '.')); }
+    catch (NumberFormatException e) { cliError(p.label + " needs a number, not \"" + v + "\""); return; }
+    if (val < p.min || val > p.max) cliError(p.label + " must be between " + fmtNum(p.min) + " and " + fmtNum(p.max) + " (got " + v + ")");
+  }
+  p.set(val);
+  if (p == L.pMode) L.pEnabled.set(1);
+}
diff --git a/GenerativeLineArt/DragDrop.pde b/GenerativeLineArt/DragDrop.pde
new file mode 100644
index 0000000..fa60fde
--- /dev/null
+++ b/GenerativeLineArt/DragDrop.pde
@@ -0,0 +1,82 @@
+// Drag and drop: drop files, a folder or a web link onto the window.
+// Files load like the Sources tab buttons (by type; presets apply, a layer
+// switches to the matching pattern), a folder becomes the watch folder and a
+// link from a browser is downloaded.
+
+import java.awt.datatransfer.DataFlavor;
+import java.awt.dnd.DnDConstants;
+import java.awt.dnd.DropTarget;
+import java.awt.dnd.DropTargetAdapter;
+import java.awt.dnd.DropTargetDragEvent;
+import java.awt.dnd.DropTargetDropEvent;
+import java.awt.dnd.DropTargetEvent;
+
+volatile boolean dragHover = false;
+
+void setupDragDrop() {
+  Object n = surface.getNative();
+  if (!(n instanceof java.awt.Component)) return;      // other renderers: no drop support
+  new DropTarget((java.awt.Component) n, DnDConstants.ACTION_COPY, new DropTargetAdapter() {
+    public void dragEnter(DropTargetDragEvent e) { dragHover = true; }
+    public void dragExit(DropTargetEvent e) { dragHover = false; }
+    public void drop(DropTargetDropEvent e) {
+      dragHover = false;
+      try {
+        e.acceptDrop(DnDConstants.ACTION_COPY);
+        java.awt.datatransfer.Transferable t = e.getTransferable();
+        if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
+          final List<File> files = new ArrayList<File>();
+          for (Object o : (List<?>) t.getTransferData(DataFlavor.javaFileListFlavor)) files.add((File) o);
+          onMain(new Runnable() { public void run() { dropFiles(files); } });
+        } else if (t.isDataFlavorSupported(DataFlavor.stringFlavor)) {
+          final String s = ((String) t.getTransferData(DataFlavor.stringFlavor)).trim();
+          onMain(new Runnable() { public void run() { dropText(s); } });
+        }
+        e.dropComplete(true);
+      } catch (Exception ex) {
+        e.dropComplete(false);
+        statusAsync("Could not read the dropped item: " + errText(ex));
+      }
+    }
+  });
+}
+
+void dropFiles(List<File> files) {
+  int ok = 0;
+  String last = "";
+  for (File f : files) {
+    if (f.isDirectory()) { startWatching(f); return; }
+    if (loadAny(f, true)) { ok++; last = f.getName(); }
+  }
+  if (files.size() > 1) setStatus("Loaded " + ok + " of " + files.size() + " dropped files");
+  else if (ok == 0 && !files.isEmpty()) setStatus("Could not load " + files.get(0).getName() + (status.isEmpty() ? "" : ": " + status));
+  else if (ok == 1 && !status.contains(last)) setStatus("Loaded " + last);
+}
+
+// A link (or a file:// URI list, as some file managers send it) dropped as text.
+void dropText(String s) {
+  String first = split(s, '\n')[0].trim();
+  if (first.matches("(?i)https?://\\S+")) { tvUrl.set(first); fetchUrl(first); return; }
+  if (first.startsWith("file:")) {
+    List<File> fs = new ArrayList<File>();
+    for (String line : split(s, '\n')) {
+      line = line.trim();
+      if (line.startsWith("file:")) try { fs.add(new File(URI.create(line))); } catch (Exception e) {}
+    }
+    dropFiles(fs);
+    return;
+  }
+  setStatus("Drop a file, a folder or a web link (http/https)");
+}
+
+// Highlight while something is dragged over the window.
+void drawDropOverlay() {
+  if (!dragHover) return;
+  noStroke(); fill(C_PANEL, 210); rect(0, 0, width, height);
+  stroke(C_ACCENT); strokeWeight(3); noFill();
+  rect(24, 24, width - 48, height - 48, 14);
+  noStroke(); fill(C_TEXT); textAlign(CENTER, CENTER);
+  textSize(24); text("Drop to load", width / 2, height / 2 - 18);
+  fill(C_DIM); textSize(13);
+  text("image, CSV / JSON, GPX / GeoJSON, SVG, audio, grid, text or preset\na folder to watch, or a web link", width / 2, height / 2 + 24);
+}
diff --git a/GenerativeLineArt/Explore.pde b/GenerativeLineArt/Explore.pde
new file mode 100644
index 0000000..c154435
--- /dev/null
+++ b/GenerativeLineArt/Explore.pde
@@ -0,0 +1,162 @@
+// Explore: a 3 x 3 grid of variations of the current layer, drawn on the
+// page together with the other layers. Click one to keep it (Undo takes it
+// back). "Seeds" only changes the seed; "Mix" also varies the pattern's
+// parameters, like Randomize (locked values stay). One variation is
+// generated per frame, so the window stays responsive.
+//   E = open / close, Space or R = new batch, Tab = Seeds / Mix, Esc = close
+
+final int EX_N = 9;
+boolean exploreOn = false;
+int exploreMix = 0;                   // 0 = seeds, 1 = mix parameters
+int exploreDone = 0;                  // variations generated so far
+int exploreLayer = 0;
+int exploreBatch = 0;
+float[][] exVals = new float[EX_N][];   // per variation: seed, then the pattern's parameters
+PGraphics[] exThumb = new PGraphics[EX_N];
+int[] exPaths = new int[EX_N];
+float[] exSecs = new float[EX_N];
+
+void toggleExplore() {
+  if (exploreOn) { exploreOn = false; return; }
+  exploreOn = true;
+  newExploreBatch();
+}
+
+void newExploreBatch() {
+  exploreLayer = curLayer;
+  exploreBatch++;
+  Layer L = layers[exploreLayer];
+  Random r = new Random(L.pSeed.i() * 7919L + exploreBatch * 104729L + exploreMix);
+  ArrayList<Param> ps = L.params();
+  for (int v = 0; v < EX_N; v++) {
+    float[] a = new float[ps.size() + 1];
+    a[0] = L.pSeed.locked ? L.pSeed.val : r.nextInt(10000);
+    for (int k = 0; k < ps.size(); k++) {
+      Param p = ps.get(k);
+      a[k + 1] = p.val;
+      if (exploreMix == 1 && p.type != 1 && !p.locked) {
+        float lo = p.min + 0.08 * (p.max - p.min), hi = p.min + 0.75 * (p.max - p.min);
+        a[k + 1] = lo + r.nextFloat() * (hi - lo);
+        if (p.isInt) a[k + 1] = round(a[k + 1]);
+      }
+    }
+    if (v == 0) {                       // the first cell is the current design, for comparison
+      a[0] = L.pSeed.val;
+      for (int k = 0; k < ps.size(); k++) a[k + 1] = ps.get(k).val;
+    }
+    exVals[v] = a;
+    exThumb[v] = null;
+  }
+  exploreDone = 0;
+}
+
+// Generates the next variation (called once per frame while exploring).
+void exploreStep() {
+  if (!exploreOn || exploreDone >= EX_N) return;
+  if (curLayer != exploreLayer || !layers[exploreLayer].pEnabled.on()) { exploreOn = false; return; }
+  Layer L = layers[exploreLayer];
+  ArrayList<Param> ps = L.params();
+  int v = exploreDone;
+  // try the variation's values without touching undo, then put everything back
+  float seed0 = L.pSeed.val;
+  float[] old = new float[ps.size()];
+  for (int k = 0; k < ps.size(); k++) old[k] = ps.get(k).val;
+  ArrayList<ArrayList<PVector>> paths0 = L.paths;
+  int n0 = L.nPaths, p0 = L.nPoints; float len0 = L.length, tr0 = L.travel;
+  L.pSeed.val = exVals[v][0];
+  for (int k = 0; k < ps.size(); k++) ps.get(k).val = exVals[v][k + 1];
+  generateLayer(L);
+  exPaths[v] = L.nPaths;
+  exSecs[v] = L.seconds();
+  exThumb[v] = renderThumb(L, L.paths);
+  L.pSeed.val = seed0;
+  for (int k = 0; k < ps.size(); k++) ps.get(k).val = old[k];
+  L.paths = paths0; L.nPaths = n0; L.nPoints = p0; L.length = len0; L.travel = tr0;
+  exploreDone++;
+}
+
+float[] exCell(int v) {               // x, y, w, h of a cell in the preview area
+  float gx = PANEL_W + 30, gy = 56, gw = areaW() - 60, gh = areaH() - 80;
+  float cw = gw / 3, ch = gh / 3;
+  return new float[] { gx + (v % 3) * cw, gy + (v / 3) * ch, cw, ch };
+}
+
+PGraphics renderThumb(Layer cur, ArrayList<ArrayList<PVector>> paths) {
+  float[] c = exCell(0);
+  float k = min((c[2] - 16) / genW, (c[3] - 30) / genH);
+  int tw = max(1, round(genW * k)), th = max(1, round(genH * k));
+  PGraphics g = createGraphics(tw, th, JAVA2D);
+  g.beginDraw();
+  g.background(paperColor());
+  g.noFill(); g.strokeJoin(ROUND); g.strokeCap(ROUND);
+  for (Layer L : layers) {
+    if (!L.pEnabled.on()) continue;
+    g.stroke(L.penColor(), L == cur ? 255 : 90);
+    g.strokeWeight(max(0.5, L.pPen.val * k));
+    for (ArrayList<PVector> path : (L == cur ? paths : L.paths)) {
+      g.beginShape();
+      for (PVector p : path) g.vertex(p.x * k, p.y * k);
+      g.endShape();
+    }
+  }
+  g.endDraw();
+  return g;
+}
+
+void drawExplore() {
+  noStroke(); fill(C_CANVAS); rect(PANEL_W, 0, areaW(), areaH());
+  fill(C_TEXT); textSize(14); textAlign(LEFT, CENTER);
+  text((exploreMix == 0 ? "Seed variations" : "Mixed variations") + " of layer " + (exploreLayer + 1) + "  ·  " + PATTERN_NAMES[layers[exploreLayer].pMode.i()], PANEL_W + 30, 26);
+  fill(C_DIM); textSize(11); textAlign(RIGHT, CENTER);
+  text("click (or 1-9) to keep  ·  Space = more  ·  Tab = " + (exploreMix == 0 ? "also vary parameters" : "seeds only") + "  ·  Esc = close", width - 30, 26);
+  for (int v = 0; v < EX_N; v++) {
+    float[] c = exCell(v);
+    boolean over = mouseX >= c[0] && mouseX < c[0] + c[2] && mouseY >= c[1] && mouseY < c[1] + c[3];
+    if (exThumb[v] == null) {
+      fill(C_DIM); textAlign(CENTER, CENTER); textSize(12);
+      text(v == exploreDone ? "drawing..." : "", c[0] + c[2] / 2, c[1] + c[3] / 2);
+      continue;
+    }
+    PGraphics t = exThumb[v];
+    float tx = c[0] + (c[2] - t.width) / 2, ty = c[1] + 4;
+    noStroke(); fill(0, 90); rect(tx + 3, ty + 4, t.width, t.height);
+    image(t, tx, ty);
+    if (over && exploreDone >= EX_N) { noFill(); stroke(C_ACCENT); strokeWeight(3); rect(tx - 2, ty - 2, t.width + 4, t.height + 4, 3); }
+    fill(v == 0 ? C_ACCENT : C_DIM); textSize(11); textAlign(CENTER, TOP);
+    String label = (v == 0 ? "current  ·  " : "seed " + (int) exVals[v][0] + "  ·  ") + exPaths[v] + " paths  ·  " + fmtTime(exSecs[v]);
+    text(label, c[0] + c[2] / 2, ty + t.height + 5);
+  }
+}
+
+// Mouse press while exploring: true when it was handled.
+boolean explorePress() {
+  if (!exploreOn || mouseX < PANEL_W) return false;
+  for (int v = 0; v < EX_N; v++) {
+    float[] c = exCell(v);
+    if (mouseX >= c[0] && mouseX < c[0] + c[2] && mouseY >= c[1] && mouseY < c[1] + c[3] && exThumb[v] != null) {
+      pickVariation(v);
+      return true;
+    }
+  }
+  return true;                          // clicks between the cells do nothing
+}
+
+void pickVariation(int v) {
+  Layer L = layers[exploreLayer];
+  commitPending();
+  L.pSeed.set(exVals[v][0]);
+  ArrayList<Param> ps = L.params();
+  for (int k = 0; k < ps.size(); k++) ps.get(k).set(exVals[v][k + 1]);
+  exploreOn = false;
+  setStatus(v == 0 ? "Kept the current design" : "Variation applied (Ctrl+Z = back)");
+}
+
+// Keys while exploring: true when handled.
+boolean exploreKey() {
+  if (!exploreOn) return false;
+  if (key == ESC || key == 'e' || key == 'E') { key = 0; exploreOn = false; return true; }
+  if (key == ' ' || key == 'r' || key == 'R' || key == 'n' || key == 'N') { newExploreBatch(); return true; }
+  if (key == TAB) { exploreMix = 1 - exploreMix; newExploreBatch(); return true; }
+  if (key >= '1' && key <= '9' && exploreDone > key - '1') { pickVariation(key - '1'); return true; }
+  return true;
+}
diff --git a/GenerativeLineArt/GenerativeLineArt.pde b/GenerativeLineArt/GenerativeLineArt.pde
index 8c0fd88..6f6d5c3 100644
--- a/GenerativeLineArt/GenerativeLineArt.pde
+++ b/GenerativeLineArt/GenerativeLineArt.pde
@@ -47,8 +47,11 @@ final String[] FORMAT_EXT   = { "svg", "gcode", "hpgl" };
 final String[] IMAGE_STYLES = { "TSP line", "Stipple", "Hatch", "Spiral", "Squiggle" };
 final String[] PAPER_NAMES = { "A5", "A4", "A3", "Square" };
 final float[][] PAPER_MM   = { {148, 210}, {210, 297}, {297, 420}, {250, 250} };
-final String[] PEN_NAMES   = { "Black", "Red", "Blue", "Green", "Orange", "Purple", "Teal", "Brown" };
-final int[] PEN_COLORS     = { 0xFF111111, 0xFFD62828, 0xFF1D4ED8, 0xFF15803D, 0xFFEA7A00, 0xFF7E22CE, 0xFF0E9AA7, 0xFF7C4A21 };
+final String[] PEN_NAMES   = { "Black", "Red", "Blue", "Green", "Orange", "Purple", "Teal", "Brown", "White", "Gold", "Silver" };
+final int[] PEN_COLORS     = { 0xFF111111, 0xFFD62828, 0xFF1D4ED8, 0xFF15803D, 0xFFEA7A00, 0xFF7E22CE, 0xFF0E9AA7, 0xFF7C4A21, 0xFFFAFAFA, 0xFFD4A537, 0xFFB4B8BF };
+// paper colours for the preview, image and simulation (plot files stay transparent)
+final String[] PAPER_COLOUR_NAMES = { "White", "Cream", "Kraft", "Grey", "Black", "Navy" };
+final int[] PAPER_COLOURS = { 0xFFFFFFFF, 0xFFF5EEDC, 0xFFC9A57B, 0xFF8E9196, 0xFF1B1B1D, 0xFF1E2A47 };
 final int NUM_LAYERS = 4;
 final String[] LSYS_NAMES  = { "Snowflake", "Dragon", "Gosper", "Sierpinski", "Plant" };
 final String[] FIELD_NAMES = { "Noise", "Photo", "Grid" };       // what drives the field-based patterns
@@ -65,7 +68,7 @@ final int C_HI     = 0xFFA5F3E4;
 // ---------- state ---------------------------------------------------------
 Random ui = new Random();          // UI randomness (pattern generation uses randomSeed)
 
-Param pPaper, pLandscape, pMargin, pOptimize, pSeparate;
+Param pPaper, pPaperCol, pLandscape, pMargin, pOptimize, pSeparate;
 Param pSpeedDown, pSpeedUp, pLiftTime;                 // plotter (time estimate, G-code, HPGL)
 Param pSimplify, pMerge, pMinLen, pDedupe;             // path clean-up
 Param pMarks, pPenTest;                                // extras
@@ -129,6 +132,8 @@ void setup() {
   uiFont = createFont("SansSerif", 13);
   textFont(uiFont);
   pPaper     = new Param(null, "Paper", PAPER_NAMES, 1);
+  pPaperCol  = new Param(null, "Paper colour", PAPER_COLOUR_NAMES, 0);
+  pPaperCol.geometry = false;
   pLandscape = new Param(null, "Landscape", false);
   pMargin    = new Param(null, "Margin (mm)", 0, 60, 15, false);
   pOptimize  = new Param(null, "Optimize travel", true);
@@ -172,7 +177,7 @@ void setup() {
   pAutoExport = new Param(null, "Auto-export", true);
   for (Param p : new Param[] { pRadius, pStreets, pZoom, pWatch, pAutoExport }) p.geometry = false;
 
-  Collections.addAll(globals, pPaper, pLandscape, pMargin, pOptimize, pSeparate, pSpeedDown, pSpeedUp, pLiftTime,
+  Collections.addAll(globals, pPaper, pPaperCol, pLandscape, pMargin, pOptimize, pSeparate, pSpeedDown, pSpeedUp, pLiftTime,
     pSimplify, pMerge, pMinLen, pDedupe, pMarks, pPenTest, pMaskSrc, pMaskSize, pMaskThr, pMaskInv,
     pFormat, pLift, pFlipY, pZUp, pZDown, pServoUp, pServoDown, pBatch,
     pRadius, pStreets, pZoom, pWatch, pAutoExport);
@@ -192,6 +197,8 @@ void setup() {
   setMaskFont(DEFAULT_MASK_FONT);
   loadHersheyFonts();
   cliSetup();
+  if (!cliOneShot) setupDragDrop();
+  if (!cliMode) restoreSession();
 }
 
 void draw() {
@@ -201,19 +208,26 @@ void draw() {
   if (pendingPresetLoad != null) { File f = pendingPresetLoad; pendingPresetLoad = null; loadPreset(f); }
   if (pendingPhoto != null)      { File f = pendingPhoto;      pendingPhoto = null;      loadPhoto(f); }
   if (pendingMask != null)       { File f = pendingMask;       pendingMask = null;       loadMaskImage(f); }
+  if (pendingShare != null)      { File f = pendingShare;      pendingShare = null;      writeShareImage(f); }
   runMainQueue();
   pollWatchFolder();
 
   updatePage();
   if (pendingBatch) { pendingBatch = false; batchExport(); }
+  if (exploreOn && layers[exploreLayer].dirty) newExploreBatch();   // the layer changed: start over
   regenerate();
   if (pendingAutoExport != null) { File f = pendingAutoExport; pendingAutoExport = null; writeExport(f); }
   if (cliStep()) return;
   buildPanel();
-  drawPaper();
+  if (simOn) drawSimulation();
+  else if (exploreOn) { exploreStep(); drawExplore(); }
+  else drawPaper();
   drawPanel();
   drawStatusBar();
+  drawPalette();
+  drawDropOverlay();
   trackUndo();
+  autosaveSession();
 }
 
 void regenerate() {
@@ -722,18 +736,26 @@ void action(int id) {
     case 25: designFromText(L, tvSeedText.s); break;
     case 26: aiGenerate(tvPrompt.s); break;
     case 27: clearSources(); break;
+    case 28: toggleExplore(); break;
+    case 29: toggleSimulation(); break;
+    case 30: requestShareImage(); break;
   }
 }
 
 void keyPressed() {
+  if (paletteOn) { paletteKey(); return; }
   if (fontOpen) { typeFontFilter(); return; }
   if (focusText != null) { typeText(focusText); return; }
+  if (exploreKey()) return;
+  if (simKey()) return;
   Layer L = layers[curLayer];
   boolean ctrl = keyEvent != null && (keyEvent.isControlDown() || keyEvent.isMetaDown());
   if (ctrl) {
     boolean shift = keyEvent.isShiftDown();
     if (keyCode == 'Z') { if (shift) redo(); else undo(); }
     else if (keyCode == 'Y') redo();
+    else if (keyCode == 'N') startFresh();
+    else if (keyCode == 'K') openPalette();
     return;
   }
   if (key == CODED) {
@@ -747,6 +769,13 @@ void keyPressed() {
   else if (key == 'n' || key == 'N' || key == ' ') newSeed(L);
   else if (key == 'r' || key == 'R') randomizeLayer(L);
   else if (key >= '1' && key <= '0' + NUM_LAYERS) curLayer = key - '1';
+  else if (key == '/' || key == '?') openPalette();
+  else if (key == 'e' || key == 'E') toggleExplore();
+  else if (key == 'g' || key == 'G') toggleSimulation();
+  else if (key == 'i' || key == 'I') requestShareImage();
+  else if (key == '0') resetView();
+  else if (key == '+' || key == '=') zoomAt(PANEL_W + areaW() / 2, areaH() / 2, 1.5);
+  else if (key == '-') zoomAt(PANEL_W + areaW() / 2, areaH() / 2, 1 / 1.5);
 }
 
 // A piece of text edited in a TextFieldW (mask text, URL, prompt, ...).
@@ -776,6 +805,7 @@ void textSubmitted(TextVal t) {
 // Keyboard input while a text field has focus. Ctrl+V (Cmd+V) pastes.
 void typeText(TextVal t) {
   if (key == ESC) { key = 0; focusText = null; return; }    // don't let Esc quit the sketch
+  if (t == tvNum && numKey()) return;
   boolean ctrl = keyEvent != null && (keyEvent.isControlDown() || keyEvent.isMetaDown());
   if (ctrl) {
     if (keyCode == 'V') { String c = clipboardText(); if (c != null) t.set(t.s + c.replaceAll("[\\r\\n\\t]+", " ")); }
@@ -901,7 +931,8 @@ class SliderW extends Widget {
     textSize(12);
     fill(C_TEXT); textAlign(LEFT, TOP); text(p.label, x, y);
     if (p.locked) drawLock(x + textWidth(p.label) + 6, y + 1);
-    fill(C_ACCENT); textAlign(RIGHT, TOP); text(fmtParam(p), x + w, y);
+    if (focusText == tvNum && numParam == p) drawNumField(this);
+    else { fill(C_ACCENT); textAlign(RIGHT, TOP); text(fmtParam(p), x + w, y); }
     float ty = y + 25, x0 = x + 6, x1 = x + w - 6;
     strokeCap(ROUND); stroke(C_TRACK); strokeWeight(3); line(x0, ty, x1, ty);
     float k = map(p.val, p.min, p.max, x0, x1);
@@ -909,8 +940,9 @@ class SliderW extends Widget {
     noStroke(); fill((activeParam == p || (activeParam == null && hit())) ? C_HI : C_ACCENT);
     ellipse(k, ty, 13, 13);
   }
-  void press() { drag(); }
+  void press() { if (sliderPress(this)) { activeW = null; activeParam = null; return; } drag(); }
   void drag() {
+    if (activeW != this) return;
     float x0 = x + 6, x1 = x + w - 6;
     p.set(map(constrain(mouseX, x0, x1), x0, x1, p.min, p.max));
   }
@@ -970,13 +1002,14 @@ class ChoiceW extends Widget {
 
 class SwatchW extends Widget {
   SwatchW(Param p) { this.p = p; h = 22; }
-  float sz() { return min(20, (w - 7 * 4) / 8.0); }
+  float sz() { return min(20, (w - (PEN_COLORS.length - 1) * 4) / (float) PEN_COLORS.length); }
   void display() {
     float sz = sz();
     for (int i = 0; i < PEN_COLORS.length; i++) {
       float bx = x + i * (sz + 4);
       noStroke(); fill(PEN_COLORS[i]); rect(bx, y + 1, sz, sz, 4);
       if (i == p.i()) { noFill(); stroke(C_HI); strokeWeight(2); rect(bx - 2, y - 1, sz + 4, sz + 4, 5); }
+      else if (lowContrast(PEN_COLORS[i], paperColor())) { stroke(C_DIM); strokeWeight(1); line(bx + 3, y + sz - 2, bx + sz - 3, y + 4); }
     }
   }
   void press() {
@@ -1197,6 +1230,7 @@ void addParamWidgets(ArrayList<Widget> top, ArrayList<Param> ps) {
 void buildDesignTab(ArrayList<Widget> top) {
   Layer L = layers[curLayer];
   top.add(new ChoiceW(pPaper, 4, pLandscape));
+  top.add(new ChoiceW(pPaperCol, 6, null));
   top.add(new SliderW(pMargin));
   top.add(new Header("PEN LAYERS  (each layer = one pen)"));
   top.add(new LayerTabsW());
@@ -1204,7 +1238,8 @@ void buildDesignTab(ArrayList<Widget> top) {
   top.add(new DropdownW(L.pMode));
   top.add(row(new SliderW(L.pPen), new SliderW(L.pSeed)));
   top.add(new ButtonRow(new String[] { "New seed", "Randomize", "Reset", "Undo", "Redo" }, new int[] { 0, 1, 2, 6, 7 }));
-  top.add(new Header("PATTERN PARAMETERS  (right-click = lock)"));
+  top.add(new ButtonRow(new String[] { exploreOn ? "Close variations (E)" : "Explore variations (E)" }, new int[] { 28 }));
+  top.add(new Header("PATTERN PARAMETERS  (double-click = type, right-click = lock)"));
   int mode = L.pMode.i();
   if (mode == 26) {
     top.add(new ButtonRow(new String[] { "Load image...", "Use demo" }, new int[] { 9, 12 }));
@@ -1247,6 +1282,7 @@ void buildOutputTab(ArrayList<Widget> top) {
       .append(String.format(Locale.US, "%.1f m down, %.1f m travel, %d lifts", L.length / 1000, L.travel / 1000, L.nPaths));
   }
   top.add(new InfoW(est.length() == 0 ? "No layers enabled" : est.toString()));
+  top.add(new ButtonRow(new String[] { simOn ? "Stop simulation (G)" : "Simulate plot (G)" }, new int[] { 29 }));
 
   top.add(new Header("PATH CLEAN-UP"));
   top.add(row(new SliderW(pSimplify), new SliderW(pMerge)));
@@ -1274,6 +1310,7 @@ void buildOutputTab(ArrayList<Widget> top) {
     else top.add(row(new SliderW(pServoUp), new SliderW(pServoDown)));
   }
   top.add(row(new SliderW(pBatch), new ButtonRow(new String[] { "Batch export" }, new int[] { 8 })));
+  top.add(new ButtonRow(new String[] { "Save PNG image (proof card)... (I)" }, new int[] { 30 }));
 }
 
 void buildPanel() {
@@ -1320,7 +1357,7 @@ void drawPanel() {
   for (Widget w : panelFlat) if (!w.scrolls) w.display();
 
   fill(C_DIM); textSize(11); textAlign(LEFT, BOTTOM); textLeading(14);
-  text("S export | P save preset | L load | N seed | R randomize\nCtrl+Z undo | Ctrl+Y redo | 1-4 layer | arrows = pattern", PAD, clipBottom + 36);
+  text("Ctrl+K or /  =  search every command and shortcut\nS export | N seed | R randomize | E variations | G simulate", PAD, clipBottom + 36);
 
   for (Widget w : panelFlat) if (w instanceof DropdownW) ((DropdownW) w).overlay();
   for (Widget w : panelFlat) if (w instanceof FontW) ((FontW) w).overlay();
@@ -1333,6 +1370,8 @@ String fmtParam(Param p) {
 }
 
 void mousePressed() {
+  if (paletteOn) { palettePress(); return; }
+  if (focusText == tvNum) applyNum();       // clicking elsewhere keeps the typed value
   focusText = null;
   if (fontOpen) {
     boolean inList = false;
@@ -1345,7 +1384,13 @@ void mousePressed() {
     ddOpen = false;
     return;
   }
-  if (mouseX > PANEL_W) return;
+  if (explorePress()) return;
+  if (simPress()) return;
+  if (mouseX > PANEL_W) {
+    if (inPreview() && mouseEvent != null && mouseEvent.getCount() == 2) resetView();
+    else if (inPreview()) { panning = true; panLastX = mouseX; panLastY = mouseY; }
+    return;
+  }
   if (mouseButton == RIGHT) {                       // toggle a parameter lock
     for (Widget w : panelFlat) {
       if (w.hit() && lockable(w.p)) {
@@ -1360,10 +1405,14 @@ void mousePressed() {
     if (w.hit()) { activeW = w; activeParam = (w instanceof SliderW) ? w.p : null; w.press(); break; }
   }
 }
-void mouseDragged() { if (activeW != null) activeW.drag(); }
-void mouseReleased() { activeW = null; activeParam = null; }
+void mouseDragged() {
+  if (panning) { panBy(mouseX - panLastX, mouseY - panLastY); panLastX = mouseX; panLastY = mouseY; return; }
+  if (activeW != null) activeW.drag();
+}
+void mouseReleased() { activeW = null; activeParam = null; panning = false; }
 
 void mouseWheel(MouseEvent event) {
+  if (paletteOn) { paletteWheel(event.getCount()); return; }
   if (fontOpen) { fontScroll += event.getCount() * 3; return; }
   if (ddOpen) return;
   for (Widget w : panelFlat) {
@@ -1374,32 +1423,35 @@ void mouseWheel(MouseEvent event) {
       return;
     }
   }
+  if ((exploreOn || simOn) && inPreview()) return;
+  if (inPreview()) { zoomAt(mouseX, mouseY, pow(1.25, -event.getCount())); return; }
   if (mouseX < PANEL_W) panelScroll = constrain(panelScroll + event.getCount() * 40, 0, maxScroll);
 }
 
 // ---------- preview -------------------------------------------------------
 void drawPaper() {
-  float availW = width - PANEL_W - 80;
-  float availH = height - 80 - 24;
-  float sc = max(0.1, min(availW / genW, availH / genH));
-  int pw = max(1, round(genW * sc)), ph = max(1, round(genH * sc));
-  float ox = PANEL_W + (width - PANEL_W - pw) / 2.0;
-  float oy = (height - 24 - ph) / 2.0;
-
-  noStroke(); fill(0, 90); rect(ox + 5, oy + 6, pw, ph);
-  if (pg == null || pg.width != pw || pg.height != ph || previewStale) renderPreview(pw, ph);
-  image(pg, ox, oy);
-
-  float k = pw / genW;
+  float k = viewK(), ox = viewOx(), oy = viewOy();
+  if (viewZoom > 1) drawZoomed(ox, oy, k);
+  else {
+    int pw = max(1, round(genW * k)), ph = max(1, round(genH * k));
+    ox = PANEL_W + (areaW() - pw) / 2.0;
+    oy = (areaH() - ph) / 2.0;
+    k = pw / genW;
+    noStroke(); fill(0, 90); rect(ox + 5, oy + 6, pw, ph);
+    if (pg == null || pg.width != pw || pg.height != ph || previewStale) renderPreview(pw, ph);
+    image(pg, ox, oy);
+  }
   noFill(); stroke(80, 160, 255, 110); strokeWeight(1);
   rect(ox + xmin * k, oy + ymin * k, (xmax - xmin) * k, (ymax - ymin) * k);
+  drawZoomInfo(k);
+  drawContrastWarning();
 }
 
 void renderPreview(int pw, int ph) {
   if (pg == null || pg.width != pw || pg.height != ph) pg = createGraphics(pw, ph, JAVA2D);
   float k = pw / genW;
   pg.beginDraw();
-  pg.background(255);
+  pg.background(paperColor());
   pg.noFill();
   pg.strokeJoin(ROUND);
   pg.strokeCap(ROUND);
@@ -1432,8 +1484,11 @@ void drawStatusBar() {
     fill(C_HI); textAlign(RIGHT, CENTER);
     text(busyWhat + " " + "|/-\\".charAt((millis() / 150) % 4), width - 14, height - 12);
   } else if (millis() - statusMs < 6000) {
+    String t = status;                                // never wider than half the bar
+    while (t.length() > 4 && textWidth(t) > (width - PANEL_W) * 0.55) t = t.substring(0, t.length() - 4) + "...";
+    noStroke(); fill(C_PANEL); rect(width - 30 - textWidth(t), height - 24, textWidth(t) + 30, 24);
     fill(C_ACCENT); textAlign(RIGHT, CENTER);
-    text(status, width - 14, height - 12);
+    text(t, width - 14, height - 12);
   }
 }
 
@@ -3712,6 +3767,12 @@ void presetLoadSelected(File f) {
 }
 
 void savePreset(File f) {
+  if (presetJSON().save(f, "indent=2")) setStatus("Preset saved: " + f.getName());
+  else setStatus("Could not save preset");
+}
+
+// The whole design as a preset (version 2).
+JSONObject presetJSON() {
   JSONObject root = new JSONObject();
   root.setString("app", "GenerativeLineArt");
   root.setInt("version", 2);
@@ -3760,8 +3821,7 @@ void savePreset(File f) {
     arr.append(o);
   }
   root.setJSONArray("layers", arr);
-  if (root.save(f, "indent=2")) setStatus("Preset saved: " + f.getName());
-  else setStatus("Could not save preset");
+  return root;
 }
 
 int indexOf(String[] arr, String s) {
@@ -3792,6 +3852,7 @@ boolean applyPreset(JSONObject root) {
       JSONObject st = root.getJSONObject("settings");
       for (Param p : globals) if (st.hasKey(p.label)) p.set(st.getFloat(p.label));
     }
+    if (!root.hasKey("settings") || !root.getJSONObject("settings").hasKey(pPaperCol.label)) pPaperCol.set(0);   // older presets: white paper
     tvMask.set(root.getString("maskText", tvMask.s));
     String mf = root.getString("maskFont", DEFAULT_MASK_FONT);
     if (!mf.equals(maskFontName)) {
diff --git a/GenerativeLineArt/NumberEntry.pde b/GenerativeLineArt/NumberEntry.pde
new file mode 100644
index 0000000..09e9d5c
--- /dev/null
+++ b/GenerativeLineArt/NumberEntry.pde
@@ -0,0 +1,84 @@
+// Type an exact slider value: double-click a slider or click its value.
+// Enter applies, Esc cancels, Tab applies and moves on to the next slider.
+// Accepts a decimal comma, and "*2", "/2", "+10" or "-10" to change the
+// current value; out-of-range values are clamped (the status bar says so).
+
+Param numParam = null;
+TextVal tvNum = new TextVal("", 24);
+float sliderPressVal = 0;                // value before the press (a double-click restores it)
+
+void startNumEdit(Param p) {
+  numParam = p;
+  tvNum.s = fmtParam(p);
+  focusText = tvNum;
+}
+
+void applyNum() {
+  Param p = numParam;
+  if (p == null) return;
+  String s = tvNum.s.trim().replace(',', '.').replace(" ", "");
+  if (s.isEmpty()) return;
+  try {
+    float v;
+    char op = s.charAt(0);
+    if ((op == '*' || op == 'x' || op == '/') && s.length() > 1) {
+      float k = Float.parseFloat(s.substring(1));
+      v = op == '/' ? p.val / k : p.val * k;
+    } else if ((op == '+' || (op == '-' && s.startsWith("--"))) && s.length() > 1) {
+      v = p.val + Float.parseFloat(s.substring(op == '+' ? 1 : 2)) * (op == '+' ? 1 : -1);
+    } else v = Float.parseFloat(s);
+    if (Float.isNaN(v) || Float.isInfinite(v)) throw new NumberFormatException();
+    p.set(v);
+    if (v < p.min || v > p.max) setStatus(p.label + ": " + fmtNum(v) + " is outside " + fmtNum(p.min) + " .. " + fmtNum(p.max) + ", set to " + fmtParam(p));
+  } catch (NumberFormatException e) {
+    setStatus("\"" + tvNum.s + "\" is not a number (also: *2, /2, +10, --10)");
+  }
+}
+
+// Called by typeText for the number field; returns true when it handled the key.
+boolean numKey() {
+  if (key == ENTER || key == RETURN) { applyNum(); focusText = null; return true; }
+  if (key == TAB) {
+    applyNum();
+    focusText = null;
+    boolean back = keyEvent != null && keyEvent.isShiftDown();
+    ArrayList<Param> sl = new ArrayList<Param>();
+    for (Widget w : panelFlat) if (w instanceof SliderW) sl.add(w.p);
+    int i = sl.indexOf(numParam);
+    if (i >= 0 && sl.size() > 1) startNumEdit(sl.get((i + (back ? sl.size() - 1 : 1)) % sl.size()));
+    return true;
+  }
+  if (key == CODED && (keyCode == UP || keyCode == DOWN)) {        // nudge while typing
+    applyNum();
+    Param p = numParam;
+    float step = p.isInt ? 1 : (p.max - p.min) / 100.0;
+    if (keyEvent != null && keyEvent.isShiftDown()) step *= 10;
+    p.set(p.val + (keyCode == UP ? step : -step));
+    tvNum.s = fmtParam(p);
+    return true;
+  }
+  if (key >= 32 && key != DELETE && "0123456789.,-+*/x eE".indexOf(key) < 0) return true;   // ignore letters
+  return false;
+}
+
+// Mouse press on a slider: true when it opened the number field.
+boolean sliderPress(SliderW w) {
+  boolean onValue = mouseY < w.y + 17 && mouseX > w.x + w.w - 60;
+  boolean dbl = mouseEvent != null && mouseEvent.getCount() == 2;
+  if (!onValue && !dbl) { sliderPressVal = w.p.val; return false; }
+  if (dbl) w.p.set(sliderPressVal);         // the first click of the double-click moved the knob
+  startNumEdit(w.p);
+  return true;
+}
+
+// The value spot of a slider while it is being typed in.
+void drawNumField(SliderW w) {
+  textSize(12);
+  String t = tvNum.s;
+  float fw = max(56, textWidth(t) + 16);
+  stroke(C_ACCENT); strokeWeight(1); fill(C_FIELD);
+  rect(w.x + w.w - fw, w.y - 3, fw, 19, 3);
+  noStroke(); fill(C_TEXT); textAlign(RIGHT, TOP);
+  text(t, w.x + w.w - 7, w.y);
+  if ((millis() / 500) % 2 == 0) { stroke(C_ACCENT); line(w.x + w.w - 5, w.y - 1, w.x + w.w - 5, w.y + 14); }
+}
diff --git a/GenerativeLineArt/Palette.pde b/GenerativeLineArt/Palette.pde
new file mode 100644
index 0000000..6f11076
--- /dev/null
+++ b/GenerativeLineArt/Palette.pde
@@ -0,0 +1,189 @@
+// Command palette: Ctrl+K (Cmd+K) or / opens a search box over everything
+// the app can do: patterns, actions, paper, pens, layers, tabs, sources and
+// the presets in presets/. Type a few letters, Up/Down to choose, Enter to
+// run, Esc to close. The keyboard shortcut of each command is shown, so the
+// palette doubles as the shortcut reference.
+
+class Cmd {
+  String label, hint;
+  Runnable run;
+  Cmd(String label, String hint, Runnable run) { this.label = label; this.hint = hint; this.run = run; }
+}
+
+boolean paletteOn = false;
+String paletteQuery = "";
+int paletteSel = 0, paletteTop = 0;
+ArrayList<Cmd> paletteAll = new ArrayList<Cmd>();
+final int PALETTE_ROWS = 12;
+
+void openPalette() {
+  paletteAll = buildCommands();
+  paletteQuery = ""; paletteSel = 0; paletteTop = 0;
+  paletteOn = true;
+  focusText = null; ddOpen = false; fontOpen = false;
+}
+
+Cmd cmd(String label, String hint, Runnable r) { return new Cmd(label, hint, r); }
+Runnable act(final int id) { return new Runnable() { public void run() { action(id); } }; }
+
+ArrayList<Cmd> buildCommands() {
+  ArrayList<Cmd> c = new ArrayList<Cmd>();
+  final Layer L = layers[curLayer];
+  c.add(cmd("Export " + FORMAT_NAMES[pFormat.i()] + "...", "S", act(3)));
+  c.add(cmd("Save PNG image (proof card)...", "I", act(30)));
+  c.add(cmd("Simulate plot", "G", new Runnable() { public void run() { toggleSimulation(); } }));
+  c.add(cmd("Explore variations", "E", new Runnable() { public void run() { toggleExplore(); } }));
+  c.add(cmd("New seed", "N / Space", act(0)));
+  c.add(cmd("Randomize layer", "R", act(1)));
+  c.add(cmd("Reset layer", "", act(2)));
+  c.add(cmd("Undo", "Ctrl+Z", act(6)));
+  c.add(cmd("Redo", "Ctrl+Y", act(7)));
+  c.add(cmd("Save preset...", "P", act(4)));
+  c.add(cmd("Load preset...", "L", act(5)));
+  c.add(cmd("Start fresh (new design)", "Ctrl+N", new Runnable() { public void run() { startFresh(); } }));
+  c.add(cmd("Batch export seed variations", "", act(8)));
+  c.add(cmd("Fit preview to window", "0 / double-click", new Runnable() { public void run() { resetView(); } }));
+  c.add(cmd("Zoom in", "+ / wheel", new Runnable() { public void run() { zoomAt(PANEL_W + areaW() / 2, areaH() / 2, 1.5); } }));
+  c.add(cmd("Zoom out", "- / wheel", new Runnable() { public void run() { zoomAt(PANEL_W + areaW() / 2, areaH() / 2, 1 / 1.5); } }));
+  c.add(cmd("Toggle landscape", "", new Runnable() { public void run() { pLandscape.set(pLandscape.on() ? 0 : 1); } }));
+  for (int i = 0; i < PAPER_NAMES.length; i++) {
+    final int p = i;
+    c.add(cmd("Paper: " + PAPER_NAMES[i], "", new Runnable() { public void run() { pPaper.set(p); } }));
+  }
+  for (int i = 0; i < PATTERN_NAMES.length; i++) {
+    final int m = i;
+    c.add(cmd("Pattern: " + PATTERN_NAMES[i], "arrows", new Runnable() { public void run() { L.pMode.set(m); L.pEnabled.set(1); panelTab = 0; } }));
+  }
+  for (int i = 0; i < PAPER_COLOUR_NAMES.length; i++) {
+    final int p = i;
+    c.add(cmd("Paper colour: " + PAPER_COLOUR_NAMES[i], "", new Runnable() { public void run() { pPaperCol.set(p); } }));
+  }
+  for (int i = 0; i < NUM_LAYERS; i++) {
+    final int n = i;
+    c.add(cmd("Layer " + (i + 1) + (layers[i].pEnabled.on() ? "" : " (off)") + ": " + PATTERN_NAMES[layers[i].pMode.i()], str(i + 1),
+      new Runnable() { public void run() { curLayer = n; panelTab = 0; } }));
+  }
+  c.add(cmd((L.pEnabled.on() ? "Disable" : "Enable") + " layer " + (curLayer + 1), "", new Runnable() { public void run() { L.pEnabled.set(L.pEnabled.on() ? 0 : 1); } }));
+  for (int i = 0; i < PEN_NAMES.length; i++) {
+    final int p = i;
+    c.add(cmd("Pen colour: " + PEN_NAMES[i] + " (layer " + (curLayer + 1) + ")", "", new Runnable() { public void run() { L.pColor.set(p); } }));
+  }
+  for (int i = 0; i < FORMAT_NAMES.length; i++) {
+    final int f = i;
+    c.add(cmd("Export format: " + FORMAT_NAMES[i], "", new Runnable() { public void run() { pFormat.set(f); } }));
+  }
+  String[] tabs = { "Design", "Sources", "Output" };
+  for (int i = 0; i < tabs.length; i++) {
+    final int t = i;
+    c.add(cmd("Go to " + tabs[i] + " tab", "", new Runnable() { public void run() { panelTab = t; panelScroll = 0; } }));
+  }
+  c.add(cmd("Load photo / image...", "or drop it", act(9)));
+  c.add(cmd("Load GPX / GeoJSON route...", "or drop it", act(13)));
+  c.add(cmd("Load CSV / JSON data...", "or drop it", act(14)));
+  c.add(cmd("Load SVG...", "or drop it", act(15)));
+  c.add(cmd("Load audio...", "or drop it", act(16)));
+  c.add(cmd("Load grid / DEM...", "or drop it", act(17)));
+  c.add(cmd("Fetch streets (" + tvLocation.s + ")", "", act(18)));
+  c.add(cmd("Fetch terrain (" + tvLocation.s + ")", "", act(19)));
+  c.add(cmd("Fetch weather (" + tvLocation.s + ")", "", act(20)));
+  c.add(cmd("Choose watch folder...", "or drop a folder", act(23)));
+  c.add(cmd("Clear sources", "", act(27)));
+  File[] ps = new File(sketchPath("presets")).listFiles();
+  if (ps != null) {
+    Arrays.sort(ps);
+    for (final File f : ps) {
+      if (!f.getName().toLowerCase().endsWith(".json")) continue;
+      String nm = f.getName().replaceAll("\\.json$", "").replace('_', ' ');
+      c.add(cmd("Preset: " + nm, "", new Runnable() { public void run() { loadPreset(f); } }));
+    }
+  }
+  return c;
+}
+
+// Commands whose label contains every typed word; labels that start with
+// the query come first.
+ArrayList<Cmd> paletteMatches() {
+  ArrayList<Cmd> first = new ArrayList<Cmd>(), rest = new ArrayList<Cmd>();
+  String q = paletteQuery.trim().toLowerCase();
+  String[] words = q.isEmpty() ? new String[0] : splitTokens(q);
+  for (Cmd c : paletteAll) {
+    String l = c.label.toLowerCase();
+    boolean ok = true;
+    for (String w : words) if (!l.contains(w)) { ok = false; break; }
+    if (!ok) continue;
+    if (!q.isEmpty() && (l.startsWith(q) || l.contains(": " + q))) first.add(c); else rest.add(c);
+  }
+  first.addAll(rest);
+  return first;
+}
+
+float[] paletteBox() {
+  float w = min(560, width - 80), x = (width - w) / 2, y = 70;
+  return new float[] { x, y, w, 46 + PALETTE_ROWS * 28 + 10 };
+}
+
+void drawPalette() {
+  if (!paletteOn) return;
+  noStroke(); fill(0, 120); rect(0, 0, width, height);
+  float[] b = paletteBox();
+  ArrayList<Cmd> m = paletteMatches();
+  paletteSel = constrain(paletteSel, 0, max(0, m.size() - 1));
+  if (paletteSel < paletteTop) paletteTop = paletteSel;
+  if (paletteSel >= paletteTop + PALETTE_ROWS) paletteTop = paletteSel - PALETTE_ROWS + 1;
+  float rows = min(PALETTE_ROWS, max(1, m.size()));
+  fill(C_PANEL); stroke(C_TRACK); strokeWeight(1);
+  rect(b[0], b[1], b[2], 56 + rows * 28, 8);
+  noStroke(); fill(C_FIELD); rect(b[0] + 10, b[1] + 10, b[2] - 20, 32, 5);
+  textSize(14); textAlign(LEFT, CENTER);
+  if (paletteQuery.isEmpty()) { fill(C_DIM); text("Type a command, pattern or preset...", b[0] + 20, b[1] + 25); }
+  else { fill(C_TEXT); text(paletteQuery, b[0] + 20, b[1] + 25); }
+  if ((millis() / 500) % 2 == 0) { stroke(C_ACCENT); float cx = b[0] + 21 + (paletteQuery.isEmpty() ? 0 : textWidth(paletteQuery)); line(cx, b[1] + 16, cx, b[1] + 35); }
+  textSize(13);
+  if (m.isEmpty()) { noStroke(); fill(C_DIM); textAlign(LEFT, CENTER); text("No matching command", b[0] + 20, b[1] + 66); return; }
+  for (int r = 0; r < rows && paletteTop + r < m.size(); r++) {
+    Cmd c = m.get(paletteTop + r);
+    float ry = b[1] + 50 + r * 28;
+    boolean sel = paletteTop + r == paletteSel;
+    noStroke();
+    if (sel) { fill(C_ACCENT, 60); rect(b[0] + 6, ry, b[2] - 12, 26, 4); }
+    fill(sel ? C_TEXT : color(205)); textAlign(LEFT, CENTER);
+    text(c.label, b[0] + 18, ry + 13);
+    if (!c.hint.isEmpty()) { fill(C_DIM); textAlign(RIGHT, CENTER); textSize(11); text(c.hint, b[0] + b[2] - 18, ry + 13); textSize(13); }
+  }
+  if (m.size() > PALETTE_ROWS) {
+    fill(C_DIM); textSize(10); textAlign(RIGHT, TOP);
+    text((paletteTop + 1) + "-" + min(m.size(), paletteTop + PALETTE_ROWS) + " of " + m.size(), b[0] + b[2] - 12, b[1] + 56 + rows * 28 + 4);
+  }
+}
+
+void paletteKey() {
+  if (key == ESC) { key = 0; paletteOn = false; return; }
+  ArrayList<Cmd> m = paletteMatches();
+  if (key == CODED) {
+    if (keyCode == UP) paletteSel = max(0, paletteSel - 1);
+    else if (keyCode == DOWN) paletteSel = min(m.size() - 1, paletteSel + 1);
+    return;
+  }
+  if (key == ENTER || key == RETURN) { if (!m.isEmpty()) runCmd(m.get(paletteSel)); return; }
+  if (key == BACKSPACE) { if (paletteQuery.length() > 0) paletteQuery = paletteQuery.substring(0, paletteQuery.length() - 1); paletteSel = 0; return; }
+  boolean ctrl = keyEvent != null && (keyEvent.isControlDown() || keyEvent.isMetaDown());
+  if (ctrl && keyCode == 'K') { paletteOn = false; return; }
+  if (ctrl && keyCode == 'V') { String c = clipboardText(); if (c != null) paletteQuery += c.trim(); return; }
+  if (key >= 32 && key != DELETE && paletteQuery.length() < 60) { paletteQuery += key; paletteSel = 0; paletteTop = 0; }
+}
+
+void runCmd(Cmd c) {
+  paletteOn = false;
+  c.run.run();
+  if (millis() - statusMs > 100) setStatus(c.label);
+}
+
+void palettePress() {
+  float[] b = paletteBox();
+  ArrayList<Cmd> m = paletteMatches();
+  int r = floor((mouseY - b[1] - 50) / 28);
+  if (mouseX >= b[0] && mouseX <= b[0] + b[2] && r >= 0 && r < PALETTE_ROWS && paletteTop + r < m.size()) runCmd(m.get(paletteTop + r));
+  else if (mouseX < b[0] || mouseX > b[0] + b[2] || mouseY < b[1] || mouseY > b[1] + 56 + PALETTE_ROWS * 28) paletteOn = false;
+}
+
+void paletteWheel(int n) { paletteSel = constrain(paletteSel + n, 0, max(0, paletteMatches().size() - 1)); }
diff --git a/GenerativeLineArt/PaperColour.pde b/GenerativeLineArt/PaperColour.pde
new file mode 100644
index 0000000..43a330a
--- /dev/null
+++ b/GenerativeLineArt/PaperColour.pde
@@ -0,0 +1,28 @@
+// Paper colour: preview the design on cream, kraft, grey, black or navy
+// paper (with white, gold or silver gel pens on dark paper). It only
+// changes the preview, the PNG image and the simulation; plot files never
+// get a background. A pen that would barely show on the chosen paper is
+// struck through in the pen swatches and named in the preview.
+
+int paperColor() { return PAPER_COLOURS[pPaperCol.i()]; }
+
+float lum(int c) { return 0.299 * red(c) + 0.587 * green(c) + 0.114 * blue(c); }
+
+boolean lowContrast(int pen, int paper) {
+  return abs(lum(pen) - lum(paper)) < 45 && dist(red(pen), green(pen), blue(pen), red(paper), green(paper), blue(paper)) < 110;
+}
+
+// A note above the page when an enabled pen barely shows on the paper.
+void drawContrastWarning() {
+  String w = "";
+  for (Layer L : layers) {
+    if (!L.pEnabled.on() || !lowContrast(L.penColor(), paperColor())) continue;
+    w += (w.isEmpty() ? "" : ", ") + PEN_NAMES[L.pColor.i()] + " pen (layer " + (L.id + 1) + ")";
+  }
+  if (w.isEmpty()) return;
+  String t = w + " barely shows on " + PAPER_COLOUR_NAMES[pPaperCol.i()].toLowerCase() + " paper";
+  textSize(12);
+  float tw = textWidth(t) + 24, x = PANEL_W + (areaW() - tw) / 2;
+  noStroke(); fill(0xFF6B4A12); rect(x, 8, tw, 24, 12);
+  fill(0xFFFFE3A3); textAlign(CENTER, CENTER); text(t, x + tw / 2, 19);
+}
diff --git a/GenerativeLineArt/PreviewZoom.pde b/GenerativeLineArt/PreviewZoom.pde
new file mode 100644
index 0000000..8845f15
--- /dev/null
+++ b/GenerativeLineArt/PreviewZoom.pde
@@ -0,0 +1,92 @@
+// Zoom and pan in the preview: mouse wheel zooms around the cursor, drag
+// pans, double-click (or 0) fits the page again. While zoomed in, the
+// visible part is redrawn at that scale, at the real pen width, so you can
+// check overlaps and fine detail before plotting.
+
+float viewZoom = 1, viewCx = -1, viewCy = -1;   // view centre in page mm (-1 = page centre)
+boolean panning = false;
+float panLastX, panLastY;
+PGraphics zoomPg;
+String zoomKey = "";
+
+float areaW() { return width - PANEL_W; }
+float areaH() { return height - 24; }
+
+// Fitted scale (px per mm) at zoom 1.
+float fitScale() { return max(0.1, min((areaW() - 80) / genW, (areaH() - 80) / genH)); }
+
+float viewK() { return fitScale() * viewZoom; }
+float viewOx() { return PANEL_W + areaW() / 2 - (viewCx < 0 ? genW / 2 : min(viewCx, genW)) * viewK(); }
+float viewOy() { return areaH() / 2 - (viewCy < 0 ? genH / 2 : min(viewCy, genH)) * viewK(); }
+
+void resetView() { viewZoom = 1; viewCx = -1; viewCy = -1; }
+
+void zoomAt(float mx, float my, float factor) {
+  float k = viewK(), ox = viewOx(), oy = viewOy();
+  float mmx = (mx - ox) / k, mmy = (my - oy) / k;              // page point under the cursor
+  viewZoom = constrain(viewZoom * factor, 1, 40);
+  if (viewZoom <= 1.0001) { resetView(); return; }
+  float k2 = viewK();
+  viewCx = constrain((PANEL_W + areaW() / 2 - (mx - mmx * k2)) / k2, 0, genW);
+  viewCy = constrain((areaH() / 2 - (my - mmy * k2)) / k2, 0, genH);
+}
+
+void panBy(float dx, float dy) {
+  if (viewZoom <= 1) return;
+  float k = viewK();
+  viewCx = constrain((viewCx < 0 ? genW / 2 : viewCx) - dx / k, 0, genW);
+  viewCy = constrain((viewCy < 0 ? genH / 2 : viewCy) - dy / k, 0, genH);
+}
+
+boolean inPreview() { return mouseX > PANEL_W && mouseY < areaH(); }
+
+// Draws the zoomed view into a buffer the size of the preview area.
+void drawZoomed(float ox, float oy, float k) {
+  int aw = max(1, (int) areaW()), ah = max(1, (int) areaH());
+  String key = aw + "," + ah + "," + ox + "," + oy + "," + k;
+  if (zoomPg == null || zoomPg.width != aw || zoomPg.height != ah || previewStale || !key.equals(zoomKey)) {
+    if (zoomPg == null || zoomPg.width != aw || zoomPg.height != ah) zoomPg = createGraphics(aw, ah, JAVA2D);
+    zoomPg.beginDraw();
+    zoomPg.background(C_CANVAS);
+    zoomPg.translate(ox - PANEL_W, oy);
+    zoomPg.noStroke(); zoomPg.fill(0, 90); zoomPg.rect(5, 6, genW * k, genH * k);
+    zoomPg.fill(paperColor()); zoomPg.rect(0, 0, genW * k, genH * k);
+    zoomPg.noFill(); zoomPg.strokeJoin(ROUND); zoomPg.strokeCap(ROUND);
+    float vx0 = (PANEL_W - ox) / k, vy0 = -oy / k, vx1 = vx0 + aw / k, vy1 = vy0 + ah / k;   // visible page area (mm)
+    for (Layer L : layers) {
+      if (!L.pEnabled.on()) continue;
+      zoomPg.stroke(L.penColor());
+      zoomPg.strokeWeight(max(0.8, L.pPen.val * k));
+      for (ArrayList<PVector> path : L.paths) {
+        if (!pathVisible(path, vx0, vy0, vx1, vy1)) continue;
+        zoomPg.beginShape();
+        for (PVector v : path) zoomPg.vertex(v.x * k, v.y * k);
+        zoomPg.endShape();
+      }
+    }
+    zoomPg.endDraw();
+    zoomKey = key;
+    previewStale = false;
+  }
+  image(zoomPg, PANEL_W, 0);
+}
+
+boolean pathVisible(ArrayList<PVector> p, float x0, float y0, float x1, float y1) {
+  float a = 1e9, b = 1e9, c = -1e9, d = -1e9;
+  for (PVector v : p) { a = min(a, v.x); b = min(b, v.y); c = max(c, v.x); d = max(d, v.y); }
+  return c >= x0 && a <= x1 && d >= y0 && b <= y1;
+}
+
+// Zoom level and a 10 mm scale bar in the corner of the preview.
+void drawZoomInfo(float k) {
+  if (viewZoom <= 1) return;
+  float bar = 10 * k, x = width - 20 - bar, y = areaH() - 22;
+  String mm = "10 mm";
+  if (bar > 260) { bar = k; x = width - 20 - bar; mm = "1 mm"; }
+  noStroke(); fill(C_PANEL, 220); rect(x - 120, y - 26, bar + 128, 40, 6);
+  stroke(C_TEXT); strokeWeight(2); line(x, y, x + bar, y); line(x, y - 4, x, y + 4); line(x + bar, y - 4, x + bar, y + 4);
+  noStroke(); fill(C_TEXT); textSize(11); textAlign(CENTER, BOTTOM); text(mm, x + bar / 2, y - 4);
+  fill(C_ACCENT); textAlign(LEFT, CENTER); textSize(12);
+  text(round(viewZoom * 100) + "%", x - 112, y - 10);
+  fill(C_DIM); textSize(10); text("double-click = fit", x - 112, y + 5);
+}
diff --git a/GenerativeLineArt/Session.pde b/GenerativeLineArt/Session.pde
new file mode 100644
index 0000000..1d08392
--- /dev/null
+++ b/GenerativeLineArt/Session.pde
@@ -0,0 +1,55 @@
+// Session: the design is saved to session.json a moment after every change
+// and restored when the sketch starts, so closing the window (or a crash)
+// never loses work. Ctrl+N starts a fresh design (Undo takes that back).
+// Not used in command-line mode.
+
+JSONObject defaultDesign;            // the built-in start design
+String lastSessionText = "";
+int lastSessionCheck = 0;
+
+File sessionFile() { return new File(sketchPath("session.json")); }
+
+void restoreSession() {
+  defaultDesign = presetJSON();
+  lastSessionText = defaultDesign.format(-1);
+  File f = sessionFile();
+  if (!f.exists()) return;
+  JSONObject o = null;
+  try { o = loadJSONObject(f); } catch (Exception e) {}
+  if (o == null || !applyPreset(o)) { setStatus("Could not restore the last session; starting fresh"); return; }
+  JSONObject ui = o.getJSONObject("ui");
+  if (ui != null) {
+    panelTab = constrain(ui.getInt("tab", 0), 0, 2);
+    curLayer = constrain(ui.getInt("layer", 0), 0, NUM_LAYERS - 1);
+  }
+  lastSessionText = sessionText();
+  setStatus("Your last design is restored (Ctrl+N = start fresh)");
+}
+
+String sessionText() {
+  JSONObject o = presetJSON();
+  return o.format(-1);
+}
+
+void autosaveSession() {
+  if (cliMode || defaultDesign == null) return;
+  if (millis() - lastSessionCheck < 2000 || millis() - lastChangeMs < 1000 || activeW != null) return;
+  lastSessionCheck = millis();
+  String t = sessionText();
+  JSONObject ui = new JSONObject();
+  ui.setInt("tab", panelTab);
+  ui.setInt("layer", curLayer);
+  String key = t + ui.format(-1);
+  if (key.equals(lastSessionText)) return;
+  JSONObject o = parseJSONObject(t);
+  o.setJSONObject("ui", ui);
+  if (o.save(sessionFile(), "indent=2")) lastSessionText = key;
+}
+
+void startFresh() {
+  if (defaultDesign == null) return;
+  commitPending();
+  applyPreset(defaultDesign);
+  resetView();
+  setStatus("Fresh start: Ctrl+Z brings your design back");
+}
diff --git a/GenerativeLineArt/ShareImage.pde b/GenerativeLineArt/ShareImage.pde
new file mode 100644
index 0000000..e98c844
--- /dev/null
+++ b/GenerativeLineArt/ShareImage.pde
@@ -0,0 +1,87 @@
+// Share image: a PNG "proof card" of the design, to show a client or post
+// online: the plot on paper at the real pen widths, with a soft shadow and a
+// caption (patterns, paper, pens, plot time). The I key or the Output tab
+// button saves one; on the command line, --out name.png writes it.
+
+File pendingShare;
+
+void requestShareImage() {
+  selectOutput("Save a PNG image of the design", "shareSelected", new File(sketchPath("lineart_" + timestamp() + ".png")));
+}
+
+void shareSelected(File f) {
+  if (f == null) return;
+  if (!f.getName().toLowerCase().endsWith(".png")) f = new File(f.getAbsolutePath() + ".png");
+  pendingShare = f;
+}
+
+// Renders the card; longSide is the long edge of the paper in pixels.
+PGraphics shareImage(int longSide) {
+  float k = longSide / max(genW, genH);
+  int pw = round(genW * k), ph = round(genH * k);
+  int pad = round(longSide * 0.08), foot = round(longSide * 0.11);
+  int w = pw + 2 * pad, h = ph + pad + foot;
+  PGraphics g = createGraphics(w, h, JAVA2D);
+  g.smooth(8);
+  g.beginDraw();
+  g.background(0xFFE9E6E0);
+  // soft shadow
+  g.noStroke();
+  for (int i = 12; i >= 1; i--) {
+    g.fill(0, 5);
+    float o = i * longSide / 900.0;
+    g.rect(pad - o * 0.5 + o * 0.4, pad - o * 0.5 + o * 0.9, pw + o, ph + o, o);
+  }
+  g.fill(paperColor()); g.rect(pad, pad, pw, ph);
+  g.pushMatrix();
+  g.translate(pad, pad);
+  g.noFill(); g.strokeJoin(ROUND); g.strokeCap(ROUND);
+  for (Layer L : layers) {
+    if (!L.pEnabled.on()) continue;
+    g.stroke(L.penColor());
+    g.strokeWeight(max(1, L.pPen.val * k));
+    for (ArrayList<PVector> path : L.paths) {
+      g.beginShape();
+      for (PVector v : path) g.vertex(v.x * k, v.y * k);
+      g.endShape();
+    }
+  }
+  g.popMatrix();
+
+  // caption
+  ArrayList<String> pats = new ArrayList<String>();
+  int pens = 0; float secs = 0, len = 0;
+  for (Layer L : layers) if (L.pEnabled.on()) {
+    pens++; secs += L.seconds(); len += L.length;
+    String n = PATTERN_NAMES[L.pMode.i()];
+    if (!pats.contains(n)) pats.add(n);
+  }
+  float ts = longSide * 0.026, ty = pad + ph + foot * 0.42;
+  g.textFont(uiFont);
+  g.textAlign(LEFT, CENTER);
+  g.fill(0xFF2A2A2A); g.textSize(ts);
+  g.text(pats.isEmpty() ? "Empty design" : join(pats.toArray(new String[0]), "  +  "), pad, ty);
+  g.fill(0xFF77736C); g.textSize(ts * 0.62);
+  String info = PAPER_NAMES[pPaper.i()] + (pLandscape.on() ? " landscape" : "") + "  ·  " + round(genW) + " × " + round(genH) + " mm  ·  "
+    + pens + (pens == 1 ? " pen" : " pens") + "  ·  " + String.format(Locale.US, "%.1f m of line", len / 1000) + "  ·  plot time " + fmtTime(secs).replace("~", "about ");
+  g.text(info, pad, ty + ts * 1.15);
+  // pen swatches, right-aligned
+  float r = ts * 0.55, x = pad + pw - r;
+  for (int i = NUM_LAYERS - 1; i >= 0; i--) {
+    Layer L = layers[i];
+    if (!L.pEnabled.on()) continue;
+    g.stroke(0, 50); g.strokeWeight(max(1, r * 0.08)); g.fill(L.penColor()); g.ellipse(x, ty, r * 2, r * 2);
+    x -= r * 2.8;
+  }
+  g.endDraw();
+  return g;
+}
+
+boolean writeShareImage(File f) {
+  regenerate();
+  PGraphics g = shareImage(2000);
+  if (f.getParentFile() != null) f.getParentFile().mkdirs();
+  boolean ok = g.save(f.getAbsolutePath());
+  setStatus(ok ? "Saved image: " + f.getName() : "Could not save " + f.getName());
+  return ok;
+}
diff --git a/GenerativeLineArt/Simulate.pde b/GenerativeLineArt/Simulate.pde
new file mode 100644
index 0000000..31e815a
--- /dev/null
+++ b/GenerativeLineArt/Simulate.pde
@@ -0,0 +1,190 @@
+// Plot simulation: plays the plot back in the order and at the speed the
+// plotter will draw it (pen-down speed, travel speed and pen lifts from the
+// Output tab), layer after layer. Travel moves show as a thin line behind
+// the pen. Plays the whole plot in about 30 seconds by default.
+//   G = start / stop, Space = pause, + / - = faster / slower,
+//   click the time bar to jump, Esc = stop
+
+boolean simOn = false, simPaused = false;
+float simT = 0, simTotal = 0, simSpeed = 1;
+int simLastMs = 0;
+ArrayList<float[]> simEvents = new ArrayList<float[]>();     // per path: layer, path, t start, t down, t end
+ArrayList<ArrayList<PVector>> simPathsList = new ArrayList<ArrayList<PVector>>();
+ArrayList<float[]> simCum = new ArrayList<float[]>();        // cumulative length per point
+int simDrawn = 0;                     // paths already in the buffer
+PGraphics simPg;
+float simK, simOx, simOy;
+
+void toggleSimulation() {
+  if (simOn) { simOn = false; return; }
+  buildSimulation();
+  if (simEvents.isEmpty()) { setStatus("Nothing to plot: enable a layer first"); return; }
+  exploreOn = false;
+  resetView();
+  simOn = true; simPaused = false; simT = 0; simDrawn = 0; simPg = null;
+  simSpeed = max(1, simTotal / 30.0);
+  simLastMs = millis();
+}
+
+void buildSimulation() {
+  simEvents.clear(); simPathsList.clear(); simCum.clear();
+  float t = 0, px = 0, py = 0;
+  float down = pSpeedDown.val, up = pSpeedUp.val, lift = pLiftTime.val;
+  for (Layer L : layers) {
+    if (!L.pEnabled.on()) continue;
+    for (ArrayList<PVector> p : L.paths) {
+      if (p.size() < 2) continue;
+      PVector a = p.get(0);
+      float t0 = t;
+      t += dist(px, py, a.x, a.y) / up + lift;               // travel, pen down
+      float tDown = t;
+      float[] cum = new float[p.size()];
+      for (int i = 1; i < p.size(); i++) cum[i] = cum[i - 1] + PVector.dist(p.get(i - 1), p.get(i));
+      t += cum[p.size() - 1] / down + lift;                     // draw, pen up
+      simEvents.add(new float[] { L.id, simPathsList.size(), t0, tDown, t, px, py });
+      simPathsList.add(p);
+      simCum.add(cum);
+      PVector b = p.get(p.size() - 1);
+      px = b.x; py = b.y;
+    }
+  }
+  simTotal = t + dist(px, py, 0, 0) / up;                      // back to the origin
+}
+
+// Draws one simulation frame in the preview area.
+void drawSimulation() {
+  int now = millis();
+  if (!simPaused) simT = min(simTotal, simT + (now - simLastMs) / 1000.0 * simSpeed);
+  simLastMs = now;
+
+  int pw = max(1, round(genW * fitScale())), ph = max(1, round(genH * fitScale()));
+  simK = pw / genW;
+  simOx = PANEL_W + (areaW() - pw) / 2.0;
+  simOy = (areaH() - 40 - ph) / 2.0 + 4;
+  if (simPg == null || simPg.width != pw || simPg.height != ph) {
+    simPg = createGraphics(pw, ph, JAVA2D);
+    simPg.beginDraw(); simPg.background(paperColor()); simPg.endDraw();
+    simDrawn = 0;
+  }
+  // paths finished since the last frame go into the buffer
+  int done = simDrawn;
+  while (done < simEvents.size() && simEvents.get(done)[4] <= simT) done++;
+  if (done < simDrawn) {                                       // jumped back: start over
+    simPg.beginDraw(); simPg.background(paperColor()); simPg.endDraw();
+    simDrawn = 0;
+  }
+  if (done > simDrawn) {
+    simPg.beginDraw();
+    simPg.noFill(); simPg.strokeJoin(ROUND); simPg.strokeCap(ROUND);
+    for (int i = simDrawn; i < done; i++) simStroke(simPg, i, -1);
+    simPg.endDraw();
+    simDrawn = done;
+  }
+  noStroke(); fill(0, 90); rect(simOx + 5, simOy + 6, pw, ph);
+  image(simPg, simOx, simOy);
+
+  // the path being drawn now, the travel line and the pen
+  float penX = 0, penY = 0;
+  boolean penDown = false;
+  int cur = simDrawn;
+  if (cur < simEvents.size()) {
+    float[] e = simEvents.get(cur);
+    if (simT >= e[2]) {
+      if (simT < e[3]) {                                       // travelling to the path
+        PVector a = simPathsList.get(cur).get(0);
+        float f = constrain((simT - e[2]) / max(1e-6, e[3] - e[2] - pLiftTime.val), 0, 1);
+        penX = lerp(e[5], a.x, f); penY = lerp(e[6], a.y, f);
+        stroke(220, 60, 60, 160); strokeWeight(1);
+        line(simOx + e[5] * simK, simOy + e[6] * simK, simOx + penX * simK, simOy + penY * simK);
+      } else {
+        float drawn = (simT - e[3]) * pSpeedDown.val;
+        pushMatrix(); translate(simOx, simOy);
+        noFill(); strokeJoin(ROUND); strokeCap(ROUND);
+        PVector p = simStroke(g, cur, drawn);
+        popMatrix();
+        penX = p.x; penY = p.y; penDown = true;
+      }
+    } else { penX = e[5]; penY = e[6]; }
+  }
+  Layer L = cur < simEvents.size() ? layers[(int) simEvents.get(cur)[0]] : null;
+  float sx = simOx + penX * simK, sy = simOy + penY * simK;
+  noFill(); stroke(L == null ? C_DIM : L.penColor()); strokeWeight(2);
+  ellipse(sx, sy, penDown ? 9 : 15, penDown ? 9 : 15);
+  if (!penDown) { stroke(C_DIM); strokeWeight(1); line(sx - 10, sy, sx + 10, sy); line(sx, sy - 10, sx, sy + 10); }
+
+  drawSimBar(L, cur);
+  if (simT >= simTotal && !simPaused) { simPaused = true; setStatus("Plot finished: " + fmtClock(simTotal)); }
+}
+
+// Strokes path i (up to 'upTo' mm of it, all of it when negative) on g.
+// Returns the last point drawn.
+PVector simStroke(PGraphics gr, int i, float upTo) {
+  Layer L = layers[(int) simEvents.get(i)[0]];
+  ArrayList<PVector> p = simPathsList.get(i);
+  float[] cum = simCum.get(i);
+  gr.stroke(L.penColor());
+  gr.strokeWeight(max(0.8, L.pPen.val * simK));
+  gr.beginShape();
+  PVector last = p.get(0);
+  for (int k = 0; k < p.size(); k++) {
+    if (upTo >= 0 && cum[k] > upTo) {
+      PVector a = p.get(k - 1), b = p.get(k);
+      float f = (upTo - cum[k - 1]) / max(1e-6, cum[k] - cum[k - 1]);
+      last = new PVector(lerp(a.x, b.x, f), lerp(a.y, b.y, f));
+      gr.vertex(last.x * simK, last.y * simK);
+      break;
+    }
+    last = p.get(k);
+    gr.vertex(last.x * simK, last.y * simK);
+  }
+  gr.endShape();
+  return last;
+}
+
+float[] simBarRect() { return new float[] { PANEL_W + 30, areaH() - 34, areaW() - 60, 8 }; }
+
+void drawSimBar(Layer L, int cur) {
+  float[] b = simBarRect();
+  noStroke(); fill(C_TRACK); rect(b[0], b[1], b[2], b[3], 4);
+  // layer segments in their pen colour
+  float t0 = 0;
+  for (int i = 0; i < simEvents.size(); i++) {
+    boolean last = i == simEvents.size() - 1 || simEvents.get(i + 1)[0] != simEvents.get(i)[0];
+    if (last) {
+      float t1 = simEvents.get(i)[4];
+      fill(layers[(int) simEvents.get(i)[0]].penColor(), 120);
+      rect(b[0] + b[2] * t0 / simTotal, b[1] + b[3] - 2, b[2] * (t1 - t0) / simTotal, 2);
+      t0 = t1;
+    }
+  }
+  fill(C_ACCENT); rect(b[0], b[1], b[2] * simT / max(1e-6, simTotal), b[3] - 3, 4);
+  fill(C_TEXT); textSize(12); textAlign(LEFT, BOTTOM);
+  String where = L == null ? "done" : "layer " + (L.id + 1) + "  ·  path " + min(cur + 1, simEvents.size()) + " of " + simEvents.size();
+  text(fmtClock(simT) + " / " + fmtClock(simTotal) + "   " + where, b[0], b[1] - 6);
+  fill(C_DIM); textAlign(RIGHT, BOTTOM); textSize(11);
+  text((simPaused ? "paused  ·  " : "") + (simSpeed < 10 ? nf(simSpeed, 0, 1) : str(round(simSpeed))) + "x  ·  Space = pause  ·  +/- = speed  ·  click bar = jump  ·  G / Esc = stop", b[0] + b[2], b[1] - 6);
+}
+
+String fmtClock(float s) {
+  int t = round(s), h = t / 3600, m = (t / 60) % 60, sec = t % 60;
+  return (h > 0 ? h + ":" + nf(m, 2) : str(m)) + ":" + nf(sec, 2);
+}
+
+boolean simPress() {
+  if (!simOn || mouseX < PANEL_W) return false;
+  float[] b = simBarRect();
+  if (mouseY >= b[1] - 10 && mouseY <= b[1] + b[3] + 10) {
+    simT = constrain((mouseX - b[0]) / b[2], 0, 1) * simTotal;
+    simPaused = false;
+  } else simPaused = !simPaused;                              // click the page = pause / play
+  return true;
+}
+
+boolean simKey() {
+  if (!simOn) return false;
+  if (key == ESC || key == 'g' || key == 'G') { key = 0; simOn = false; return true; }
+  if (key == ' ') { simPaused = !simPaused; if (simT >= simTotal) { simT = 0; simPaused = false; } return true; }
+  if (key == '+' || key == '=') { simSpeed = min(simSpeed * 2, 100000); return true; }
+  if (key == '-') { simSpeed = max(simSpeed / 2, 0.25); return true; }
+  return true;
+}
diff --git a/GenerativeLineArt/Sources.pde b/GenerativeLineArt/Sources.pde
index 8002315..5ada87d 100644
--- a/GenerativeLineArt/Sources.pde
+++ b/GenerativeLineArt/Sources.pde
@@ -55,7 +55,9 @@ void runMainQueue() {
 // Runs 'work' off the animation thread; errors end up in the status bar.
 void runAsync(final String what, final Task work) {
   if (syncJobs) {
-    try { work.run(); } catch (Exception e) { cliError(what + " failed: " + errText(e)); }
+    try { work.run(); }
+    catch (CliAbort e) { throw e; }                     // already reported
+    catch (Exception e) { cliError(what + " failed: " + errText(e)); }
     return;
   }
   busyCount++;
diff --git a/README.md b/README.md
index c4c30dd..f27a727 100644
--- a/README.md
+++ b/README.md
@@ -45,17 +45,25 @@ Open [`GenerativeLineArt/GenerativeLineArt.pde`](GenerativeLineArt/GenerativeLin
 
 ## Controls
 
+- **Command palette** (`Ctrl+K` / `Cmd+K` or `/`): search everything the app can do — patterns, actions, paper, pens, layers, tabs, sources and the presets in `presets/` — and run it with `Enter`. Each command shows its shortcut, so it doubles as the shortcut list.
 - **Design / Sources / Output tabs** at the top of the panel: *Design* holds the paper, layers and pattern parameters; *Sources* loads external data (see below); *Output* holds the plotter speeds and time estimate, path clean-up, registration marks / pen test, mask source, export format and batch export.
-- **Sliders / dials** in the left panel adjust the current layer's parameters live. Mouse wheel over a slider = fine adjustment; elsewhere in the panel it scrolls.
+- **Sliders / dials** in the left panel adjust the current layer's parameters live. Mouse wheel over a slider = fine adjustment; elsewhere in the panel it scrolls. **Double-click** a slider (or click its value) to type an exact value: `Enter` applies, `Esc` cancels, `Tab` moves to the next slider, Up/Down nudge; `*2`, `/2`, `+10` and `--10` change the current value, and a decimal comma works too.
 - **Right-click** a pattern parameter or the seed to lock / unlock it (a padlock appears next to its name).
+- **Preview zoom**: mouse wheel over the page zooms around the cursor (up to 4000 %), drag to pan, double-click or `0` fits the page again (`+` / `-` zoom too). Zoomed in, lines are drawn at their real pen width, with a scale bar, so you can check overlaps and fine detail before plotting.
+- **Paper colour** (Design tab): preview on white, cream, kraft, grey, black or navy paper; pens include white, gold and silver for dark paper. It changes the preview, the PNG image and the simulation, never the plot files. A pen that barely shows on the paper is struck through in the swatches and named above the page.
 - **Layer tabs** (1–4) switch which pen layer you're editing.
 - **Pattern dropdown** picks the pattern for the current layer; Left/Right arrow keys cycle through patterns.
 - **New seed / Randomize / Reset** buttons (or `N`/`Space`, `R`) regenerate the current layer.
+- **Your work is kept**: the design is saved to `GenerativeLineArt/session.json` a moment after each change and restored at the next start (tab and layer included). `Ctrl+N` starts a fresh design; `Ctrl+Z` takes that back.
+- **Explore variations** (button or `E`): a 3 × 3 grid of alternatives for the current layer, drawn with the other layers. Click one (or press `1`–`9`) to keep it; `Space` = new batch, `Tab` switches between *seeds only* and *also vary parameters* (locked values stay), `Esc` closes. The first cell is the current design, for comparison.
+- **Simulate plot** (Output tab or `G`): plays the plot back in the order and at the speed the plotter will draw it (pen-down and travel speed, pen lifts), layer after layer, with travel moves and the pen position. The whole plot takes about 30 s; `Space` pauses, `+` / `-` change the speed, click the time bar to jump, `G` / `Esc` stops.
 - **Undo / Redo** buttons, or `Ctrl+Z` and `Ctrl+Y` / `Ctrl+Shift+Z` (`Cmd` on macOS).
 - **Mask** (Design tab, per layer): Off / Inside / Outside. Pick the text or image on the Output tab.
 - **Font** (Output tab, text mask): click to open a list of every installed font. Type to filter it (e.g. `bold`), scroll with the mouse wheel or Up/Down, then click a font or press Enter. The font is saved in presets; if a preset's font isn't installed, the current font stays.
 - **Export ...** (or `S`) opens a save dialog in the chosen format; a quick-save also writes into `GenerativeLineArt/exports/`.
+- **Save PNG image** (Output tab or `I`): a proof card of the design — the plot on paper at the real pen widths, with a caption (patterns, paper, pens, length of line, plot time) — to show a client or post online.
 - **Save preset... / Load preset...** (or `P`, `L`) store/restore the whole setup as JSON in `GenerativeLineArt/presets/`.
+- **Drag and drop** files onto the window to load them (any type from *External sources*; several at once is fine, a preset is applied). Drop a folder to watch it, or a link from your browser to download it.
 - **Text fields** (mask text, URL, place, prompt): click to type, `Ctrl+V` / `Cmd+V` pastes, `Enter` runs the button next to the field.
 
 ## External sources
@@ -95,11 +103,13 @@ The sketch can run without the GUI, for scripts, scheduled tasks or flows. Argum
 Processing cli --sketch=GenerativeLineArt --run --preset presets/wave_lines_a3.json --out exports/waves.svg
 Processing cli --sketch=GenerativeLineArt --run --input route.gpx --text "Sunday ride" --layer 2 --format gcode --out ride.gcode
 Processing cli --sketch=GenerativeLineArt --run --location "Utrecht" --streets major --radius 2000 --out utrecht.svg
+Processing cli --sketch=GenerativeLineArt --run --preset presets/wave_lines_a3.json --out preview.png   # proof card image
+Processing cli --sketch=GenerativeLineArt --run --set "Pattern=Wave lines" --set "Lines=90" --set "Paper colour=Black" --set "Pen colour=White" --out waves.png
 Processing cli --sketch=GenerativeLineArt --run --design-text "Anna & Tom" --batch 10
 Processing cli --sketch=GenerativeLineArt --run --watch C:\Plots\Inbox
 ```
 
-Options: `--preset`, `--input <file|url>` (repeatable), `--grid`, `--layer`, `--location`, `--streets [all|major|water|buildings]`, `--radius`, `--terrain [zoom]`, `--weather`, `--text`, `--seed`, `--seed-text`, `--design-text`, `--prompt`, `--paper`, `--landscape` / `--portrait`, `--format svg|gcode|hpgl`, `--out`, `--batch <n>`, `--watch <folder>`, `--help`. Relative paths are relative to the current directory. Without `--watch` the window stays hidden and the sketch quits after exporting, with exit code 1 when something failed. On a Linux server without a display, run it under `xvfb-run`.
+Options: `--set "<name>=<value>"` (any parameter or setting by name; choices by option name), `--list [json]` (every pattern, parameter and setting with its range), `--preset`, `--input <file|url>` (repeatable), `--grid`, `--layer`, `--location`, `--streets [all|major|water|buildings]`, `--radius`, `--terrain [zoom]`, `--weather`, `--text`, `--seed`, `--seed-text`, `--design-text`, `--prompt`, `--paper`, `--landscape` / `--portrait`, `--format svg|gcode|hpgl`, `--out`, `--batch <n>`, `--watch <folder>`, `--help`. Relative paths are relative to the current directory. Without `--watch` the window stays hidden and the sketch quits after exporting, with exit code 1 when something failed. On a Linux server without a display, run it under `xvfb-run`.
 
 ## Plotting