diff --git a/.github/workflows/weft.yml b/.github/workflows/weft.yml
index 23cd7a1..4704c0a 100644
--- a/.github/workflows/weft.yml
+++ b/.github/workflows/weft.yml
@@ -87,7 +87,7 @@ jobs:
         if: always()
         uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
-          name: weft-0.1
+          name: weft-0.2
           path: |
             fonts/weft/
             proofs/weft/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4275c00..729e51f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,13 @@ Each family keeps its own changelog:
 
 Release tags: `weft-vX.Y.Z`, `sans-vX.Y.Z`, `heddle-vX.Y.Z`, `warp-vX.Y.Z`, `site-vX.Y.Z`.
 
+## 2026-10-28: Weft 0.2
+
+- machine-made Weft 0.2.0 (font version 0.200): look-alikes, Latin
+  Extended-A, combining marks, box drawing, arrows, hinted static TTF.
+  See `weft/CHANGELOG.md`. Site: the Weft download links point to
+  `weft-v0.2.0`.
+
 ## 2026-10-27: Warp 0.1
 
 - machine-made Warp 0.1.0 (font version 0.100): machine-made Warp
diff --git a/STATUS.md b/STATUS.md
index 4971a3e..ec21218 100644
--- a/STATUS.md
+++ b/STATUS.md
@@ -8,7 +8,7 @@
 | Visibility | public after the 0.1 release (founder approved) |
 | Stage | released 0.1: machine-made Weft 0.1.0, machine-made Sans 0.1.0, specimen site 0.1.0, machine-made Heddle 0.1.0. machine-made Warp 0.1 built on branch `warp/v0.1` |
 | Gate now | Warp: Jac reviews the PR from `warp/v0.1`; the founder reviews the proofs; then the tags `warp-v0.1.0` and a new `site-v*` |
-| Next task | Warp 0.2: the OpenType MATH table; Warp 0.3: the variable font (see `warp/STATUS.md`). Heddle 0.2 (see `heddle/STATUS.md`). Weft: polish (look-alikes l/1, I/1, O/0; heavy accented capitals), width axis, Thread style. Sans 0.2: redraw in the style of Weft and match Weft's x-height (see `sans/STATUS.md`). npm packages for both families. |
+| Next task | Warp 0.2: the OpenType MATH table; Warp 0.3: the variable font (see `warp/STATUS.md`). Heddle 0.2 (see `heddle/STATUS.md`). Weft 0.2 is on branch `weft/v0.2` (see `weft/STATUS.md`); then the width axis and the Thread style. Sans 0.2: redraw in the style of Weft and match Weft's x-height (see `sans/STATUS.md`). npm packages for both families. |
 | Blocked by | none |
 | Last green CI | none yet (first runs are on the release PR). Local end-to-end run of all steps on 2026-10-26: green |
 | Owner model | to assign |
@@ -102,9 +102,8 @@ Family notes: `weft/STATUS.md`, `sans/STATUS.md`,
   runners can differ (for example ttfautohint for the Sans static TTF).
   If the Sans byte check fails on the runner, the workflow says so; the
   fallback is the structural check `sans/scripts/compare_builds.py`.
-- **Weft look-alikes.** OCR confuses l and I with 1, and O with 0, more
-  than in DejaVu Sans Mono (CER 0.12 against 0.075). The gate stops a
-  regression; it does not prove parity.
+- **Weft look-alikes.** Fixed in Weft 0.2 (branch `weft/v0.2`): OCR
+  CER 0.07 to 0.08 against 0.0875 for DejaVu Sans Mono.
 - **Line height with accented capitals.** Both families use an ascender
   of 906. Accented capitals go above it (Sans Á at about 1000). Win
   metrics cover all ink, so nothing clips, but tight line spacing can
diff --git a/fonts/weft/otf/MachineMadeWeft-Black.otf b/fonts/weft/otf/MachineMadeWeft-Black.otf
index 1dd3b14..4f687d8 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-Black.otf and b/fonts/weft/otf/MachineMadeWeft-Black.otf differ
diff --git a/fonts/weft/otf/MachineMadeWeft-Bold.otf b/fonts/weft/otf/MachineMadeWeft-Bold.otf
index bafba33..052b3d1 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-Bold.otf and b/fonts/weft/otf/MachineMadeWeft-Bold.otf differ
diff --git a/fonts/weft/otf/MachineMadeWeft-ExtraBold.otf b/fonts/weft/otf/MachineMadeWeft-ExtraBold.otf
index b558f3b..7917951 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-ExtraBold.otf and b/fonts/weft/otf/MachineMadeWeft-ExtraBold.otf differ
diff --git a/fonts/weft/otf/MachineMadeWeft-ExtraLight.otf b/fonts/weft/otf/MachineMadeWeft-ExtraLight.otf
index 6307721..6172db2 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-ExtraLight.otf and b/fonts/weft/otf/MachineMadeWeft-ExtraLight.otf differ
diff --git a/fonts/weft/otf/MachineMadeWeft-Light.otf b/fonts/weft/otf/MachineMadeWeft-Light.otf
index efa27df..6e21abe 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-Light.otf and b/fonts/weft/otf/MachineMadeWeft-Light.otf differ
diff --git a/fonts/weft/otf/MachineMadeWeft-Medium.otf b/fonts/weft/otf/MachineMadeWeft-Medium.otf
index 750a58f..d49c8a9 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-Medium.otf and b/fonts/weft/otf/MachineMadeWeft-Medium.otf differ
diff --git a/fonts/weft/otf/MachineMadeWeft-Regular.otf b/fonts/weft/otf/MachineMadeWeft-Regular.otf
index 95d08f2..769a980 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-Regular.otf and b/fonts/weft/otf/MachineMadeWeft-Regular.otf differ
diff --git a/fonts/weft/otf/MachineMadeWeft-SemiBold.otf b/fonts/weft/otf/MachineMadeWeft-SemiBold.otf
index 4574fb0..72b6c70 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-SemiBold.otf and b/fonts/weft/otf/MachineMadeWeft-SemiBold.otf differ
diff --git a/fonts/weft/otf/MachineMadeWeft-Thin.otf b/fonts/weft/otf/MachineMadeWeft-Thin.otf
index 88bfa8d..dde9c28 100644
Binary files a/fonts/weft/otf/MachineMadeWeft-Thin.otf and b/fonts/weft/otf/MachineMadeWeft-Thin.otf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-Black.ttf b/fonts/weft/ttf/MachineMadeWeft-Black.ttf
index 63808d2..41fd256 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-Black.ttf and b/fonts/weft/ttf/MachineMadeWeft-Black.ttf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-Bold.ttf b/fonts/weft/ttf/MachineMadeWeft-Bold.ttf
index a0ed331..f6445bc 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-Bold.ttf and b/fonts/weft/ttf/MachineMadeWeft-Bold.ttf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-ExtraBold.ttf b/fonts/weft/ttf/MachineMadeWeft-ExtraBold.ttf
index 83b1e03..39edcd6 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-ExtraBold.ttf and b/fonts/weft/ttf/MachineMadeWeft-ExtraBold.ttf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-ExtraLight.ttf b/fonts/weft/ttf/MachineMadeWeft-ExtraLight.ttf
index 7d452e9..11bc2f8 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-ExtraLight.ttf and b/fonts/weft/ttf/MachineMadeWeft-ExtraLight.ttf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-Light.ttf b/fonts/weft/ttf/MachineMadeWeft-Light.ttf
index cdadaa3..5ff1c5c 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-Light.ttf and b/fonts/weft/ttf/MachineMadeWeft-Light.ttf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-Medium.ttf b/fonts/weft/ttf/MachineMadeWeft-Medium.ttf
index 8a2dff8..39ea7d7 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-Medium.ttf and b/fonts/weft/ttf/MachineMadeWeft-Medium.ttf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-Regular.ttf b/fonts/weft/ttf/MachineMadeWeft-Regular.ttf
index e088e85..aac6ac5 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-Regular.ttf and b/fonts/weft/ttf/MachineMadeWeft-Regular.ttf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-SemiBold.ttf b/fonts/weft/ttf/MachineMadeWeft-SemiBold.ttf
index baab647..8de8545 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-SemiBold.ttf and b/fonts/weft/ttf/MachineMadeWeft-SemiBold.ttf differ
diff --git a/fonts/weft/ttf/MachineMadeWeft-Thin.ttf b/fonts/weft/ttf/MachineMadeWeft-Thin.ttf
index 2a2ef02..7506803 100644
Binary files a/fonts/weft/ttf/MachineMadeWeft-Thin.ttf and b/fonts/weft/ttf/MachineMadeWeft-Thin.ttf differ
diff --git a/fonts/weft/variable/MachineMadeWeft[FRAG,wght].ttf b/fonts/weft/variable/MachineMadeWeft[FRAG,wght].ttf
index 41e302e..8ee73cb 100644
Binary files a/fonts/weft/variable/MachineMadeWeft[FRAG,wght].ttf and b/fonts/weft/variable/MachineMadeWeft[FRAG,wght].ttf differ
diff --git a/fonts/weft/webfonts/MachineMadeWeft-Bold.woff2 b/fonts/weft/webfonts/MachineMadeWeft-Bold.woff2
index 2b20c93..240c79d 100644
Binary files a/fonts/weft/webfonts/MachineMadeWeft-Bold.woff2 and b/fonts/weft/webfonts/MachineMadeWeft-Bold.woff2 differ
diff --git a/fonts/weft/webfonts/MachineMadeWeft-Regular.woff2 b/fonts/weft/webfonts/MachineMadeWeft-Regular.woff2
index 4168a4b..6ec4396 100644
Binary files a/fonts/weft/webfonts/MachineMadeWeft-Regular.woff2 and b/fonts/weft/webfonts/MachineMadeWeft-Regular.woff2 differ
diff --git a/fonts/weft/webfonts/MachineMadeWeft[FRAG,wght].woff2 b/fonts/weft/webfonts/MachineMadeWeft[FRAG,wght].woff2
index 06665e1..b32fe74 100644
Binary files a/fonts/weft/webfonts/MachineMadeWeft[FRAG,wght].woff2 and b/fonts/weft/webfonts/MachineMadeWeft[FRAG,wght].woff2 differ
diff --git a/proofs/weft/readability.json b/proofs/weft/readability.json
index 224f83e..15cabc1 100644
--- a/proofs/weft/readability.json
+++ b/proofs/weft/readability.json
@@ -8,7 +8,7 @@
     24
   ],
   "upscale": 3,
-  "lookalike_text": "5mlg8 I8clO 0dcZr 98nrI Ol0Bg l8n|5\n1l|n| mcr5g S29rn 8OI95 c91Sl 99l9S\nn209r 01ZS2 1mS52 B1|m5 d92IO |9B9Z\nIIr82 mcSB8 In555 1I0gB mcBc| lr|SZ\n2ZlrI d25Id 2ZdO0 l9I0r 92|2| Ignl5\nS0I|5 g5ln0 S0nlg 5lIcZ Bm8mS 90g1B\nlgm|8 S5S19 |9ng5 8d|nB BgBSl 9g88d\nI9gl2 O|08r ||9Ol O2ZB0 nlrdr 051dl",
+  "lookalike_text": "5mlg8 Iq8cl O0dcZ rq98n rIOl0 Bglq8\nn|5q1 l|n|m cr5gS 29rn8 OI95c 91Sl9\nq9l9S n209r 01ZS2 1mS52 B1|m5 qd92I\nOq|9B 9ZIIr 82mcS B8qIn 5551I 0gBmc\nBqc|l r|SZ2 ZlrId 25Id2 ZdO0l 9Iq0r\n92|2| Ignql 5S0I| 5g5ln 0S0nl g5lIc\nZBmq8 mS90g 1Blgm |8S5S 19|9n g58d|\nnBBgB Sl9g8 8dI9g ql2O| 08r|| 9OlO2",
   "weft": {
     "font": "machine-made Weft (variable, wght 400)",
     "paragraph": {
@@ -16,70 +16,90 @@
         "cer_by_px": {
           "16": 0.0034,
           "20": 0.0,
+          "24": 0.0069
+        },
+        "cer_mean": 0.0034
+      },
+      "FRAG 8": {
+        "cer_by_px": {
+          "16": 0.0,
+          "20": 0.0,
           "24": 0.0034
         },
-        "cer_mean": 0.0023
+        "cer_mean": 0.0011
       },
       "FRAG 15": {
         "cer_by_px": {
           "16": 0.0034,
           "20": 0.0,
-          "24": 0.0
+          "24": 0.0034
         },
-        "cer_mean": 0.0011
+        "cer_mean": 0.0023
       },
       "FRAG 50": {
         "cer_by_px": {
-          "16": 0.0552,
-          "20": 0.0207,
-          "24": 0.031
+          "16": 0.0517,
+          "20": 0.0138,
+          "24": 0.0138
         },
-        "cer_mean": 0.0356
+        "cer_mean": 0.0264
       },
       "FRAG 100": {
         "cer_by_px": {
-          "16": 0.3621,
+          "16": 0.3793,
           "20": 0.4172,
-          "24": 0.4552
+          "24": 0.6241
         },
-        "cer_mean": 0.4115
+        "cer_mean": 0.4735
       }
     },
     "lookalikes": {
       "FRAG 0": {
         "cer_by_px": {
-          "20": 0.1417,
-          "24": 0.1167,
-          "32": 0.1125
+          "20": 0.0833,
+          "24": 0.0625,
+          "32": 0.0667
+        },
+        "cer": 0.0708,
+        "confusions": {
+          "other": 11,
+          "O->0": 5,
+          "I->1": 5,
+          "l->1": 4,
+          "0->O": 4,
+          "I->l": 1
+        }
+      },
+      "FRAG 8": {
+        "cer_by_px": {
+          "20": 0.0875,
+          "24": 0.075,
+          "32": 0.075
         },
-        "cer": 0.1236,
+        "cer": 0.0792,
         "confusions": {
-          "O->0": 11,
-          "l->1": 11,
-          "0->O": 10,
-          "I->1": 8,
-          "other": 4,
-          "l->I": 3,
-          "5->S": 1,
-          "|->l": 1
+          "other": 12,
+          "l->1": 8,
+          "O->0": 6,
+          "I->1": 5,
+          "0->O": 4,
+          "I->l": 1
         }
       },
       "FRAG 15": {
         "cer_by_px": {
-          "20": 0.1542,
-          "24": 0.1292,
-          "32": 0.1083
+          "20": 0.0833,
+          "24": 0.0708,
+          "32": 0.0792
         },
-        "cer": 0.1306,
+        "cer": 0.0778,
         "confusions": {
-          "l->1": 16,
-          "O->0": 12,
-          "0->O": 11,
-          "I->1": 10,
-          "other": 6,
-          "l->I": 3,
-          "|->1": 1,
-          "1->l": 1
+          "other": 9,
+          "l->1": 7,
+          "O->0": 6,
+          "I->1": 4,
+          "0->O": 3,
+          "I->l": 1
         }
       }
     }
@@ -99,17 +119,19 @@
     "lookalikes": {
       "static": {
         "cer_by_px": {
-          "20": 0.0833,
-          "24": 0.0667,
-          "32": 0.075
+          "20": 0.0917,
+          "24": 0.0875,
+          "32": 0.0833
         },
-        "cer": 0.075,
+        "cer": 0.0875,
         "confusions": {
           "0->O": 19,
-          "O->0": 12,
-          "l->1": 8,
-          "I->1": 4,
+          "O->0": 9,
+          "l->1": 6,
+          "q->g": 3,
+          "I->1": 3,
           "1->l": 1,
+          "I->l": 1,
           "other": 1
         }
       }
@@ -117,51 +139,79 @@
   },
   "gate": {
     "margin": 0.02,
-    "lookalike_margin": 0.06,
+    "lookalike_margin": 0.0,
     "frag15_margin": 0.02,
     "reference_paragraph_cer": 0.0046,
-    "reference_lookalike_cer": 0.075,
+    "reference_lookalike_cer": 0.0875,
     "checks": [
       {
         "frag": 0,
         "test": "paragraph",
-        "cer": 0.0023,
+        "cer": 0.0034,
         "limit": 0.0246,
         "pass": true
       },
       {
         "frag": 0,
         "test": "lookalikes",
-        "cer": 0.1236,
-        "limit": 0.135,
+        "cer": 0.0708,
+        "limit": 0.0875,
         "pass": true
       },
       {
-        "frag": 15,
+        "frag": 8,
         "test": "paragraph",
         "cer": 0.0011,
         "limit": 0.0246,
         "pass": true
       },
       {
-        "frag": 15,
+        "frag": 8,
         "test": "lookalikes",
-        "cer": 0.1306,
-        "limit": 0.135,
+        "cer": 0.0792,
+        "limit": 0.0875,
+        "pass": true
+      },
+      {
+        "frag": 15,
+        "test": "paragraph",
+        "cer": 0.0023,
+        "limit": 0.0246,
         "pass": true
       },
       {
         "frag": 15,
+        "test": "lookalikes",
+        "cer": 0.0778,
+        "limit": 0.0875,
+        "pass": true
+      },
+      {
+        "frag": 8,
         "test": "paragraph vs FRAG 0",
         "cer": 0.0011,
-        "limit": 0.0223,
+        "limit": 0.0234,
+        "pass": true
+      },
+      {
+        "frag": 8,
+        "test": "lookalikes vs FRAG 0",
+        "cer": 0.0792,
+        "limit": 0.0908,
+        "pass": true
+      },
+      {
+        "frag": 15,
+        "test": "paragraph vs FRAG 0",
+        "cer": 0.0023,
+        "limit": 0.0234,
         "pass": true
       },
       {
         "frag": 15,
         "test": "lookalikes vs FRAG 0",
-        "cer": 0.1306,
-        "limit": 0.1436,
+        "cer": 0.0778,
+        "limit": 0.0908,
         "pass": true
       }
     ],
diff --git a/proofs/weft/weft-accents.png b/proofs/weft/weft-accents.png
new file mode 100644
index 0000000..6fcd108
Binary files /dev/null and b/proofs/weft/weft-accents.png differ
diff --git a/proofs/weft/weft-before-after-black.png b/proofs/weft/weft-before-after-black.png
new file mode 100644
index 0000000..7a092b3
Binary files /dev/null and b/proofs/weft/weft-before-after-black.png differ
diff --git a/proofs/weft/weft-before-after-lookalikes.png b/proofs/weft/weft-before-after-lookalikes.png
new file mode 100644
index 0000000..7f207f6
Binary files /dev/null and b/proofs/weft/weft-before-after-lookalikes.png differ
diff --git a/proofs/weft/weft-body-text.png b/proofs/weft/weft-body-text.png
index f8dc06b..1da06f7 100644
Binary files a/proofs/weft/weft-body-text.png and b/proofs/weft/weft-body-text.png differ
diff --git a/proofs/weft/weft-charset.png b/proofs/weft/weft-charset.png
index 976f09e..e9dd4a9 100644
Binary files a/proofs/weft/weft-charset.png and b/proofs/weft/weft-charset.png differ
diff --git a/proofs/weft/weft-code.png b/proofs/weft/weft-code.png
new file mode 100644
index 0000000..91bc01d
Binary files /dev/null and b/proofs/weft/weft-code.png differ
diff --git a/proofs/weft/weft-designspace.png b/proofs/weft/weft-designspace.png
new file mode 100644
index 0000000..a1578b2
Binary files /dev/null and b/proofs/weft/weft-designspace.png differ
diff --git a/proofs/weft/weft-frag-waterfall.png b/proofs/weft/weft-frag-waterfall.png
index 9e54774..1fce9dc 100644
Binary files a/proofs/weft/weft-frag-waterfall.png and b/proofs/weft/weft-frag-waterfall.png differ
diff --git a/proofs/weft/weft-lookalikes.png b/proofs/weft/weft-lookalikes.png
index 4cc2dc3..8e79ee0 100644
Binary files a/proofs/weft/weft-lookalikes.png and b/proofs/weft/weft-lookalikes.png differ
diff --git a/proofs/weft/weft-sketch-compare.png b/proofs/weft/weft-sketch-compare.png
new file mode 100644
index 0000000..76ad11a
Binary files /dev/null and b/proofs/weft/weft-sketch-compare.png differ
diff --git a/proofs/weft/weft-weight-waterfall.png b/proofs/weft/weft-weight-waterfall.png
index 46f262d..6e1c46b 100644
Binary files a/proofs/weft/weft-weight-waterfall.png and b/proofs/weft/weft-weight-waterfall.png differ
diff --git a/site/build.py b/site/build.py
index a65e6a7..0b84e41 100644
--- a/site/build.py
+++ b/site/build.py
@@ -48,7 +48,7 @@
 REPO_URL = "https://github.com/machine-made/type"
 ORG_URL = "https://github.com/machine-made"
 RELEASES = {
-    "weft": REPO_URL + "/releases/tag/weft-v0.1.0",
+    "weft": REPO_URL + "/releases/tag/weft-v0.2.0",
     "sans": REPO_URL + "/releases/tag/sans-v0.1.0",
     "heddle": REPO_URL + "/releases/tag/heddle-v0.1.0",
     "warp": REPO_URL + "/releases/tag/warp-v0.1.0",
diff --git a/site/pages/download/index.html b/site/pages/download/index.html
index da30d61..5385c85 100644
--- a/site/pages/download/index.html
+++ b/site/pages/download/index.html
@@ -15,9 +15,9 @@ <h1 id="dl-h">Download and install</h1>
 <section class="wrap band" id="weft" aria-labelledby="dl-weft-h">
   <div class="sec-head">
     <p class="eyebrow">Monospace</p>
-    <h2 id="dl-weft-h" class="weft-title">machine-made Weft 0.1</h2>
+    <h2 id="dl-weft-h" class="weft-title">machine-made Weft 0.2</h2>
   </div>
-  <p><a class="btn" href="{{WEFT_RELEASE}}">Download Weft 0.1 from GitHub</a></p>
+  <p><a class="btn" href="{{WEFT_RELEASE}}">Download Weft 0.2 from GitHub</a></p>
   <h3>On your computer</h3>
   <p>Unzip the release. On macOS, open the TTF files and select Install. On Windows, right-click the files and select Install. On Linux, copy them to <code>~/.local/share/fonts</code> and run <code>fc-cache</code>.</p>
   <h3>On the web</h3>
diff --git a/site/pages/weft/index.html b/site/pages/weft/index.html
index 84f688a..669aba5 100644
--- a/site/pages/weft/index.html
+++ b/site/pages/weft/index.html
@@ -1,6 +1,6 @@
 <!--
 title: machine-made Weft: a grid-built variable monospace
-description: machine-made Weft 0.1. A monospace built from strokes on a 12-unit grid, with a weight axis and a FRAG axis from clean to broken. Free under the SIL Open Font License.
+description: machine-made Weft 0.2. A monospace built from strokes on a 12-unit grid, with a weight axis and a FRAG axis from clean to broken. Free under the SIL Open Font License.
 nav: weft
 class: page-weft
 preload: weft,sans
@@ -164,6 +164,6 @@ <h3>Agent commits</h3>
 </section>
 
 <section class="wrap band cta" aria-labelledby="get-weft-h">
-  <h2 id="get-weft-h">Get Weft 0.1</h2>
+  <h2 id="get-weft-h">Get Weft 0.2</h2>
   <p><a class="btn" href="{{WEFT_RELEASE}}">Download from GitHub</a> <a class="btn btn-ghost" href="../download/#weft">Install and @font-face</a></p>
 </section>
diff --git a/weft/BRIEF.md b/weft/BRIEF.md
index 2b0a6c2..352f041 100644
--- a/weft/BRIEF.md
+++ b/weft/BRIEF.md
@@ -7,6 +7,11 @@ the axes and the build plan. Source of all shapes: the approved sketch 0.1
 > Update for Weft 0.1 (phase 2): the build plan below is done up to
 > phase 4. The width axis and the Thread style are not in 0.1. See
 > `STATUS.md`, `CHANGELOG.md` and `RELEASE-NOTES-0.1.md`.
+>
+> Update for Weft 0.2: l, I, 1, 0 and q changed for code look-alikes,
+> and the set grew to Latin Extended-A, combining marks, box drawing
+> and arrows. See `STATUS.md` (deviations from the sketch) and
+> `RELEASE-NOTES-0.2.md`.
 
 ## Name check: "Weft"
 
diff --git a/weft/CHANGELOG.md b/weft/CHANGELOG.md
index c24dc3e..617652e 100644
--- a/weft/CHANGELOG.md
+++ b/weft/CHANGELOG.md
@@ -3,6 +3,57 @@
 Notes for the integration session. The root `CHANGELOG.md` is not
 changed by the Weft sessions.
 
+## 0.200 (Weft 0.2)
+
+### Changed
+
+- Look-alikes for code. l: the stem moves to x 3 and the tail is
+  longer. I: serifs 6 units wide (were 4). 1: a longer flag and a wider
+  base. 0: a longer slash. q: a spur at the foot. The OCR look-alike
+  CER is now 0.071 / 0.079 / 0.078 at FRAG 0 / 8 / 15, against 0.0875
+  for DejaVu Sans Mono (Weft 0.1: 0.121 / 0.128 / 0.122, same test).
+- Accents above the base grow with weight (scale 1.25 at Black) and
+  sit further from the base at heavy weights (gap 0.95 units at Black,
+  was 0.5 / 0.6). Ring counters stay open at Black.
+- « » are two ‹ › components, and " “ ” „ two single quotes. They
+  move apart at heavy weights (Weft 0.1 was too tight at Black; the
+  double quotes merged).
+- Component offsets can depend on the stroke width (piecewise linear
+  between the master widths, so the variable font and the statics
+  agree).
+- OS/2 Unicode ranges and code pages come from the character set
+  (code pages: Latin 1, Latin 2, Turkish, Baltic).
+- win ascent / descent 1250 / 403 (were 1167 / 339): the new accents at
+  Black with FRAG 100 drift, and the comma below at Black. Typo and
+  hhea metrics do not change.
+
+### Added
+
+- Latin Extended-A (U+0100 to U+017F, all 128), Ș ș Ț ț, ẞ, Ǿ ǿ, and
+  Ǎ ǎ Ǔ ǔ Ẽ ẽ. New marks: caron, vertical caron (ď ľ ť Ľ), breve, dot
+  above, double acute, ogonek, comma below, turned comma above, capital
+  macron.
+- 14 combining marks (U+0300 to U+0328) with no advance, a mark feature
+  (anchors on A-Z, a-z, ı, ȷ) and GDEF classes. ccmp: i and j lose
+  their dot under a mark above.
+- ‹ › ‚ „ − and the spacing accents ˆ ˇ ˘ ˙ ˚ ˛ ˜ ˝.
+- Box drawing ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼: lines end on the cell edges (new
+  "butt" stroke kind without caps), so they join across cells and
+  lines at the typo line height. Arrows ← → ↑ ↓.
+- ss01: dotted zero.
+- The static TTFs are hinted with ttfautohint (ttfautohint-py 0.6.1,
+  pinned; `tools/finish.py --hint`). The build stays byte-identical.
+- OCR gate: FRAG 8 is gated too, q is in the look-alike set, and the
+  look-alike margin is 0 (was 0.06): Weft must not read worse than
+  DejaVu Sans Mono.
+- Tests: language coverage (Central European, Baltic, Turkish,
+  Romanian, Maltese, Esperanto), marks do not touch their base,
+  cedilla and ogonek attach, box drawing ends on the cell edges,
+  look-alike pairs differ, offsets are piecewise linear, combining
+  marks. 1749 tests.
+- Proofs: accents, code (box drawing, arrows, symbols), designspace
+  grid, sketch comparison, before/after for look-alikes and wght 900.
+
 ## 0.100 (Weft 0.1, phase 2)
 
 ### Added
diff --git a/weft/RELEASE-NOTES-0.2.md b/weft/RELEASE-NOTES-0.2.md
new file mode 100644
index 0000000..5ce065c
--- /dev/null
+++ b/weft/RELEASE-NOTES-0.2.md
@@ -0,0 +1,34 @@
+# machine-made Weft 0.2
+
+Weft is a grid-built monospace by machine-made, with a weight axis
+(`wght` 100 to 900) and a fragmentation axis (`FRAG` 0 to 100).
+
+## What is new
+
+- **Code look-alikes.** l, I, 1, 0 and q are drawn so they do not read as
+  each other. In the OCR test Weft now reads look-alike strings better
+  than DejaVu Sans Mono (character error rate 0.071 against 0.0875 at
+  FRAG 0; Weft 0.1: 0.121). A dotted zero is in `ss01`.
+- **Central European languages.** All of Latin Extended-A, Romanian Ș ș
+  Ț ț, ẞ, and 14 combining marks with mark positioning. Polish, Czech,
+  Slovak, Hungarian, Romanian, Turkish, Croatian, Slovenian, Latvian,
+  Lithuanian, Estonian, Maltese and Esperanto are covered.
+- **Heavy weights.** Accents on capitals and lowercase have more room at
+  Black, and « » " “ ” „ no longer close up.
+- **For code.** Box drawing (─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼) that joins across
+  cells and lines, arrows (← → ↑ ↓), the minus sign, ‹ › ‚ „.
+- **Hinting.** The static TTFs are hinted with ttfautohint.
+
+Every glyph keeps the 750-unit advance (combining marks have none).
+The line metrics (typo and hhea 906 / -281 / 0) do not change.
+
+## Files
+
+- `MachineMadeWeft[FRAG,wght].ttf`: the variable font.
+- `ttf/`, `otf/`: nine static weights at FRAG 0 (Thin to Black).
+- `webfonts/`: WOFF2 of the variable font, Regular and Bold.
+- `readability.json`: the OCR report.
+
+## Licence
+
+SIL Open Font License 1.1, with Reserved Font Name "machine-made".
diff --git a/weft/STATUS.md b/weft/STATUS.md
index cfe17aa..100df19 100644
--- a/weft/STATUS.md
+++ b/weft/STATUS.md
@@ -1,49 +1,98 @@
 # Weft status
 
-Notes for the integration session. The root `STATUS.md` is not changed
-by the Weft sessions.
+Notes for the integration session. The root `STATUS.md` has one line
+about Weft; the details are here.
 
 | Field | Value |
 | --- | --- |
 | Family | machine-made Weft |
-| Version | 0.1 (font version 0.100) |
-| Branch | `weft/phase-2` |
-| Stage | Weft 0.1 built: variable font (wght, FRAG), 9 statics, WOFF2 |
-| Gate now | Jac reviews the branch; founder reviews the proofs by eye |
-| Next | Release 0.1 (Jac). Then: polish, width axis, Thread style |
-| Last local run | 2026-10-26: tests, build, interpolation, Fontspector, OCR gate all green |
-| Last green CI | none yet (first run is on the PR) |
+| Version | 0.2 (font version 0.200) |
+| Branch | `weft/v0.2` |
+| Stage | Weft 0.2 built: look-alikes, Latin Extended-A, combining marks, box drawing, arrows, hinted statics |
+| Gate now | Founder reviews the proofs by eye; then PR, merge, release `weft-v0.2.0` |
+| Next | Width axis, Thread style, small caps |
+| Last local run | 2026-10-28: tests, build, byte-identical rebuild, interpolation, Fontspector, OCR gate, site build all green |
+| Last green CI | `weft.yml` runs on pull requests and on main only; no run on the branch yet |
 
-## Proven (local run, 2026-10-26)
+## Proven (local run, 2026-10-28)
 
-- 948 pytest tests pass.
+- 1749 pytest tests pass.
+- Two builds give the same bytes (hinted static TTFs included).
 - `fonttools varLib.interpolatable`: no problems on the designspace, on
   the 12 master UFOs and on the compiled variable font.
 - Fontspector 1.9.0, universal profile: 0 FAIL, 0 ERROR on the variable
   font, the 9 static TTF and the 9 static OTF.
 - OCR gate (Tesseract 5.3.4, eng): passes. See `proofs/weft/readability.json`.
-- The build is byte-reproducible.
+
+  | | FRAG 0 | FRAG 8 | FRAG 15 | DejaVu Sans Mono |
+  | --- | --- | --- | --- | --- |
+  | Look-alike CER, Weft 0.1 | 0.121 | 0.128 | 0.122 | 0.0875 |
+  | Look-alike CER, Weft 0.2 | 0.071 | 0.079 | 0.078 | 0.0875 |
+  | Paragraph CER, Weft 0.2 | 0.0034 | 0.0011 | 0.0023 | 0.0046 |
+
+  The look-alike set now has q (g9q), so the numbers differ from the
+  0.1 report (0.124 against 0.075). Both rows above use the 0.2 test.
+  The look-alike margin is 0: Weft must not read worse than DejaVu.
+- shaperglot 1.2.2 (not in CI): every mandatory orthography check
+  passes for Polish, Czech, Slovak, Hungarian, Romanian, Turkish,
+  Croatian, Slovenian, Latvian, Lithuanian, Estonian, Maltese,
+  Esperanto, Bosnian, Albanian, Catalan, Icelandic, German, French,
+  Danish and Norwegian. Only the small-caps checks are skipped (no
+  `smcp`).
+- Sketch comparison (sketch 0.1 renderer against the Regular TTF,
+  `proofs/weft/weft-sketch-compare.png`): coverage IoU 0.940. The
+  differences are the deliberate changes below.
+
+## Deliberate deviations from sketch 0.1
+
+| Glyph | Change | Reason |
+| --- | --- | --- |
+| l | Stem at x 3 (was 3.5), tail (3, 1.6) to (4.6, 0) to (6.4, 0) | OCR read l as 1. A tail to the box edge read as L. |
+| I | Serifs 0.5 to 6.5 (were 1.5 to 5.5) | OCR read I as 1. |
+| 1 | Flag from (0.5, 8.2), base 0.8 to 6.2 | Longer flag, more distinct from l and I. |
+| 0 | Slash (5, 8) to (2, 3) (was (5, 7.8) to (2, 3.2)) | A narrower zero read no better and closed up at Bold. |
+| q | Foot spur (6.5, -2.5) to (7.5, -3.5) | OCR read q as g (6 of 720 characters). |
+| " | Two ' components that move apart with weight | They merged at Black. |
+| « » | Two ‹ › components that move apart with weight | Too tight at Black. |
+
+Accents above the base are scaled by 1.25 at Black (1.0 up to Regular)
+and the gap to the base grows with weight. This is new in 0.2; the
+sketch has no heavy accents.
 
 ## Fontspector WARNs (accepted)
 
 | Check | Files | Reason |
 | --- | --- | --- |
-| `opentype/monospace` (bad-numberOfHMetrics) | all | fontTools writes 1 hmtx entry for a font where all advances are equal. The spec recommends 3. Harmless. |
-| `contour_count` | VF, some statics | The VF keeps one contour per stroke piece (on purpose). Statics: at heavy weights, "«", "»", "½", '"', "“", "”", "…", "#" merge into one contour. |
-| `typoascender_exceeds_Agrave` | VF, 6 statics | Capital accents reach above the typo ascender (906) from Medium up. Line spacing stays at 19 units on purpose; win metrics cover all ink, so nothing clips. |
+| `opentype/monospace` (bad-numberOfHMetrics) | all | 17 hmtx entries (the zero-width combining marks come first). The spec recommends 3. Harmless. |
+| `contour_count` | VF, some statics | The VF keeps one contour per stroke piece (on purpose). Statics: at heavy weights "½", "#" and "ß" merge or close. |
+| `typoascender_exceeds_Agrave` | VF, 7 statics | Capital accents reach above the typo ascender (906). Line spacing stays at 19 units on purpose; win metrics cover all ink, so nothing clips. |
 | `mandatory_avar_table` | VF | Both axes are linear on purpose. |
+| `alt_caron` (decomposed-outline) | static TTF | The statics are decomposed, so the check cannot see the components. ď ľ ť Ľ use `caronvert.mark`, a vertical stroke, not an apostrophe. |
+
+## Metrics that changed
+
+- win ascent / descent: 1250 / 403 (0.1: 1167 / 339). Bigger accents at
+  Black with FRAG 100 drift, and the comma below at Black.
+- Advance (750), typo and hhea metrics (906 / -281 / 0), x-height
+  (500), cap height (688), underline (-150 / 84) and the axes do not
+  change.
 
-## Open risks
+## Open
 
-- Look-alike OCR: Tesseract confuses Weft's l and I with 1, and O with 0,
-  more than DejaVu Sans Mono (CER about 0.12 against 0.075). The gate
-  margin for this test (0.06) was set after the first run. It stops a
-  regression; it does not prove parity. A slashed or dotted zero and a
-  different l are design questions for later.
-- At wght 900, some accented capitals and the bold `«` `»` are tight.
+- ½ ¼ ¾: the fraction slash touches the small figures from Regular up
+  (one contour in the statics). Needs narrower small figures.
+- "#" merges at Black (as in 0.1).
+- Small caps (`smcp`): not drawn. shaperglot skips its small-caps
+  checks.
+- Combining marks use the lowercase accent shapes, also on capitals
+  (precomposed capitals use the flatter `.case` accents).
 - FRAG 51 to 100 is for titles: pieces drop out and words are not
-  readable (OCR CER 0.41 at FRAG 100). This is by design.
+  readable (OCR CER 0.47 at FRAG 100). This is by design.
 - The drift lock (`loom/drift_lock.json`) must be made again
-  (`python tools/relock.py`) after any change to the strokes or to
-  `loom/pieces.py`. A test checks a sample of glyphs.
+  (`python tools/relock.py`) after any change to the strokes, the
+  accent scale or `loom/pieces.py`. A test checks a sample of glyphs.
+- The machine-made.github.io site still has the Weft 0.1 subset. Its
+  tracking does not need a change (advance unchanged). Running its
+  `fonts.py` on 0.2 gives a 24.6 KB `mm-weft.woff2` (was 23.7 KB) with
+  the new l, I, 1, 0, q and heavier-weight accent spacing.
 - Name: see `BRIEF.md` (near match "Wefts", web search only).
diff --git a/weft/loom/build.py b/weft/loom/build.py
index 1168a9c..e1c99f0 100644
--- a/weft/loom/build.py
+++ b/weft/loom/build.py
@@ -1,4 +1,4 @@
-"""Build the Weft 0.1 sources: variable masters, designspace, static UFOs.
+"""Build the Weft sources: variable masters, designspace, static UFOs.
 
 Usage:
     python -m loom.build [--out build]
@@ -10,8 +10,10 @@
 
 Masters: wght 100, 400, 900 x FRAG 0, 15, 50, 100. Every glyph has the
 same contours and points in all 12 masters (see loom/pieces.py).
-Accented letters are components (base + accent) placed with anchors in
-the masters, and decomposed in the statics.
+Accented letters and the guillemets are components in the masters
+(offsets from extended.parts(), which can depend on the stroke width),
+and are decomposed in the statics. Accents above the base are drawn a
+little larger at heavy weights (extended.ACCENT_SCALE).
 """
 
 from __future__ import annotations
@@ -38,6 +40,9 @@
 from loom import extended as ext
 from loom import glyphs as data
 from loom import pieces
+from fontTools.ttLib.tables.O_S_2f_2 import intersectUnicodeRanges
+from ufo2ft.util import calcCodePageRanges
+
 from loom.outline import clean_contour, path_contours, signed_area
 
 UPM = 1000
@@ -49,7 +54,7 @@
 
 FAMILY = "machine-made Weft"
 PS_FAMILY = "MachineMadeWeft"
-VERSION = (0, 100)  # 0.100: Weft 0.1
+VERSION = (0, 200)  # 0.200: Weft 0.2
 COPYRIGHT = "Copyright 2026 The machine-made Weft Project Authors (https://github.com/machine-made/type)"
 LICENSE_DESCRIPTION = (
     "This Font Software is licensed under the SIL Open Font License, "
@@ -74,10 +79,13 @@
 ]
 FRAG_NAMES = [(0, "Clean"), (15, "Notched"), (50, "Cut"), (100, "Broken")]
 
-# Characters in Weft 0.1. Soft hyphen (U+00AD) is not in the set on
+# Characters in Weft. Soft hyphen (U+00AD) is not in the set on
 # purpose: it is a format character, not a drawn glyph.
-DRAWN = {**data.STROKES, **ext.STROKES_EXT}
-CHARS = sorted(set(DRAWN) | set(ext.COMPOSITES), key=ord)
+# The double quote of the sketch table is a compound in Weft 0.2 (two
+# single quotes, see extended.COMPOUNDS).
+DRAWN = {ch: st for ch, st in {**data.STROKES, **ext.STROKES_EXT}.items()
+         if ch not in ext.COMPOUNDS}
+CHARS = sorted(set(DRAWN) | set(ext.COMPOSITES) | set(ext.COMPOUNDS) | set(ext.COMBINING), key=ord)
 
 
 def u(v: float) -> int:
@@ -89,9 +97,22 @@ def glyph_name(ch: str) -> str:
     return ext.GLYPH_NAMES_EXT.get(ch) or data.glyph_name(ch)
 
 
+def advance(name: str) -> int:
+    """Return the advance of a glyph: 750, or 0 for a combining mark."""
+    return 0 if name in mark_names() else ADVANCE
+
+
+@lru_cache(maxsize=None)
+def mark_names() -> frozenset[str]:
+    return frozenset(glyph_name(ch) for ch in ext.COMBINING)
+
+
 def glyph_order() -> list[str]:
-    names = [".notdef", "space"] + [glyph_name(c) for c in CHARS]
-    return names + sorted(ext.ACCENTS)
+    # The zero-width marks come first, so all glyphs after them share one
+    # advance and hmtx stays short.
+    marks = [glyph_name(c) for c in CHARS if c in ext.COMBINING]
+    names = [".notdef", "space"] + marks + [glyph_name(c) for c in CHARS if c not in ext.COMBINING]
+    return names + sorted(ext.ALTERNATES) + sorted(ext.ACCENTS)
 
 
 def charset() -> str:
@@ -101,7 +122,13 @@ def charset() -> str:
 
 def drawn_names() -> list[str]:
     """Return the names of all glyphs with their own strokes."""
-    return [".notdef"] + [glyph_name(c) for c in sorted(DRAWN, key=ord)] + sorted(ext.ACCENTS)
+    return ([".notdef"] + [glyph_name(c) for c in sorted(DRAWN, key=ord)]
+            + sorted(ext.ALTERNATES) + sorted(ext.ACCENTS))
+
+
+def part_name(part: str) -> str:
+    """Return the glyph name of a component (a char or an accent name)."""
+    return part if part in ext.ACCENTS else glyph_name(part)
 
 
 def strokes_of(name: str):
@@ -109,6 +136,8 @@ def strokes_of(name: str):
         return data.NOTDEF
     if name in ext.ACCENTS:
         return ext.ACCENTS[name]
+    if name in ext.ALTERNATES:
+        return ext.ALTERNATES[name]
     for ch in DRAWN:
         if glyph_name(ch) == name:
             return DRAWN[ch]
@@ -136,6 +165,26 @@ def drift_lock() -> dict[str, int]:
     return json.loads(path.read_text())["attempts"]
 
 
+def contours(name: str, w: float, frag: float) -> list[list[tuple[float, float]]]:
+    """Return the piece contours of a drawn glyph at (w, FRAG), design units.
+
+    An accent that scales with weight is drawn at width w / s and scaled
+    by s about (3.5, 0), so its stroke width stays w. The point structure
+    is the same at every location.
+    """
+    return plan_contours(plan(name), w, frag)
+
+
+def plan_contours(gp: pieces.GlyphPlan, w: float, frag: float) -> list[list[tuple[float, float]]]:
+    """Like contours(), for a plan (interp.problems() calls this)."""
+    name = gp.name
+    s = ext.accent_scale(name, w) if name in ext.ACCENTS else 1.0
+    cs = pieces.glyph_contours(gp, w / s, frag)
+    if s == 1.0:
+        return cs
+    return [[(3.5 + s * (x - 3.5), s * y) for x, y in c] for c in cs]
+
+
 def to_font(p: tuple[float, float]) -> tuple[int, int]:
     return (round((p[0] + BOX) * SCALE), round(p[1] * SCALE))
 
@@ -149,10 +198,6 @@ def draw_piece_contours(glyph, contours) -> None:
         pen.endPath()
 
 
-def _anchor_y(kind: str, w: float, accent: str) -> int:
-    return u(ext.accent_offset(kind, w, accent))
-
-
 def _set_info(font: ufoLib2.Font, wght: float, style: str, *, static: bool) -> None:
     info = font.info
     info.familyName = FAMILY
@@ -189,10 +234,12 @@ def _set_info(font: ufoLib2.Font, wght: float, style: str, *, static: bool) -> N
     # (monospaced, the fourth digit).
     panose_weight = min(11, max(2, round(wght / 100) + 1))
     info.openTypeOS2Panose = [2, 0, panose_weight, 9, 0, 0, 0, 0, 0, 0]
-    # Unicode ranges: 0 Basic Latin, 1 Latin-1 Supplement, 31 General
-    # Punctuation, 33 Currency Symbols. Code page: 0 Latin 1.
-    info.openTypeOS2UnicodeRanges = [0, 1, 31, 33]
-    info.openTypeOS2CodePageRanges = [0]
+    # Unicode ranges and code pages from the character set.
+    cps = {ord(c) for c in charset()}
+    info.openTypeOS2UnicodeRanges = sorted(intersectUnicodeRanges(cps))
+    # Only the Windows ANSI code pages (bits 0 to 31): the box drawing
+    # set is too small to claim the OEM code pages.
+    info.openTypeOS2CodePageRanges = sorted(b for b in calcCodePageRanges(cps) if b < 32)
     info.unitsPerEm = UPM
     info.xHeight = u(data.METRICS["x_height"])
     info.capHeight = u(data.METRICS["cap_height"])
@@ -206,12 +253,37 @@ def _set_info(font: ufoLib2.Font, wght: float, style: str, *, static: bool) -> N
     info.openTypeHheaAscender = asc
     info.openTypeHheaDescender = desc
     info.openTypeHheaLineGap = 0
-    # No feature writers: Weft has no kerning and no mark positioning.
-    font.lib["com.github.googlei18n.ufo2ft.featureWriters"] = []
+    # Feature writers: mark positioning for the combining marks and the
+    # GDEF classes. Weft has no kerning. The other features (ccmp, ss01)
+    # are in extended.FEATURES.
+    font.lib["com.github.googlei18n.ufo2ft.featureWriters"] = FEATURE_WRITERS
+    font.lib["public.openTypeCategories"] = categories()
+    font.features.text = ext.FEATURES
     font.lib["public.glyphOrder"] = glyph_order()
     font.lib["public.postscriptNames"] = {}
 
 
+FEATURE_WRITERS = [{"class": "MarkFeatureWriter"}, {"class": "GdefFeatureWriter"}]
+
+
+def categories() -> dict[str, str]:
+    """Return the GDEF classes: marks and the bases that carry anchors."""
+    cats = {glyph_name(ch): "base" for ch in ext.ANCHOR_BASES}
+    cats.update({name: "mark" for name in mark_names()})
+    return dict(sorted(cats.items()))
+
+
+def add_mark_anchors(font: ufoLib2.Font, w: float) -> None:
+    """Add the mark anchors to the base letters and the combining marks."""
+    for ch in ext.ANCHOR_BASES:
+        g = font[glyph_name(ch)]
+        for name, (x, y) in ext.base_anchors(ch, w).items():
+            g.anchors.append(UfoAnchor(u(x + BOX), u(y), name=name))
+    for ch in ext.COMBINING:
+        name, (x, y) = ext.mark_anchor(ch, w)
+        font[glyph_name(ch)].anchors.append(UfoAnchor(u(x + BOX), u(y), name=f"_{name}"))
+
+
 def build_master(wght: float, frag: float) -> ufoLib2.Font:
     """Return one variable-font master (overlapping pieces, components)."""
     w = data.stroke_width(wght)
@@ -220,40 +292,18 @@ def build_master(wght: float, frag: float) -> ufoLib2.Font:
     _set_info(font, wght, style, static=False)
     for name in glyph_order():
         g = font.newGlyph(name)
-        g.width = ADVANCE
+        g.width = advance(name)
     font["space"].unicodes = [0x20, 0xA0]
     for ch in CHARS:
         font[glyph_name(ch)].unicodes = [ord(ch)]
     for name in drawn_names():
-        draw_piece_contours(font[name], pieces.glyph_contours(plan(name), w, frag))
-    # Anchors on bases and accents. x is the box centre.
-    cx = u(3.5 + BOX)
-    for name in ext.ACCENTS:
-        if name.startswith("cedilla"):
-            font[name].anchors.append(UfoAnchor(cx, 0, name="_bottom"))
-        else:
-            # The lowest ink of the accent, so that base "top" minus this
-            # anchor gives the component offset.
-            a, b = ext.ACCENT_LOW[name]
-            font[name].anchors.append(UfoAnchor(cx, u(a + b * w), name="_top"))
-    bases = {}
-    for ch, (base, accent, kind) in ext.COMPOSITES.items():
-        if base is not None:
-            bases.setdefault(base, set()).add(kind)
-    for base, kinds in bases.items():
-        g = font[glyph_name(base)]
-        for kind in sorted(kinds):
-            if kind == "base":
-                g.anchors.append(UfoAnchor(cx, 0, name="bottom"))
-            else:
-                g.anchors.append(UfoAnchor(cx, u(ext.ACCENT_BASE_TOP[kind] + w / 2 + ext.ACCENT_GAP[kind]), name="top"))
-    # Composites: base at (0, 0), accent at anchor minus accent anchor.
-    for ch, (base, accent, kind) in ext.COMPOSITES.items():
+        draw_piece_contours(font[name], contours(name, w, frag))
+    add_mark_anchors(font, w)
+    # Composites: the parts at their offsets for this stroke width.
+    for ch in list(ext.COMPOSITES) + list(ext.COMPOUNDS) + list(ext.COMBINING):
         g = font[glyph_name(ch)]
-        if base is not None:
-            g.components.append(Component(glyph_name(base)))
-        dy = 0 if kind == "base" else _anchor_y(kind, w, accent)
-        g.components.append(Component(accent, transformation=(1, 0, 0, 1, 0, dy)))
+        for part, dx, dy in ext.parts(ch, w):
+            g.components.append(Component(part_name(part), transformation=(1, 0, 0, 1, u(dx), u(dy))))
     return font
 
 
@@ -314,22 +364,32 @@ def static_contours(name: str, wght: float, frag: float = 0) -> list[list[tuple]
     w = data.stroke_width(wght)
     raw: list[list[tuple]] = []
 
-    def add(plan_name: str, dy_units: float) -> None:
-        for c in pieces.glyph_contours(plan(plan_name), w, frag):
-            raw.append([((x + BOX) * SCALE, (y + dy_units) * SCALE) for x, y in c])
+    def add(plan_name: str, dx: float, dy: float) -> None:
+        # The variable font rounds component offsets to font units. Do
+        # the same, so the statics match the variable font.
+        ox, oy = u(dx) / SCALE, u(dy) / SCALE
+        for c in contours(plan_name, w, frag):
+            raw.append([((x + ox + BOX) * SCALE, (y + oy) * SCALE) for x, y in c])
 
-    comp = next(((b, a, k) for ch, (b, a, k) in ext.COMPOSITES.items()
-                 if glyph_name(ch) == name), None)
-    if comp is None:
-        add(name, 0.0)
+    ch = composite_char(name)
+    if ch is None:
+        add(name, 0.0, 0.0)
     else:
-        base, accent, kind = comp
-        if base is not None:
-            add(glyph_name(base), 0.0)
-        add(accent, ext.accent_offset(kind, w, accent))
+        for part, dx, dy in ext.parts(ch, w):
+            add(part_name(part), dx, dy)
     return _union(raw)
 
 
+@lru_cache(maxsize=None)
+def _composite_names() -> dict[str, str]:
+    return {glyph_name(ch): ch for ch in list(ext.COMPOSITES) + list(ext.COMPOUNDS) + list(ext.COMBINING)}
+
+
+def composite_char(name: str) -> str | None:
+    """Return the char of a composite glyph, or None for a drawn glyph."""
+    return _composite_names().get(name)
+
+
 def draw_contours(glyph, contours) -> None:
     pen = glyph.getPen()
     for c in contours:
@@ -350,12 +410,13 @@ def build_static(wght: float, style: str) -> ufoLib2.Font:
     font.lib["public.glyphOrder"] = order
     for name in order:
         g = font.newGlyph(name)
-        g.width = ADVANCE
+        g.width = advance(name)
         if name != "space":
             draw_contours(g, static_contours(name, wght))
     font["space"].unicodes = [0x20, 0xA0]
     for ch in CHARS:
         font[glyph_name(ch)].unicodes = [ord(ch)]
+    add_mark_anchors(font, data.stroke_width(wght))
     return font
 
 
@@ -403,12 +464,12 @@ def build_designspace(master_dir: Path, masters: dict) -> DesignSpaceDocument:
         inst.postScriptFontName = f"{PS_FAMILY}-{style}"
         inst.location = {"Weight": wv, "Fragmentation": 0}
         doc.addInstance(inst)
-    doc.lib["com.github.googlei18n.ufo2ft.featureWriters"] = []
+    doc.lib["com.github.googlei18n.ufo2ft.featureWriters"] = FEATURE_WRITERS
     return doc
 
 
 def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(description="Build the Weft 0.1 UFO sources.")
+    ap = argparse.ArgumentParser(description="Build the Weft UFO sources.")
     ap.add_argument("--out", default="build")
     ap.add_argument("--no-static", action="store_true", help="Do not write the static UFOs.")
     args = ap.parse_args(argv)
diff --git a/weft/loom/drift_lock.json b/weft/loom/drift_lock.json
index 6344df1..a43fcfd 100644
--- a/weft/loom/drift_lock.json
+++ b/weft/loom/drift_lock.json
@@ -5,6 +5,7 @@
     "E": 1,
     "Eth": 1,
     "a": 5,
+    "arrowright": 1,
     "at": 8,
     "bullet": 18,
     "cent": 1,
@@ -12,8 +13,6 @@
     "f": 1,
     "oslash": 3,
     "paragraph": 3,
-    "quotedblleft": 1,
-    "ring.lc": 1,
     "section": 7,
     "threequarters": 3,
     "uni20B9": 3,
diff --git a/weft/loom/extended.py b/weft/loom/extended.py
index 02a9921..ac3f8e1 100644
--- a/weft/loom/extended.py
+++ b/weft/loom/extended.py
@@ -1,4 +1,4 @@
-"""Weft glyph data for Weft 0.1 beyond sketch 0.1.
+"""Weft glyph data beyond sketch 0.1 (Weft 0.1 and 0.2).
 
 This file holds plain data only, in the same form as loom/glyphs.py:
 centre-line strokes in design units, x in the 7-unit design box, y from
@@ -11,9 +11,14 @@
   symbols and letters that are not accented forms, and the extras
   (Euro, curly quotes, ellipsis, bullet, rupee, dotless i).
 * Accent components (".lc" for lowercase, ".case" for capitals).
-* COMPOSITES: accented letters and spacing accents, built from a base
-  glyph and an accent component. The accent offset depends on the stroke
-  width (see accent_offset), so accents clear the base at every weight.
+* Weft 0.2: Latin Extended-A, S and T with comma below, single
+  guillemets, low quotes, minus, box drawing and arrows.
+* COMPOSITES: accented letters, spacing accents and the guillemets,
+  built from components. A component offset can depend on the stroke
+  width (see parts() and accent_offset()), so marks clear the base at
+  every weight. Offsets are piecewise linear in the stroke width, with
+  breaks at the master widths, so the variable font and the statics
+  agree.
 
 Do not trace, import or copy outlines from other fonts.
 
@@ -153,10 +158,7 @@ def _scale(strokes, k: float, dx: float, dy: float):
         ("open", [(5, 7.4), (3, 7.4), (2.2, 6.6), (2.2, 4.4), (3, 3.6), (5, 3.6)]),
     ],
     'ª': _scale(_A_LC, 0.55, 1.6, 6.2) + [("open", [(1.6, 4.6), (5.4, 4.6)])],
-    '«': [
-        ("open", [(2.6, 7.2), (0, 4.6), (2.6, 2.0)]),
-        ("open", [(7, 7.2), (4.4, 4.6), (7, 2.0)]),
-    ],
+    # « and » are composites of ‹ and › (COMPOUNDS, Weft 0.2).
     '¬': [
         ("open", [(0.8, 6), (6.2, 6), (6.2, 3.2)]),
     ],
@@ -193,10 +195,6 @@ def _scale(strokes, k: float, dx: float, dy: float):
         ("closed", OCT(1.8, 5.2, 6.4, 10.6, 1)),
         ("open", [(1.6, 4.6), (5.4, 4.6)]),
     ],
-    '»': [
-        ("open", [(0, 7.2), (2.6, 4.6), (0, 2.0)]),
-        ("open", [(4.4, 7.2), (7, 4.6), (4.4, 2.0)]),
-    ],
     '¼': _n1(0, 6.4) + [_FRACTION_SLASH] + _n4(4.4, 0),
     '½': _n1(0, 6.4) + [_FRACTION_SLASH] + _n2(4.4, 0),
     '¾': _n3(0, 6.4) + [_FRACTION_SLASH] + _n4(4.4, 0),
@@ -270,14 +268,6 @@ def _scale(strokes, k: float, dx: float, dy: float):
     '‘': [
         ("open", _rot180(_QUOTERIGHT, 3.5, 9.75)),
     ],
-    '”': [
-        ("open", _move(_QUOTERIGHT, -1.2)),
-        ("open", _move(_QUOTERIGHT, 1.2)),
-    ],
-    '“': [
-        ("open", _move(_rot180(_QUOTERIGHT, 3.5, 9.75), -1.2)),
-        ("open", _move(_rot180(_QUOTERIGHT, 3.5, 9.75), 1.2)),
-    ],
     '…': [
         ("dot", [(0.5, 0)]),
         ("dot", [(3.5, 0)]),
@@ -294,72 +284,304 @@ def _scale(strokes, k: float, dx: float, dy: float):
         ("open", [(4.2, 11), (5.6, 9.6), (5.6, 7.4), (4.2, 6), (0.6, 6)]),
         ("open", [(0.6, 6), (6.4, 0)]),
     ],
+    # ---- Weft 0.2: Latin Extended-A letters that are not accented forms ----
+    'Đ': [
+        ("closed", [(0, 0), (0, 11), (4, 11), (7, 8), (7, 3), (4, 0)]),
+        ("open", [(-1.2, 5.5), (2.8, 5.5)]),
+    ],
+    'đ': [
+        ("open", [(6.5, 11.5), (6.5, 0)]),
+        ("open", [(6.5, 8), (2.5, 8), (0.5, 6), (0.5, 2), (2.5, 0), (6.5, 0)]),
+        ("open", [(5.0, 10.0), (8.0, 10.0)]),
+    ],
+    'Ħ': [
+        ("open", [(0, 0), (0, 11)]),
+        ("open", [(7, 0), (7, 11)]),
+        ("open", [(0, 5.8), (7, 5.8)]),
+        ("open", [(-1.0, 8.9), (8.0, 8.9)]),
+    ],
+    'ħ': [
+        ("open", [(0.5, 11.5), (0.5, 0)]),
+        ("open", [(0.5, 8), (4.5, 8), (6.5, 6), (6.5, 0)]),
+        ("open", [(-1.0, 10.3), (2.2, 10.3)]),
+    ],
+    'Ŧ': [
+        ("open", [(0, 11), (7, 11)]),
+        ("open", [(3.5, 11), (3.5, 0)]),
+        ("open", [(1.5, 5.5), (5.5, 5.5)]),
+    ],
+    'ŧ': [
+        ("open", [(2.5, 10.6), (2.5, 2), (4.5, 0), (6.2, 0)]),
+        ("open", [(0.5, 8), (5.8, 8)]),
+        ("open", [(0.8, 5.0), (4.2, 5.0)]),
+    ],
+    'Ł': [
+        ("open", [(0, 11), (0, 0), (7, 0)]),
+        ("open", [(-0.8, 4.3), (2.6, 6.7)]),
+    ],
+    'ł': [
+        ("open", [(1, 11.5), (3, 11.5), (3, 1.6), (4.6, 0), (6.4, 0)]),
+        ("open", [(1.2, 4.8), (4.8, 7.4)]),
+    ],
+    'Ŀ': [
+        ("open", [(0, 11), (0, 0), (7, 0)]),
+        ("dot", [(3.6, 5.5)]),
+    ],
+    'ŀ': [
+        ("open", [(1, 11.5), (3, 11.5), (3, 1.6), (4.6, 0), (6.4, 0)]),
+        ("dot", [(6.0, 6.0)]),
+    ],
+    'ĸ': [
+        ("open", [(0.5, 8), (0.5, 0)]),
+        ("open", [(6.2, 8), (0.5, 3)]),
+        ("open", [(2.7, 4.93), (6.5, 0)]),
+    ],
+    'IJ': [
+        ("open", [(0.3, 11), (0.3, 0)]),
+        ("open", [(3.4, 11), (6.6, 11), (6.6, 2.3), (4.3, 0), (3.6, 0)]),
+    ],
+    'ij': [
+        ("open", [(1, 8), (1, 0)]),
+        ("dot", [(1, 10.6)]),
+        ("open", [(5.5, 8), (5.5, -1.5), (3.5, -3.5), (2.2, -3.5)]),
+        ("dot", [(5.5, 10.6)]),
+    ],
+    'ʼn': [
+        ("open", [(-0.2, 11), (-0.2, 10.5), (-0.9, 9.0)]),
+        ("open", [(2.2, 0), (2.2, 8), (6.2, 8), (8.2, 6), (8.2, 0)]),
+    ],
+    'Ŋ': [
+        ("open", [(0, 0), (0, 11), (4.5, 11), (7, 8.5), (7, -1.5), (5, -3.5), (3.4, -3.5)]),
+    ],
+    'ŋ': [
+        ("open", [(0.5, 0), (0.5, 8), (4.5, 8), (6.5, 6), (6.5, -1.5), (4.5, -3.5), (2.8, -3.5)]),
+    ],
+    'Œ': [
+        ("open", [(3.6, 11), (2.5, 11), (0, 8.5), (0, 2.5), (2.5, 0), (3.6, 0)]),
+        ("open", [(7, 11), (3.6, 11), (3.6, 0), (7, 0)]),
+        ("open", [(3.6, 5.8), (6.4, 5.8)]),
+    ],
+    'œ': [
+        ("closed", OCT(0.3, 3.5, 0, 8, 1.2)),
+        ("open", [(3.5, 4.4), (6.7, 4.4), (6.7, 6.8), (5.5, 8), (4.7, 8), (3.5, 6.8)]),
+        ("open", [(3.5, 1.2), (4.7, 0), (6.6, 0)]),
+    ],
+    'ſ': [
+        ("open", [(6.2, 11.5), (4, 11.5), (2.5, 10), (2.5, 0)]),
+    ],
+    'ȷ': [
+        ("open", [(1.5, 8), (4.5, 8), (4.5, -1.5), (2.5, -3.5), (0.5, -3.5)]),
+    ],
+    'ẞ': [
+        ("open", [(0, 0), (0, 8.5), (2.5, 11), (6.5, 11), (3.4, 6.4), (5, 6.4), (7, 4.4), (7, 2), (5, 0), (2.6, 0)]),
+    ],
+    # ---- Weft 0.2: punctuation and symbols ----
+    '‹': [
+        ("open", [(4.8, 7.2), (2.2, 4.6), (4.8, 2.0)]),
+    ],
+    '›': [
+        ("open", [(2.2, 7.2), (4.8, 4.6), (2.2, 2.0)]),
+    ],
+    '‚': [
+        ("open", [(3.6, 0.5), (3.6, 0), (2.4, -2)]),
+    ],
+    '−': [
+        ("open", [(0.8, 4.6), (6.2, 4.6)]),
+    ],
+    # ---- Weft 0.2: arrows (the shaft stops short of the tip, inside the head) ----
+    '←': [
+        ("open", [(3, 7.6), (0, 4.6), (3, 1.6)]),
+        ("open", [(0.8, 4.6), (7, 4.6)]),
+    ],
+    '→': [
+        ("open", [(4, 7.6), (7, 4.6), (4, 1.6)]),
+        ("open", [(0, 4.6), (6.2, 4.6)]),
+    ],
+    '↑': [
+        ("open", [(0.5, 8), (3.5, 11), (6.5, 8)]),
+        ("open", [(3.5, 0), (3.5, 10.2)]),
+    ],
+    '↓': [
+        ("open", [(0.5, 3), (3.5, 0), (6.5, 3)]),
+        ("open", [(3.5, 11), (3.5, 0.8)]),
+    ],
+}
+
+# ---- Weft 0.2: box drawing. The lines end on the cell edges ("butt"
+# strokes, no caps): x -2.5 and 9.5 (the 12-unit advance), y -4.5 and
+# 14.5 (the typo descender and ascender, one line of 19 units). The
+# horizontal line is at y 5, the middle of the line; the vertical line
+# is at x 3.5, the middle of the cell.
+_BH = ("butt", [(-2.5, 5), (9.5, 5)])
+_BV = ("butt", [(3.5, -4.5), (3.5, 14.5)])
+STROKES_EXT.update({
+    '─': [_BH],
+    '│': [_BV],
+    '┌': [("butt", [(9.5, 5), (3.5, 5), (3.5, -4.5)])],
+    '┐': [("butt", [(-2.5, 5), (3.5, 5), (3.5, -4.5)])],
+    '└': [("butt", [(3.5, 14.5), (3.5, 5), (9.5, 5)])],
+    '┘': [("butt", [(3.5, 14.5), (3.5, 5), (-2.5, 5)])],
+    '├': [_BV, ("butt", [(3.5, 5), (9.5, 5)])],
+    '┤': [_BV, ("butt", [(3.5, 5), (-2.5, 5)])],
+    '┬': [_BH, ("butt", [(3.5, 5), (3.5, -4.5)])],
+    '┴': [_BH, ("butt", [(3.5, 5), (3.5, 14.5)])],
+    '┼': [_BH, _BV],
+})
+
+# Unencoded alternates, reached through OpenType features.
+# ss01: the dotted zero (the default zero is slashed).
+ALTERNATES = {
+    "zero.ss01": [
+        ("closed", OCT(0.6, 6.4, 0, 11, 2.4)),
+        ("dot", [(3.5, 5.5)]),
+    ],
 }
+FEATURES = """languagesystem DFLT dflt;
+languagesystem latn dflt;
+
+@TOP_MARKS = [gravecomb acutecomb uni0302 tildecomb uni0304 uni0306 uni0307 uni0308 uni030A uni030B uni030C];
+
+# i and j lose their dot under a combining mark above.
+feature ccmp {
+    sub i' @TOP_MARKS by dotlessi;
+    sub j' @TOP_MARKS by uni0237;
+} ccmp;
+
+feature ss01 {
+    featureNames {
+        name "Dotted zero";
+    };
+    sub zero by zero.ss01;
+} ss01;
+"""
 
-# Accent components. Each one is drawn with its lowest centre line at
-# y = 0 (the cedilla hangs from the baseline instead). accent_offset()
-# gives the vertical offset in the composite.
+# Accent components. Marks with a lowercase and a capital form end in
+# ".lc" / ".case", the others in ".mark". Each one is drawn with its
+# lowest centre line at y = 0. Marks that hang below the base ("base" kind: cedilla, ogonek)
+# are drawn in place; "caronvert" (the apostrophe-like caron of d, l, t
+# and L) is drawn in place at the top right and moved per glyph.
 ACCENTS = {
     "grave.lc": [("open", [(2.8, 1.4), (4.2, 0)])],
     "acute.lc": [("open", [(2.8, 0), (4.2, 1.4)])],
     "circumflex.lc": [("open", [(1.9, 0), (3.5, 1.4), (5.1, 0)])],
     "tilde.lc": [("open", [(1.2, 0), (2.4, 1.2), (3.0, 1.2), (4.2, 0), (4.6, 0), (5.8, 1.2)])],
     "dieresis.lc": [("dot", [(1.9, 0.3)]), ("dot", [(5.1, 0.3)])],
-    "ring.lc": [("closed", OCT(2.3, 4.7, 0, 2.0, 0.6))],
+    "ring.lc": [("closed", OCT(2.2, 4.8, 0, 2.2, 0.7))],
     "macron.lc": [("open", [(1.6, 0.6), (5.4, 0.6)])],
     "cedilla.lc": [("open", [(3.3, 0.5), (3.3, -0.8), (4.7, -1.7), (4.7, -2.4), (4.0, -3.1), (2.3, -3.1)])],
+    "caron.lc": [("open", [(1.9, 1.4), (3.5, 0), (5.1, 1.4)])],
+    "breve.lc": [("open", [(1.9, 1.4), (2.9, 0), (4.1, 0), (5.1, 1.4)])],
+    "dotaccent.lc": [("dot", [(3.5, 0.3)])],
+    "hungarumlaut.lc": [("open", [(1.6, 0), (2.4, 1.6)]), ("open", [(4.4, 0), (5.2, 1.6)])],
     "grave.case": [("open", [(2.6, 1.0), (4.4, 0)])],
     "acute.case": [("open", [(2.6, 0), (4.4, 1.0)])],
     "circumflex.case": [("open", [(1.8, 0), (3.5, 1.0), (5.2, 0)])],
     "tilde.case": [("open", [(1.2, 0), (2.2, 1.0), (3.0, 1.0), (4.0, 0), (4.8, 0), (5.8, 1.0)])],
     "dieresis.case": [("dot", [(1.9, 0.3)]), ("dot", [(5.1, 0.3)])],
-    "ring.case": [("closed", OCT(2.4, 4.6, 0, 1.8, 0.6))],
+    "ring.case": [("closed", OCT(2.2, 4.8, 0, 2.0, 0.7))],
+    "macron.case": [("open", [(1.4, 0), (5.6, 0)])],
+    "caron.case": [("open", [(1.8, 1.0), (3.5, 0), (5.2, 1.0)])],
+    "breve.case": [("open", [(1.9, 1.0), (2.8, 0), (4.2, 0), (5.1, 1.0)])],
+    "dotaccent.case": [("dot", [(3.5, 0.3)])],
+    "hungarumlaut.case": [("open", [(1.6, 0), (2.4, 1.2)]), ("open", [(4.4, 0), (5.2, 1.2)])],
+    # Marks without a .lc / .case pair.
+    "ogonek.mark": [("open", [(3.5, 0.3), (2.6, -1.0), (2.6, -2.1), (3.3, -2.8), (4.5, -2.8)])],
+    "commabelow.mark": [("open", [(3.6, 0), (3.6, -0.3), (2.8, -1.5)])],
+    "commaturnedabove.mark": [("open", [(3.4, 0), (3.4, 0.4), (4.4, 1.9)])],
+    "caronvert.mark": [("open", [(7, 11.5), (6.8, 10.0)])],
 }
 
-# Gap (design units) between the top of the base ink and the bottom of
-# the accent ink.
-ACCENT_GAP = {"lc": 0.6, "case": 0.5}
-# Top centre line of the base: x-height for lowercase, cap height for
-# capitals.
-ACCENT_BASE_TOP = {"lc": 8.0, "case": 11.0}
+# The stroke widths of the wght masters (100, 400, 900). Offsets and
+# scales below are given at these widths and are linear in between.
+W_MASTERS = (0.6, 1.35, 2.6)
 
 
-def accent_offset(kind: str, width: float, accent: str | None = None) -> float:
-    """Return the y offset (design units) of an accent component.
+def pwl(w: float, values) -> float:
+    """Return a value at stroke width w, piecewise linear between masters.
 
-    The base ink ends at top + w/2. The accent ink starts at offset +
-    low(w), where low(w) is the lowest ink point of the accent (linear in
-    w: square caps of a slanted stroke reach below the centre line). So
-    the offset is top + w/2 + gap - low(w). It is linear in w, so it
-    interpolates.
+    `values` is a number (the same at every width) or one value per
+    master width. Outside the master range the end segments extend.
     """
-    if kind == "base":
-        return 0.0
-    low = ACCENT_LOW.get(accent, (0.0, -0.5))
-    return ACCENT_BASE_TOP[kind] + width / 2 + ACCENT_GAP[kind] - (low[0] + low[1] * width)
+    if isinstance(values, (int, float)):
+        return float(values)
+    (w0, w1, w2), (v0, v1, v2) = W_MASTERS, values
+    if w <= w1:
+        return v0 + (v1 - v0) * (w - w0) / (w1 - w0)
+    return v1 + (v2 - v1) * (w - w1) / (w2 - w1)
+
+
+# Accents above the base grow at heavy weights, so their counters and
+# gaps stay open: scale per master width, about (3.5, 0).
+ACCENT_SCALE = (1.0, 1.0, 1.25)
+# Gap (design units) between the base ink and the mark ink, per master
+# width. Weft 0.1 had 0.6 (lc) and 0.5 (case) at every weight; Black was
+# too tight.
+ACCENT_GAP = {
+    "lc": (0.6, 0.65, 0.95),
+    "case": (0.5, 0.55, 0.95),
+    "asc": (0.5, 0.55, 0.95),
+    "below": (0.4, 0.45, 0.55),
+}
+# Top centre line of the base: x-height, cap height, ascender.
+ACCENT_BASE_TOP = {"lc": 8.0, "case": 11.0, "asc": 11.5}
+
+
+def is_scaled(accent: str) -> bool:
+    """True for the accents that scale with weight (marks above)."""
+    return accent.endswith((".lc", ".case")) and not accent.startswith("cedilla")
+
 
+def accent_scale(accent: str, w: float) -> float:
+    return pwl(w, ACCENT_SCALE) if is_scaled(accent) else 1.0
 
-def _accent_low(strokes) -> tuple[float, float]:
-    """Return (a, b) with lowest ink y = a + b * w (exact for straight strokes)."""
+
+def _ink_line(strokes, pick) -> tuple[float, float]:
+    """Return (a, b) with pick(ink y) = a + b * w (exact for straight strokes)."""
     from loom.outline import stroke_polygons  # local import: data module stays light
 
-    def low(w: float) -> float:
-        return min(y for kind, pts in strokes for poly in stroke_polygons(kind, pts, w, 2.4)
-                   for _, y in poly)
-    l1, l2 = low(1.0), low(2.0)
+    def ink(w: float) -> float:
+        return pick(y for kind, pts in strokes for poly in stroke_polygons(kind, pts, w, 2.4)
+                    for _, y in poly)
+    l1, l2 = ink(1.0), ink(2.0)
     return (2 * l1 - l2, l2 - l1)
 
 
-ACCENT_LOW = {name: _accent_low(st) for name, st in ACCENTS.items()}
+ACCENT_LOW = {name: _ink_line(st, min) for name, st in ACCENTS.items()}
+ACCENT_HIGH = {name: _ink_line(st, max) for name, st in ACCENTS.items()}
 
 
-_ACCENT_WORDS = {
-    "GRAVE": "grave", "ACUTE": "acute", "CIRCUMFLEX": "circumflex",
-    "TILDE": "tilde", "DIAERESIS": "dieresis", "RING ABOVE": "ring",
-    "CEDILLA": "cedilla",
-}
+def accent_low(accent: str, w: float) -> float:
+    """Return the lowest ink y of an accent as drawn at width w (scaled).
+
+    The accent is drawn at width w / s and scaled by s about y = 0, so
+    its stroke width is w: low = s * (a + b * w / s) = s * a + b * w.
+    """
+    a, b = ACCENT_LOW[accent]
+    return accent_scale(accent, w) * a + b * w
+
 
-# Accented letters: char -> (base char, accent word).
+def accent_offset(kind: str, width: float, accent: str | None = None) -> float:
+    """Return the y offset (design units) of a mark component.
+
+    Above ("lc", "case", "asc"): the base ink ends at top + w/2, the mark
+    ink starts gap(w) higher. Below ("below"): the base ink ends at -w/2,
+    the top of the mark ink is gap(w) lower. "base" and "abs" marks are
+    drawn in place (offset 0).
+    """
+    if kind in ("base", "abs", "comp"):
+        return 0.0
+    gap = pwl(width, ACCENT_GAP[kind])
+    if kind == "below":
+        a, b = ACCENT_HIGH[accent]
+        return -width / 2 - gap - (a + b * width)
+    return ACCENT_BASE_TOP[kind] + width / 2 + gap - accent_low(accent, width)
+
+
+# Accented letters: char -> (base char, accent, kind, dx, base dx). The
+# accent is a name in ACCENTS, or a word that becomes "<word>.lc" /
+# "<word>.case". kind None picks "case" for capitals and "lc" otherwise.
+# dx moves the mark and base dx the base (a number, or one value per
+# master width).
 _ACCENTED = {
     'À': ('A', 'grave'), 'Á': ('A', 'acute'), 'Â': ('A', 'circumflex'), 'Ã': ('A', 'tilde'),
     'Ä': ('A', 'dieresis'), 'Å': ('A', 'ring'), 'Ç': ('C', 'cedilla'),
@@ -379,29 +601,218 @@ def low(w: float) -> float:
     'ö': ('o', 'dieresis'),
     'ù': ('u', 'grave'), 'ú': ('u', 'acute'), 'û': ('u', 'circumflex'), 'ü': ('u', 'dieresis'),
     'ý': ('y', 'acute'), 'ÿ': ('y', 'dieresis'),
+    # ---- Weft 0.2: Latin Extended-A ----
+    'Ā': ('A', 'macron'), 'ā': ('a', 'macron'),
+    'Ă': ('A', 'breve'), 'ă': ('a', 'breve'),
+    'Ą': ('A', 'ogonek', 'base', 3.1), 'ą': ('a', 'ogonek', 'base', 2.8),
+    'Ć': ('C', 'acute'), 'ć': ('c', 'acute'),
+    'Ĉ': ('C', 'circumflex'), 'ĉ': ('c', 'circumflex'),
+    'Ċ': ('C', 'dotaccent'), 'ċ': ('c', 'dotaccent'),
+    'Č': ('C', 'caron'), 'č': ('c', 'caron'),
+    'Ď': ('D', 'caron'), 'ď': ('d', 'caronvert', 'abs', (0.95, 1.6, 1.05), (0.0, -0.2, -2.0)),
+    'Ē': ('E', 'macron'), 'ē': ('e', 'macron'),
+    'Ĕ': ('E', 'breve'), 'ĕ': ('e', 'breve'),
+    'Ė': ('E', 'dotaccent'), 'ė': ('e', 'dotaccent'),
+    'Ę': ('E', 'ogonek', 'base', 2.0), 'ę': ('e', 'ogonek', 'base', 1.4),
+    'Ě': ('E', 'caron'), 'ě': ('e', 'caron'),
+    'Ĝ': ('G', 'circumflex'), 'ĝ': ('g', 'circumflex'),
+    'Ğ': ('G', 'breve'), 'ğ': ('g', 'breve'),
+    'Ġ': ('G', 'dotaccent'), 'ġ': ('g', 'dotaccent'),
+    'Ģ': ('G', 'commabelow', 'below'), 'ģ': ('g', 'commaturnedabove', 'lc'),
+    'Ĥ': ('H', 'circumflex'), 'ĥ': ('h', 'circumflex.case', 'asc', -2.0),
+    'Ĩ': ('I', 'tilde'), 'ĩ': ('ı', 'tilde'),
+    'Ī': ('I', 'macron'), 'ī': ('ı', 'macron'),
+    'Ĭ': ('I', 'breve'), 'ĭ': ('ı', 'breve'),
+    'Į': ('I', 'ogonek', 'base', 1.1), 'į': ('i', 'ogonek', 'base', 1.0),
+    'İ': ('I', 'dotaccent'),
+    'Ĵ': ('J', 'circumflex', None, 1.0), 'ĵ': ('ȷ', 'circumflex', None, 1.0),
+    'Ķ': ('K', 'commabelow', 'below'), 'ķ': ('k', 'commabelow', 'below'),
+    'Ĺ': ('L', 'acute', None, -2.0), 'ĺ': ('l', 'acute.case', 'asc', -0.5),
+    'Ļ': ('L', 'commabelow', 'below'), 'ļ': ('l', 'commabelow', 'below', 2.0),
+    'Ľ': ('L', 'caronvert', 'abs', (-5.55, -4.7, -3.1)), 'ľ': ('l', 'caronvert', 'abs', (-2.55, -1.7, -0.1)),
+    'Ń': ('N', 'acute'), 'ń': ('n', 'acute'),
+    'Ņ': ('N', 'commabelow', 'below'), 'ņ': ('n', 'commabelow', 'below'),
+    'Ň': ('N', 'caron'), 'ň': ('n', 'caron'),
+    'Ō': ('O', 'macron'), 'ō': ('o', 'macron'),
+    'Ŏ': ('O', 'breve'), 'ŏ': ('o', 'breve'),
+    'Ő': ('O', 'hungarumlaut'), 'ő': ('o', 'hungarumlaut'),
+    'Ŕ': ('R', 'acute'), 'ŕ': ('r', 'acute'),
+    'Ŗ': ('R', 'commabelow', 'below'), 'ŗ': ('r', 'commabelow', 'below', -3.0),
+    'Ř': ('R', 'caron'), 'ř': ('r', 'caron'),
+    'Ś': ('S', 'acute'), 'ś': ('s', 'acute'),
+    'Ŝ': ('S', 'circumflex'), 'ŝ': ('s', 'circumflex'),
+    'Ş': ('S', 'cedilla'), 'ş': ('s', 'cedilla'),
+    'Š': ('S', 'caron'), 'š': ('s', 'caron'),
+    'Ţ': ('T', 'cedilla'), 'ţ': ('t', 'cedilla', None, 0.6),
+    'Ť': ('T', 'caron'), 'ť': ('t', 'caronvert', 'abs', (-3.05, -2.2, -0.6)),
+    'Ũ': ('U', 'tilde'), 'ũ': ('u', 'tilde'),
+    'Ū': ('U', 'macron'), 'ū': ('u', 'macron'),
+    'Ŭ': ('U', 'breve'), 'ŭ': ('u', 'breve'),
+    'Ů': ('U', 'ring'), 'ů': ('u', 'ring'),
+    'Ű': ('U', 'hungarumlaut'), 'ű': ('u', 'hungarumlaut'),
+    'Ų': ('U', 'ogonek', 'base', 1.0), 'ų': ('u', 'ogonek', 'base', 2.6),
+    'Ŵ': ('W', 'circumflex'), 'ŵ': ('w', 'circumflex'),
+    'Ŷ': ('Y', 'circumflex'), 'ŷ': ('y', 'circumflex'),
+    'Ÿ': ('Y', 'dieresis'),
+    'Ź': ('Z', 'acute'), 'ź': ('z', 'acute'),
+    'Ż': ('Z', 'dotaccent'), 'ż': ('z', 'dotaccent'),
+    'Ž': ('Z', 'caron'), 'ž': ('z', 'caron'),
+    'Ǿ': ('Ø', 'acute'), 'ǿ': ('ø', 'acute'),
+    # Auxiliary letters (shaperglot: Lithuanian, French, Norwegian).
+    'Ǎ': ('A', 'caron'), 'ǎ': ('a', 'caron'), 'Ǔ': ('U', 'caron'), 'ǔ': ('u', 'caron'),
+    'Ẽ': ('E', 'tilde'), 'ẽ': ('e', 'tilde'),
+    # ---- Weft 0.2: Romanian comma below ----
+    'Ș': ('S', 'commabelow', 'below'), 'ș': ('s', 'commabelow', 'below'),
+    'Ț': ('T', 'commabelow', 'below'), 'ț': ('t', 'commabelow', 'below', 0.4),
 }
 
+# The offsets of the vertical caron (ď ľ ť Ľ) give a gap of 0.6, 0.65 and
+# 0.95 units to the stem at the three master widths (0.6 for ď at Black,
+# where d also moves left, so the caron stays inside the cell).
+# The caron of t sits above the cross bar: it moves up at heavy weights.
+ABS_DY = {'ť': (0.0, 0.4, 1.7)}
+
+# Guillemets and double quotes: two copies of the single form. They move
+# apart at heavy weights so the space between them stays open (in Weft
+# 0.1 the guillemets were too tight at Black and the double quotes
+# merged). At Regular they are where Weft 0.1 drew them.
+GUILLEMET_DX = (2.0, 2.2, 2.55)
+QUOTE_DX = (1.2, 1.2, 1.75)
+_COMPOUND = {
+    '«': ('‹', GUILLEMET_DX),
+    '»': ('›', GUILLEMET_DX),
+    '"': ("'", QUOTE_DX),
+    '“': ('‘', QUOTE_DX),
+    '”': ('’', QUOTE_DX),
+    '„': ('‚', QUOTE_DX),
+}
+
+# Spacing accents: char -> accent. They sit at the lowercase accent
+# height (the cedilla and the ogonek hang from the baseline).
+_SPACING = {
+    '`': "grave.lc", '´': "acute.lc", '¨': "dieresis.lc", '¯': "macron.lc", '¸': "cedilla.lc",
+    'ˆ': "circumflex.lc", 'ˇ': "caron.lc", '˘': "breve.lc", '˙': "dotaccent.lc",
+    '˚': "ring.lc", '˛': "ogonek.mark", '˜': "tilde.lc", '˝': "hungarumlaut.lc",
+}
+
+
+def _resolve(base: str, accent: str, kind: str | None) -> tuple[str, str]:
+    if kind is None:
+        kind = "base" if accent == "cedilla" else ("case" if base.isupper() else "lc")
+    if accent in ACCENTS:
+        return accent, kind
+    if f"{accent}.mark" in ACCENTS:
+        return f"{accent}.mark", kind
+    if kind == "base":
+        return f"{accent}.lc", kind
+    return f"{accent}.{'case' if kind in ('case', 'asc') else 'lc'}", kind
+
 
 def _composites():
     comps = {}
-    for ch, (base, accent) in _ACCENTED.items():
-        if accent == "cedilla":
-            comps[ch] = (base, f"{accent}.lc", "base")
-        elif base.isupper():
-            comps[ch] = (base, f"{accent}.case", "case")
-        else:
-            comps[ch] = (base, f"{accent}.lc", "lc")
-    # Spacing accents: an empty base (None) and the lowercase accent.
-    comps['`'] = (None, "grave.lc", "lc")
-    comps['´'] = (None, "acute.lc", "lc")
-    comps['¨'] = (None, "dieresis.lc", "lc")
-    comps['¯'] = (None, "macron.lc", "lc")
-    comps['¸'] = (None, "cedilla.lc", "base")
+    for ch, spec in _ACCENTED.items():
+        base, word = spec[0], spec[1]
+        kind = spec[2] if len(spec) > 2 else None
+        dx = spec[3] if len(spec) > 3 else 0.0
+        accent, kind = _resolve(base, word, kind)
+        comps[ch] = (base, accent, kind, dx)
+        if len(spec) > 4:
+            BASE_DX[ch] = spec[4]
+    for ch, accent in _SPACING.items():
+        kind = "base" if accent in ("cedilla.lc", "ogonek.mark") else "lc"
+        comps[ch] = (None, accent, kind, 0.0)
     return comps
 
 
-# char -> (base char or None, accent component name, offset kind)
+BASE_DX: dict = {}
+# char -> (base char or None, accent name, offset kind, dx spec)
 COMPOSITES = _composites()
+# char -> (single form, dx spec) for the guillemets and double quotes.
+COMPOUNDS = dict(_COMPOUND)
+
+
+# Combining marks (Weft 0.2): char -> (accent, anchor name). They have
+# no advance and sit over the previous cell (dx -12 units), at the
+# lowercase accent height. The mark feature moves them to the anchor of
+# the base (see base_anchors), so they also work on capitals.
+COMBINING = {
+    '\u0300': ("grave.lc", "top"), '\u0301': ("acute.lc", "top"),
+    '\u0302': ("circumflex.lc", "top"), '\u0303': ("tilde.lc", "top"),
+    '\u0304': ("macron.lc", "top"), '\u0306': ("breve.lc", "top"),
+    '\u0307': ("dotaccent.lc", "top"), '\u0308': ("dieresis.lc", "top"),
+    '\u030A': ("ring.lc", "top"), '\u030B': ("hungarumlaut.lc", "top"),
+    '\u030C': ("caron.lc", "top"), '\u0326': ("commabelow.mark", "bottom"),
+    '\u0327': ("cedilla.lc", "cedilla"), '\u0328': ("ogonek.mark", "ogonek"),
+}
+CELL = 12.0  # the advance in design units
+
+# Letters with an ascender: marks above go over the ascender.
+_ASCENDERS = set("bdhklt")
+# Letters that carry the mark anchors.
+ANCHOR_BASES = [chr(c) for c in range(0x41, 0x5B)] + [chr(c) for c in range(0x61, 0x7B)] + ['ı', 'ȷ']
+
+
+def _top_kind(ch: str) -> str:
+    if ch.isupper():
+        return "case"
+    return "asc" if ch in _ASCENDERS else "lc"
+
+
+def mark_anchor_y(anchor: str, w: float, kind: str = "lc") -> float:
+    """Return the y (design units) of a mark anchor at stroke width w."""
+    if anchor == "top":
+        return ACCENT_BASE_TOP[kind] + w / 2 + pwl(w, ACCENT_GAP[kind])
+    if anchor == "bottom":
+        return -w / 2 - pwl(w, ACCENT_GAP["below"])
+    return 0.0  # cedilla, ogonek: they hang from the baseline
+
+
+def base_anchors(ch: str, w: float) -> dict[str, tuple[float, float]]:
+    """Return {anchor: (x, y)} in design units (box x) for a base letter."""
+    out = {"top": (3.5, mark_anchor_y("top", w, _top_kind(ch))),
+           "bottom": (3.5, mark_anchor_y("bottom", w))}
+    # Cedilla and ogonek: where the precomposed letters put them.
+    for mark, name in (("cedilla.lc", "cedilla"), ("ogonek.mark", "ogonek")):
+        for comp, (base, accent, kind, dx) in COMPOSITES.items():
+            if base == ch and accent == mark:
+                out[name] = (3.5 + pwl(w, dx), 0.0)
+                break
+        else:
+            if name == "cedilla":
+                out[name] = (3.5, 0.0)
+    return out
+
+
+def mark_anchor(ch: str, w: float) -> tuple[str, tuple[float, float]]:
+    """Return (anchor name, (x, y)) of a combining mark, in its own cell."""
+    accent, anchor = COMBINING[ch]
+    return anchor, (3.5 - CELL, mark_anchor_y(anchor, w))
+
+
+def parts(ch: str, w: float) -> list[tuple[str, float, float]]:
+    """Return the components of a composite at stroke width w.
+
+    Each part is (char or accent name, dx, dy) in design units. A char
+    names a drawn glyph (or ı, ȷ); an accent name is a key of ACCENTS.
+    """
+    if ch in COMBINING:
+        accent, anchor = COMBINING[ch]
+        kind = {"top": "lc", "bottom": "below"}.get(anchor, "base")
+        return [(accent, -CELL, accent_offset(kind, w, accent))]
+    if ch in COMPOUNDS:
+        single, dx = COMPOUNDS[ch]
+        d = pwl(w, dx)
+        return [(single, -d, 0.0), (single, d, 0.0)]
+    base, accent, kind, dx = COMPOSITES[ch]
+    out = []
+    if base is not None:
+        out.append((base, pwl(w, BASE_DX.get(ch, 0.0)), 0.0))
+    dy = accent_offset(kind, w, accent)
+    if kind == "abs":
+        dy += pwl(w, ABS_DY.get(ch, 0.0))
+    out.append((accent, pwl(w, dx), dy))
+    return out
+
 
 # Production glyph names (AGL) for the new characters.
 GLYPH_NAMES_EXT = {
@@ -419,6 +830,33 @@ def _composites():
     "æ": "ae", "ð": "eth", "ø": "oslash", "þ": "thorn", "ı": "dotlessi",
     "€": "Euro", "’": "quoteright", "‘": "quoteleft", "”": "quotedblright",
     "“": "quotedblleft", "…": "ellipsis", "•": "bullet", "₹": "uni20B9",
+    # Weft 0.2
+    "Đ": "Dcroat", "đ": "dcroat", "Ħ": "Hbar", "ħ": "hbar", "Ŧ": "Tbar", "ŧ": "tbar",
+    "Ł": "Lslash", "ł": "lslash", "Ŀ": "Ldot", "ŀ": "ldot", "ĸ": "kgreenlandic",
+    "IJ": "IJ", "ij": "ij", "ʼn": "napostrophe", "Ŋ": "Eng", "ŋ": "eng",
+    "Œ": "OE", "œ": "oe", "ſ": "longs", "ȷ": "uni0237",
+    "‹": "guilsinglleft", "›": "guilsinglright", "‚": "quotesinglbase",
+    "„": "quotedblbase", "−": "minus",
+    "←": "arrowleft", "→": "arrowright", "↑": "arrowup", "↓": "arrowdown",
+    "ˆ": "circumflex", "ˇ": "caron", "˘": "breve", "˙": "dotaccent", "˚": "ring",
+    "˛": "ogonek", "˜": "tilde", "˝": "hungarumlaut",
+    "İ": "Idotaccent", "Ș": "uni0218", "ș": "uni0219", "Ț": "uni021A", "ț": "uni021B",
+    "Ģ": "Gcommaaccent", "ģ": "gcommaaccent", "Ķ": "Kcommaaccent", "ķ": "kcommaaccent",
+    "Ļ": "Lcommaaccent", "ļ": "lcommaaccent", "Ņ": "Ncommaaccent", "ņ": "ncommaaccent",
+    "Ŗ": "Rcommaaccent", "ŗ": "rcommaaccent", "Ő": "Ohungarumlaut", "ő": "ohungarumlaut",
+    "Ű": "Uhungarumlaut", "ű": "uhungarumlaut",
+    "ẞ": "uni1E9E", "Ǿ": "Oslashacute", "ǿ": "oslashacute",
+    "Ǎ": "uni01CD", "ǎ": "uni01CE", "Ǔ": "uni01D3", "ǔ": "uni01D4", "Ẽ": "uni1EBC", "ẽ": "uni1EBD",
+    "\u0300": "gravecomb", "\u0301": "acutecomb", "\u0303": "tildecomb",
 }
-for _ch, (_base, _acc) in _ACCENTED.items():
-    GLYPH_NAMES_EXT[_ch] = ("i" if _base == "ı" else _base) + _acc
+for _ch in COMBINING:
+    GLYPH_NAMES_EXT.setdefault(_ch, f"uni{ord(_ch):04X}")
+for _cp in range(0x2500, 0x2580):
+    if chr(_cp) in STROKES_EXT:
+        GLYPH_NAMES_EXT[chr(_cp)] = f"uni{_cp:04X}"
+for _ch, _spec in _ACCENTED.items():
+    if _ch not in GLYPH_NAMES_EXT:
+        _base = {"ı": "i", "ȷ": "j"}.get(_spec[0], _spec[0])
+        _word = _spec[1].split(".")[0]
+        _word = {"caronvert": "caron", "commabelow": "commaaccent"}.get(_word, _word)
+        GLYPH_NAMES_EXT[_ch] = _base + _word
diff --git a/weft/loom/glyphs.py b/weft/loom/glyphs.py
index 283315c..05a45c1 100644
--- a/weft/loom/glyphs.py
+++ b/weft/loom/glyphs.py
@@ -119,8 +119,10 @@ def glyph_name(ch: str) -> str:
         ("open", [(6.2, 8), (0.5, 3)]),
         ("open", [(2.7, 4.93), (6.5, 0)]),
     ],
+    # Weft 0.2: the stem moves left and the tail is longer, so l does not
+    # read as 1 (OCR look-alike test).
     'l': [
-        ("open", [(1.3, 11.5), (3.5, 11.5), (3.5, 2), (5.5, 0), (6.3, 0)]),
+        ("open", [(1, 11.5), (3, 11.5), (3, 1.6), (4.6, 0), (6.4, 0)]),
     ],
     'm': [
         ("open", [(0, 0), (0, 8), (2.5, 8), (3.5, 7), (3.5, 0)]),
@@ -136,8 +138,9 @@ def glyph_name(ch: str) -> str:
         ("open", [(0.5, 8), (0.5, -3.5)]),
         ("open", [(0.5, 8), (4.5, 8), (6.5, 6), (6.5, 2), (4.5, 0), (0.5, 0)]),
     ],
+    # Weft 0.2: a spur at the foot, so q does not read as g.
     'q': [
-        ("open", [(6.5, 8), (6.5, -3.5)]),
+        ("open", [(6.5, 8), (6.5, -2.5), (7.5, -3.5)]),
         ("open", [(6.5, 8), (2.5, 8), (0.5, 6), (0.5, 2), (2.5, 0), (6.5, 0)]),
     ],
     'r': [
@@ -202,10 +205,11 @@ def glyph_name(ch: str) -> str:
         ("open", [(7, 0), (7, 11)]),
         ("open", [(0, 5.8), (7, 5.8)]),
     ],
+    # Weft 0.2: wider serifs (6 units), so I does not read as 1.
     'I': [
-        ("open", [(1.5, 11), (5.5, 11)]),
+        ("open", [(0.5, 11), (6.5, 11)]),
         ("open", [(3.5, 11), (3.5, 0)]),
-        ("open", [(1.5, 0), (5.5, 0)]),
+        ("open", [(0.5, 0), (6.5, 0)]),
     ],
     'J': [
         ("open", [(2.5, 11), (6.5, 11), (6.5, 2.5), (4, 0), (0.5, 0)]),
@@ -265,13 +269,17 @@ def glyph_name(ch: str) -> str:
     'Z': [
         ("open", [(0, 11), (7, 11), (0, 0), (7, 0)]),
     ],
+    # Weft 0.2: a longer slash. A narrower zero read no better in the OCR
+    # test and closed up at Bold, so the width stays (5.8 units, O is 7).
+    # The dotted zero is ss01.
     '0': [
         ("closed", [(0.6, 2.4), (0.6, 8.6), (3, 11), (4, 11), (6.4, 8.6), (6.4, 2.4), (4, 0), (3, 0)]),
-        ("open", [(5, 7.8), (2, 3.2)]),
+        ("open", [(5, 8), (2, 3)]),
     ],
+    # Weft 0.2: a longer flag and a wider base.
     '1': [
-        ("open", [(0.8, 8.7), (3.5, 11), (3.5, 0)]),
-        ("open", [(1, 0), (6, 0)]),
+        ("open", [(0.5, 8.2), (3.5, 11), (3.5, 0)]),
+        ("open", [(0.8, 0), (6.2, 0)]),
     ],
     '2': [
         ("open", [(0, 9), (2, 11), (5, 11), (7, 9), (7, 7), (0, 1.4), (0, 0), (7, 0)]),
diff --git a/weft/loom/interp.py b/weft/loom/interp.py
index 01ee8b5..0cf8e33 100644
--- a/weft/loom/interp.py
+++ b/weft/loom/interp.py
@@ -51,12 +51,16 @@ def master_pairs() -> list[tuple[int, int]]:
     return list(itertools.combinations(range(n), 2))
 
 
-def problems(gp: pieces.GlyphPlan, to_font, extra_dy=None) -> list[dict]:
-    """Return the interpolatable problems of one glyph plan."""
+def problems(gp: pieces.GlyphPlan, to_font, extra_dy=None, contours=None) -> list[dict]:
+    """Return the interpolatable problems of one glyph plan.
+
+    contours(gp, w, frag) returns the master contours (default: the plain
+    pieces; the build passes its own function for accents that scale).
+    """
     locs = [(w, f) for w in pieces.W_MASTERS for f in pieces.F_MASTERS]
     sets = []
     for w, f in locs:
-        cs = pieces.glyph_contours(gp, w, f)
+        cs = (contours or pieces.glyph_contours)(gp, w, f)
         dy = extra_dy(w) if extra_dy else 0.0
         sets.append(_GlyphSet({gp.name: _Glyph(
             [[to_font((x, y + dy)) for x, y in c] for c in cs])}))
@@ -69,7 +73,7 @@ def problems(gp: pieces.GlyphPlan, to_font, extra_dy=None) -> list[dict]:
     return out
 
 
-def make_clean(gp: pieces.GlyphPlan, to_font, max_attempts: int = 24) -> int:
+def make_clean(gp: pieces.GlyphPlan, to_font, max_attempts: int = 24, contours=None) -> int:
     """Choose drift values that pass the check. Return the attempt used.
 
     Raise ValueError if no attempt passes.
@@ -79,6 +83,6 @@ def make_clean(gp: pieces.GlyphPlan, to_font, max_attempts: int = 24) -> int:
             raise ValueError(f"Glyph {gp.name!r}: no drift plan passes the interpolation check.")
         if attempt:
             pieces.reroll_drift(gp, attempt)
-        if not problems(gp, to_font):
+        if not problems(gp, to_font, contours=contours):
             return attempt
     raise AssertionError("not reached")
diff --git a/weft/loom/outline.py b/weft/loom/outline.py
index af8af0c..b68dc75 100644
--- a/weft/loom/outline.py
+++ b/weft/loom/outline.py
@@ -4,6 +4,8 @@
 
 * Open strokes get square caps: each end extends by half the stroke
   width along its end segment, then the end is cut flat.
+* "butt" strokes have flat ends on the end points (no cap). Box drawing
+  uses them, so the lines end on the cell edges.
 * Joins are miter joins. If the miter ratio 1 / sin(theta / 2) is more
   than the miter limit (2.4), the join is a bevel.
 * A dot is a square with side = stroke width, centred on its point.
@@ -118,12 +120,12 @@ def stroke_polygons(kind: str, points: Sequence[Point], width: float,
         return [[(x - half, y - half), (x + half, y - half),
                  (x + half, y + half), (x - half, y + half)]]
     closed = kind == "closed"
-    if kind not in ("open", "closed"):
+    if kind not in ("open", "closed", "butt"):
         raise ValueError(f"Stroke kind {kind!r} is not known.")
     pts = _dedupe(points, closed)
     if len(pts) < 2 or (closed and len(pts) < 3):
         raise ValueError("Stroke has too few points.")
-    if not closed:
+    if kind == "open":
         d0 = _norm(_sub(pts[1], pts[0]))
         d1 = _norm(_sub(pts[-1], pts[-2]))
         pts[0] = _sub(pts[0], _mul(d0, half))
diff --git a/weft/loom/pieces.py b/weft/loom/pieces.py
index 1b55319..25ac366 100644
--- a/weft/loom/pieces.py
+++ b/weft/loom/pieces.py
@@ -258,9 +258,13 @@ def _make_stroke(kind: str, pts) -> StrokePlan:
 
 
 def _seg_span(sp: StrokePlan, k: int, h: float) -> tuple[float, float]:
-    """Return the along range of segment k, with square caps."""
+    """Return the along range of segment k, with square caps.
+
+    A "butt" stroke has no caps: it ends on its end points (box drawing
+    lines end on the cell edges).
+    """
     lo, hi = 0.0, sp.segs[k].length
-    if not sp.closed:
+    if sp.kind == "open":
         if k == 0:
             lo -= h
         if k == len(sp.segs) - 1:
@@ -313,7 +317,7 @@ def _find_notches(plans: list[StrokePlan]) -> list[Notch]:
                 out.append(nt)
     # Stroke ends on other strokes: corners (end on end) and T-junctions.
     for ai, A in enumerate(plans):
-        if A.kind != "open":
+        if A.kind not in ("open", "butt"):
             continue
         nA = len(A.pts)
         for end in (0, nA - 1):
@@ -653,13 +657,14 @@ def _wedge_safe(prev, v, nxt, half):
 def _pieces(sp: StrokePlan, w: float, frag: float, cutpos):
     """Return pieces as lists of (segment, s0, s1). cutpos: [(seg, u, gap)]."""
     h = w / 2
+    cap = h if sp.kind == "open" else 0.0
     nseg = len(sp.segs)
     if not sp.closed:
-        bounds = [(0, -h)]
+        bounds = [(0, -cap)]
         for k, u, g in cutpos:
             bounds.append((k, u - g / 2))
             bounds.append((k, u + g / 2))
-        bounds.append((nseg - 1, sp.segs[-1].length + h))
+        bounds.append((nseg - 1, sp.segs[-1].length + cap))
         pieces = []
         for (k0, s0), (k1, s1) in zip(bounds[0::2], bounds[1::2]):
             pieces.append(_ranges(sp, k0, s0, k1, s1, False))
diff --git a/weft/pyproject.toml b/weft/pyproject.toml
index 9e7e2b0..5972714 100644
--- a/weft/pyproject.toml
+++ b/weft/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "weft-loom"
-version = "0.1.0"
+version = "0.2.0"
 description = "Generator for the machine-made Weft typeface."
 requires-python = ">=3.14"
 license = "Apache-2.0"
@@ -12,6 +12,7 @@ dependencies = [
     "pillow==13.0.0",
     "munkres==1.1.4",
     "brotli==1.2.1",
+    "ttfautohint-py==0.6.1",
 ]
 
 [project.optional-dependencies]
diff --git a/weft/scripts/build.sh b/weft/scripts/build.sh
index 1d9730e..ff7770b 100755
--- a/weft/scripts/build.sh
+++ b/weft/scripts/build.sh
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
-# Build Weft 0.1: UFO masters and statics, then the variable TTF, static
-# TTF and OTF, and WOFF2.
+# Build Weft: UFO masters and statics, then the variable TTF, static TTF
+# and OTF, and WOFF2. The static TTFs are hinted with ttfautohint (pinned
+# in pyproject.toml: ttfautohint-py, which ships the ttfautohint library).
 # Usage: weft/scripts/build.sh (from any directory)
 set -euo pipefail
 WEFT="$(cd "$(dirname "$0")/.." && pwd)"
@@ -25,6 +26,9 @@ fontmake -u build/static/*.ufo -o ttf --keep-overlaps --output-dir "$OUT/ttf"
 fontmake -u build/static/*.ufo -o otf --keep-overlaps --output-dir "$OUT/otf"
 python tools/finish.py --static "$OUT"/ttf/*.ttf "$OUT"/otf/*.otf
 
+# Hint the static TTFs (ttfautohint, see tools/finish.py --hint).
+python tools/finish.py --hint "$OUT"/ttf/*.ttf
+
 python tools/finish.py --woff2-dir "$OUT/webfonts" --woff2 \
   "$OUT/variable/MachineMadeWeft[FRAG,wght].ttf" \
   "$OUT/ttf/MachineMadeWeft-Regular.ttf" \
diff --git a/weft/tests/test_glyphs.py b/weft/tests/test_glyphs.py
index 5ddb971..cc5f012 100644
--- a/weft/tests/test_glyphs.py
+++ b/weft/tests/test_glyphs.py
@@ -1,4 +1,4 @@
-"""Tests for the Weft 0.1 generator: glyph data, pieces, masters, statics."""
+"""Tests for the Weft generator: glyph data, pieces, masters, statics."""
 
 from __future__ import annotations
 
@@ -72,23 +72,86 @@ def test_character_set_covers_scope():
     assert set("€’‘“”…•₹") <= chars
 
 
+def test_character_set_covers_weft_02_scope():
+    chars = set(B.charset())
+    latin_ext_a = {chr(c) for c in range(0x100, 0x180)}
+    assert latin_ext_a <= chars, sorted(latin_ext_a - chars)
+    assert set("ȘșȚț") <= chars
+    assert set("£¥§¶±×÷¢½¼¾") <= chars
+    assert set("─│┌┐└┘├┤┬┴┼") <= chars
+    assert set("←→↑↓") <= chars
+    assert set("‹›‚„−ˆˇ˘˙˚˛˜˝") <= chars
+    combining = {chr(c) for c in (0x300, 0x301, 0x302, 0x303, 0x304, 0x306, 0x307,
+                                  0x308, 0x30A, 0x30B, 0x30C, 0x326, 0x327, 0x328)}
+    assert combining <= chars
+
+
+# Characters each language needs beyond ASCII (Central European and
+# Baltic languages, Turkish and Romanian; the 0.2 target).
+LANGUAGES = {
+    "Polish": "ĄąĆćĘꣳŃńÓ󌜏źŻż",
+    "Czech": "ÁáČčĎďÉéĚěÍíŇňÓóŘřŠšŤťÚúŮůÝýŽž",
+    "Slovak": "ÁáÄäČčĎďÉéÍíĹ弾ŇňÓóÔôŔ੹ŤťÚúÝýŽž",
+    "Hungarian": "ÁáÉéÍíÓóÖöŐőÚúÜüŰű",
+    "Romanian": "ĂăÂâÎîȘșȚț",
+    "Turkish": "ÇçĞğİıÖöŞşÜü",
+    "Croatian": "ČčĆćĐ𩹮ž",
+    "Slovenian": "Č芚Žž",
+    "Latvian": "ĀāČčĒēĢģĪīĶķĻļŅņŠšŪūŽž",
+    "Lithuanian": "ĄąČčĘęĖėĮįŠšŲųŪūŽž",
+    "Estonian": "ÄäÕõÖöÜüŠšŽž",
+    "Maltese": "ĊċĠġĦħŻż",
+    "Esperanto": "ĈĉĜĝĤĥĴĵŜŝŬŭ",
+}
+
+
+@pytest.mark.parametrize("language", sorted(LANGUAGES))
+def test_language_coverage(language):
+    missing = set(LANGUAGES[language]) - set(B.charset())
+    assert not missing, f"{language} needs {sorted(missing)}."
+
+
 def test_every_char_has_one_glyph_name():
     names = [B.glyph_name(c) for c in B.CHARS]
     assert len(names) == len(set(names))
 
 
 def test_composites_use_existing_glyphs():
-    for ch, (base, accent, kind) in ext.COMPOSITES.items():
+    for ch, (base, accent, kind, dx) in ext.COMPOSITES.items():
         assert accent in ext.ACCENTS
         assert base is None or base in B.DRAWN
-        assert kind in ("lc", "case", "base")
+        assert kind in ("lc", "case", "asc", "base", "below", "abs")
+    for ch, (single, dx) in ext.COMPOUNDS.items():
+        assert single in B.DRAWN
+
+
+def test_master_widths_match():
+    assert ext.W_MASTERS == pieces.W_MASTERS
+
+
+COMPOSITE_CHARS = list(ext.COMPOSITES) + list(ext.COMPOUNDS)
 
 
-def test_accent_offset_is_linear_in_width():
-    for kind in ("lc", "case"):
-        a, b, c = (ext.accent_offset(kind, w, f"acute.{kind}") for w in pieces.W_MASTERS)
-        k = (pieces.W_MASTERS[1] - pieces.W_MASTERS[0]) / (pieces.W_MASTERS[2] - pieces.W_MASTERS[0])
-        assert b == pytest.approx(a + k * (c - a))
+@pytest.mark.parametrize("ch", COMPOSITE_CHARS)
+def test_component_offsets_are_piecewise_linear(ch):
+    # The variable font interpolates component offsets linearly between
+    # masters. The statics compute them at their own width. Both agree
+    # only if the offsets are linear between the master widths.
+    ws = pieces.W_MASTERS
+    for w0, w1 in zip(ws, ws[1:]):
+        a, b, m = ext.parts(ch, w0), ext.parts(ch, w1), ext.parts(ch, (w0 + w1) / 2)
+        for pa, pb, pm in zip(a, b, m):
+            assert pm[1] == pytest.approx((pa[1] + pb[1]) / 2)
+            assert pm[2] == pytest.approx((pa[2] + pb[2]) / 2)
+
+
+def test_accent_scale_keeps_stroke_width():
+    # A scaled accent is drawn at w / s and scaled by s: a dot stays w wide.
+    for w in pieces.W_MASTERS:
+        (c,) = B.contours("dotaccent.case", w, 0)
+        xs = [p[0] for p in c]
+        assert max(xs) - min(xs) == pytest.approx(w)
+    assert ext.accent_scale("acute.case", pieces.W_MASTERS[2]) > 1.0
 
 
 # ----------------------------------------------------------- piece outlines
@@ -178,10 +241,11 @@ def test_drift_is_on_quarter_grid():
 def test_drift_lock_is_current():
     lock = json.loads((Path(B.__file__).with_name("drift_lock.json")).read_text())
     assert lock["seed"] == pieces.SEED
-    for name in ("a", "bullet", "zero", "T"):
+    for name in ("a", "bullet", "zero", "T", "l", "I", "one", "ring.case", "uni253C", "OE", "zero.ss01"):
         gp = B.plan(name)
         assert gp.attempt == lock["attempts"].get(name, 0)
-        assert not interp.problems(gp, B.to_font), f"Run tools/relock.py: {name!r} fails."
+        assert not interp.problems(gp, B.to_font, contours=B.plan_contours), \
+            f"Run tools/relock.py: {name!r} fails."
 
 
 # ------------------------------------------------------------------ masters
@@ -194,7 +258,10 @@ def test_master_glyph_set(default_master):
 
 
 def test_master_advance_is_constant(default_master):
-    assert {g.width for g in default_master} == {B.ADVANCE}
+    # Every glyph is 750 wide, except the combining marks (0).
+    for g in default_master:
+        assert g.width == (0 if g.name in B.mark_names() else B.ADVANCE), g.name
+    assert len(B.mark_names()) == len(ext.COMBINING)
 
 
 def test_composites_have_components(default_master):
@@ -202,18 +269,136 @@ def test_composites_have_components(default_master):
     assert [c.baseGlyph for c in g.components] == ["A", "acute.case"]
     assert not g.contours
     assert default_master["idieresis"].components[0].baseGlyph == "dotlessi"
+    assert [c.baseGlyph for c in default_master["guillemotleft"].components] == ["guilsinglleft"] * 2
+    assert [c.baseGlyph for c in default_master["quotedbl"].components] == ["quotesingle"] * 2
+    assert [c.baseGlyph for c in default_master["uni0219"].components] == ["s", "commabelow.mark"]
 
 
-@pytest.mark.parametrize("accent", [a for a in ext.ACCENTS if not a.startswith("cedilla")])
+@pytest.mark.parametrize("accent", [a for a in ext.ACCENTS if ext.is_scaled(a)])
 def test_accents_clear_the_base(accent):
-    # The accent ink must start above the base ink at every weight. A
-    # slanted accent has square caps that reach a little below w / 2.
+    # The accent ink must start gap(w) above the base ink at every weight.
+    # A slanted accent has square caps that reach a little below w / 2.
     kind = accent.split(".")[1]
     top = ext.ACCENT_BASE_TOP[kind]
     for w in pieces.W_MASTERS:
-        cs = pieces.glyph_contours(B.plan(accent), w, 0)
+        cs = B.contours(accent, w, 0)
         low = min(y for c in cs for _, y in c) + ext.accent_offset(kind, w, accent)
-        assert low - (top + w / 2) == pytest.approx(ext.ACCENT_GAP[kind], abs=0.02)
+        assert low - (top + w / 2) == pytest.approx(ext.pwl(w, ext.ACCENT_GAP[kind]), abs=0.02)
+
+
+def _part_unions(ch, w):
+    out = []
+    for part, dx, dy in ext.parts(ch, w):
+        out.append(union([[(x + dx, y + dy) for x, y in c] for c in B.contours(B.part_name(part), w, 0)]))
+    return out
+
+
+DETACHED = [ch for ch, (base, accent, kind, dx) in ext.COMPOSITES.items()
+            if base is not None and kind in ("lc", "case", "asc", "below", "abs")] + list(ext.COMPOUNDS)
+
+
+@pytest.mark.parametrize("ch", DETACHED)
+def test_marks_do_not_touch(ch):
+    # Marks above and below, the vertical caron, and the two halves of a
+    # guillemet or a double quote stay apart at every master weight.
+    for w in pieces.W_MASTERS:
+        a, b = _part_unions(ch, w)
+        both = pathops.op(a, b, pathops.PathOp.INTERSECTION)
+        assert abs(area(both)) < 1e-6, f"{ch!r} touches at w={w}."
+        # And at least 0.3 units apart (about 19 font units).
+        grown = union([[(x + dx, y + dy) for x, y in c] for c in path_contours(b)
+                       for dx, dy in ((0.3, 0), (-0.3, 0), (0, 0.3), (0, -0.3))])
+        near = pathops.op(a, grown, pathops.PathOp.INTERSECTION)
+        assert abs(area(near)) < 1e-6, f"{ch!r} parts are closer than 0.3 units at w={w}."
+
+
+ATTACHED = [ch for ch, (base, accent, kind, dx) in ext.COMPOSITES.items()
+            if base is not None and kind == "base"]
+
+
+@pytest.mark.parametrize("ch", ATTACHED)
+def test_cedilla_and_ogonek_attach(ch):
+    for w in pieces.W_MASTERS:
+        a, b = _part_unions(ch, w)
+        assert area(pathops.op(a, b, pathops.PathOp.INTERSECTION)) > 0, f"{ch!r} mark floats at w={w}."
+
+
+def test_new_glyphs_stay_in_the_cell():
+    # Weft 0.2 glyphs keep their ink inside the 12-unit cell at FRAG 0
+    # (a small tolerance for the d with caron at Black).
+    new = [c for c in B.CHARS if ord(c) >= 0x100 and c not in "…•€₹’‘“”—–" and c not in ext.COMBINING]
+    for w in pieces.W_MASTERS:
+        for ch in new:
+            name = B.glyph_name(ch)
+            ch_comp = B.composite_char(name)
+            if ch_comp:
+                pts = [(x + dx, y) for part, dx, dy in ext.parts(ch_comp, w)
+                       for c in B.contours(B.part_name(part), w, 0) for x, y in c]
+            else:
+                pts = [p for c in B.contours(name, w, 0) for p in c]
+            xs = [x + B.BOX for x, _ in pts]
+            assert min(xs) >= -0.35 and max(xs) <= 12.05, \
+                f"{ch!r} leaves the cell at w={w}: {min(xs):.2f} {max(xs):.2f}."
+
+
+BOX_CHARS = "─│┌┐└┘├┤┬┴┼"
+
+
+@pytest.mark.parametrize("ch", list(BOX_CHARS))
+def test_box_drawing_ends_on_the_cell_edges(ch):
+    # Lines end exactly on the cell edges, so neighbours join.
+    name = B.glyph_name(ch)
+    for w in pieces.W_MASTERS:
+        pts = [p for c in B.contours(name, w, 0) for p in c]
+        xs = [B.to_font(p)[0] for p in pts]
+        ys = [B.to_font(p)[1] for p in pts]
+        horizontal = ch in "─┌┐└┘├┤┬┴┼"
+        vertical = ch in "│┌┐└┘├┤┬┴┼"
+        left = ch in "─┐┘┤┬┴┼"
+        right = ch in "─┌└├┬┴┼"
+        up = ch in "│└┘├┤┴┼"
+        down = ch in "│┌┐├┤┬┼"
+        assert (min(xs) == 0) == left and (max(xs) == B.ADVANCE) == right
+        assert (min(ys) == B.u(B.TYPO_DESCENDER)) == down and (max(ys) == B.u(B.TYPO_ASCENDER)) == up
+        assert horizontal or vertical
+
+
+def test_combining_marks(default_master):
+    # Combining marks: no advance, over the previous cell, with an anchor
+    # that matches the anchor of the base letters (mark feature).
+    for ch, (accent, anchor) in ext.COMBINING.items():
+        g = default_master[B.glyph_name(ch)]
+        assert g.unicodes == [ord(ch)]
+        assert g.width == 0
+        b = g.getBounds(default_master)
+        assert b.xMax <= 0 < b.xMax + B.ADVANCE
+        assert [a.name for a in g.anchors] == [f"_{anchor}"]
+    for ch in "AaHhgx":
+        names = {a.name for a in default_master[B.glyph_name(ch)].anchors}
+        assert {"top", "bottom", "cedilla"} <= names
+    assert {a.name for a in default_master["A"].anchors} >= {"ogonek"}
+    assert "sub i' @TOP_MARKS by dotlessi;" in default_master.features.text
+    assert default_master.lib["public.openTypeCategories"]["acutecomb"] == "mark"
+
+
+def test_dotted_zero_is_ss01(default_master):
+    assert "zero.ss01" in default_master
+    assert "sub zero by zero.ss01;" in default_master.features.text
+    assert "feature ss01" in default_master.features.text
+
+
+LOOKALIKES = [("O", "zero", 0.3), ("zero", "o", 0.3), ("O", "o", 0.3), ("l", "one", 0.3),
+              ("I", "one", 0.3), ("I", "l", 0.3), ("l", "bar", 0.3), ("B", "eight", 0.15),
+              ("S", "five", 0.15), ("Z", "two", 0.15), ("g", "nine", 0.15), ("g", "q", 0.15)]
+
+
+@pytest.mark.parametrize("a,b,limit", LOOKALIKES)
+def test_lookalikes_differ(a, b, limit):
+    # The ink that differs (XOR) is a large part of the glyph at every weight.
+    for w in pieces.W_MASTERS:
+        pa, pb = union(B.contours(a, w, 0)), union(B.contours(b, w, 0))
+        diff = area(pathops.op(pa, pb, pathops.PathOp.XOR))
+        assert diff / max(area(pa), area(pb)) >= limit, f"{a} and {b} are too alike at w={w}."
 
 
 # ------------------------------------------------------------------ statics
@@ -224,7 +409,8 @@ def test_static_glyph_set(regular):
 
 
 def test_static_advance_is_constant(regular):
-    assert {g.width for g in regular} == {B.ADVANCE}
+    for g in regular:
+        assert g.width == (0 if g.name in B.mark_names() else B.ADVANCE), g.name
 
 
 @pytest.mark.parametrize("name", [n for n in B.glyph_order() if n not in ext.ACCENTS and n != "space"])
@@ -263,7 +449,7 @@ def test_vertical_metrics(regular):
 
 
 def test_stem_width_matches_stroke(regular):
-    glyph = regular["l"]
+    glyph = regular["I"]
     xs = sorted({p.x for c in glyph.contours for p in c.points})
     centre = (3.5 + data.METRICS["box_offset"]) * B.SCALE
     half = data.stroke_width(400) / 2 * B.SCALE
diff --git a/weft/tools/finish.py b/weft/tools/finish.py
index a4cb8de..1f40781 100644
--- a/weft/tools/finish.py
+++ b/weft/tools/finish.py
@@ -4,6 +4,7 @@
     python tools/finish.py --variable FONT.ttf
     python tools/finish.py --static FONT.ttf|FONT.otf ...
     python tools/finish.py --woff2 FONT.ttf ...
+    python tools/finish.py --hint FONT.ttf ...
 
 --variable: set the OVERLAP_SIMPLE flag on every simple glyph and the
     OVERLAP_COMPOUND flag on every composite. The pieces overlap on
@@ -12,11 +13,17 @@
     wght and FRAG axes (one value per axis, as the OpenType spec shows
     for static fonts).
 --woff2: write a WOFF2 copy next to the font.
+--hint: hint a static TTF in place with ttfautohint (the library that
+    ttfautohint-py ships, pinned in pyproject.toml) and set head flag
+    bit 3 (integer ppem), as hinted fonts need. --no-info keeps the
+    ttfautohint options out of the version string, so the output depends
+    only on the input font.
 """
 
 from __future__ import annotations
 
 import argparse
+import io
 from pathlib import Path
 
 from fontTools.otlLib.builder import buildStatTable
@@ -60,6 +67,16 @@ def finish_static(path: Path) -> None:
     print(f"Added STAT to {path}.")
 
 
+def hint(path: Path) -> None:
+    from ttfautohint import ttfautohint
+
+    data = ttfautohint(in_buffer=path.read_bytes(), no_info=True)
+    font = TTFont(io.BytesIO(data))
+    font["head"].flags |= 1 << 3
+    font.save(path)
+    print(f"Hinted {path}.")
+
+
 def write_woff2(path: Path, out_dir: Path) -> None:
     font = TTFont(path)
     font.flavor = "woff2"
@@ -75,13 +92,16 @@ def main(argv: list[str] | None = None) -> int:
     ap.add_argument("--static", nargs="*", default=[], type=Path)
     ap.add_argument("--woff2", nargs="*", default=[], type=Path)
     ap.add_argument("--woff2-dir", type=Path, help="Output folder for WOFF2 files.")
+    ap.add_argument("--hint", nargs="*", default=[], type=Path)
     args = ap.parse_args(argv)
-    if not (args.variable or args.static or args.woff2):
+    if not (args.variable or args.static or args.woff2 or args.hint):
         ap.error("Give at least one font file.")
     for p in args.variable:
         finish_variable(p)
     for p in args.static:
         finish_static(p)
+    for p in args.hint:
+        hint(p)
     for p in args.woff2:
         write_woff2(p, args.woff2_dir or p.parent)
     return 0
diff --git a/weft/tools/proof.py b/weft/tools/proof.py
index 7fcaaff..d482578 100644
--- a/weft/tools/proof.py
+++ b/weft/tools/proof.py
@@ -1,15 +1,26 @@
-"""Render the Weft 0.1 proof sheets from the compiled variable font.
+"""Render the Weft proof sheets from the compiled variable font.
 
 Usage:
     python tools/proof.py [--font VF.ttf] [--out-dir ../proofs/weft]
+                          [--before OLD_VF.ttf]
 
-Writes five PNGs (FreeType through Pillow, no sketch code):
+Writes these PNGs (FreeType through Pillow; Raqm/HarfBuzz for the lines
+that need OpenType features or mark positioning):
 
-    weft-charset.png         every encoded character, wght 400, FRAG 0
+    weft-charset.png           every encoded character, wght 400 and 900, FRAG 0
     weft-weight-waterfall.png  wght 100 to 900, FRAG 0
     weft-frag-waterfall.png    FRAG 0 to 100 at wght 400 and 900
-    weft-body-text.png         body text at 16, 18, 20, 22, 24 px (FRAG 0 and 15)
-    weft-lookalikes.png        Il1| O0 rn/m cl/d 5S 2Z B8 g9 at FRAG 0 and 15
+    weft-designspace.png       a 5 x 5 grid over wght and FRAG
+    weft-body-text.png         body text at 16 to 24 px (FRAG 0 and 15)
+    weft-lookalikes.png        Il1| O0o rn/m cl/d 5S 2Z B8 g9q, ss01
+    weft-accents.png           Latin Extended-A, Romanian, combining marks
+    weft-code.png              box drawing, arrows and a code sample
+
+With --before (the previous release, for example from
+`git show weft-v0.1.0:"fonts/weft/variable/MachineMadeWeft[FRAG,wght].ttf"`):
+
+    weft-before-after-lookalikes.png  look-alikes, previous release and now
+    weft-before-after-black.png       accents and guillemets at wght 900
 """
 
 from __future__ import annotations
@@ -24,6 +35,8 @@
 
 from loom import build  # noqa: E402
 
+VERSION = f"{build.VERSION[0]}.{build.VERSION[1] // 100}"
+
 PAPER = 244
 INK = 18
 MUTED = 110
@@ -36,11 +49,12 @@
     "pull request: 1,204 of 1,204 glyph tests pass. Façade, naïve, Øresund, "
     "São Paulo, Zürich, 25 °C, 3/4 cup, «quotes» and “quotes” — all in one face."
 )
-LOOKALIKES = "Il1| O0 rn m cl d 5S 2Z B8 g9"
+LOOKALIKES = "Il1| O0o rn m cl d 5S 2Z B8 g9q"
 
 
-def font_at(path: str, size: int, wght: float, frag: float) -> ImageFont.FreeTypeFont:
-    font = ImageFont.truetype(path, size)
+def font_at(path: str, size: int, wght: float, frag: float, *, raqm: bool = False) -> ImageFont.FreeTypeFont:
+    engine = ImageFont.Layout.RAQM if raqm else ImageFont.Layout.BASIC
+    font = ImageFont.truetype(path, size, layout_engine=engine)
     names = [a["name"] if isinstance(a["name"], str) else a["name"].decode()
              for a in font.get_variation_axes()]
     values = {"Weight": wght, "Fragmentation": frag}
@@ -62,15 +76,19 @@ def text(self, s: str, size: int = 18, fill: int = MUTED) -> None:
         ImageDraw.Draw(img).text((PAD, 4), s, font=label_font(size), fill=fill)
         self.blocks.append(img)
 
-    def line(self, s: str, font: ImageFont.FreeTypeFont, size: int, note: str = "") -> None:
-        h = round(size * 1.25) + 8
+    def line(self, s: str, font: ImageFont.FreeTypeFont, size: int, note: str = "",
+             features: list[str] | None = None, tall: bool = False) -> None:
+        # tall: room for the accents above capitals and the marks below.
+        top = round(size * (0.55 if tall else 0.0))
+        h = round(size * (1.25 + (0.85 if tall else 0.0))) + 8
         img = Image.new("L", (WIDTH, h), PAPER)
         d = ImageDraw.Draw(img)
         x = PAD
         if note:
             d.text((PAD, h // 2 - 8), note, font=label_font(14), fill=MUTED)
             x = PAD + 150
-        d.text((x, round(size * 0.95) + 4), s, font=font, fill=INK, anchor="ls")
+        d.text((x, top + round(size * 0.95) + 4), s, font=font, fill=INK, anchor="ls",
+               features=features)
         self.blocks.append(img)
 
     def gap(self, h: int = 16) -> None:
@@ -99,29 +117,32 @@ def wrap(text: str, cols: int) -> list[str]:
 
 
 def charset(vf: str, out: Path) -> None:
-    sheet = Sheet(f"machine-made Weft 0.1: full character set ({len(build.charset()) - 1} characters), wght 400, FRAG 0")
-    chars = [c for c in build.charset() if c not in "  "]
-    size, cols = 48, 32
+    sheet = Sheet(f"machine-made Weft {VERSION}: full character set ({len(build.charset()) - 1} characters, {len(build.ext.COMBINING)} of them combining marks), wght 400, FRAG 0")
+    marks = set(build.ext.COMBINING)
+    chars = [c for c in build.charset() if not c.isspace() and c not in marks]
+    size, cols = 44, 32
     font = font_at(vf, size, 400, 0)
     for i in range(0, len(chars), cols):
-        sheet.line("".join(chars[i:i + cols]), font, size)
+        sheet.line("".join(chars[i:i + cols]), font, size, tall=True)
+    sheet.text("Combining marks after o (mark feature): " + " ".join(f"U+{ord(c):04X}" for c in sorted(marks)), 14)
+    sheet.line("  ".join("o" + c for c in sorted(marks)), font_at(vf, size, 400, 0, raqm=True), size, tall=True)
     sheet.gap()
     sheet.text("Same set at wght 900")
     font = font_at(vf, size, 900, 0)
     for i in range(0, len(chars), cols):
-        sheet.line("".join(chars[i:i + cols]), font, size)
+        sheet.line("".join(chars[i:i + cols]), font, size, tall=True)
     sheet.save(out)
 
 
 def weight_waterfall(vf: str, out: Path) -> None:
-    sheet = Sheet("machine-made Weft 0.1: weight waterfall, FRAG 0 (the nine static instances)")
+    sheet = Sheet(f"machine-made Weft {VERSION}: weight waterfall, FRAG 0 (the nine static instances)")
     for wght, style in build.STATICS:
         sheet.line("Weft 0042 Hamburgefonstiv", font_at(vf, 56, wght, 0), 56, f"{wght} {style}")
     sheet.save(out)
 
 
 def frag_waterfall(vf: str, out: Path) -> None:
-    sheet = Sheet("machine-made Weft 0.1: FRAG waterfall (0 Clean, 15 Notched, 50 Cut, 100 Broken)")
+    sheet = Sheet(f"machine-made Weft {VERSION}: FRAG waterfall (0 Clean, 15 Notched, 50 Cut, 100 Broken)")
     for wght in (400, 900):
         sheet.text(f"wght {wght}")
         for frag in (0, 8, 15, 30, 50, 62, 80, 100):
@@ -131,7 +152,7 @@ def frag_waterfall(vf: str, out: Path) -> None:
 
 
 def body_text(vf: str, out: Path) -> None:
-    sheet = Sheet("machine-made Weft 0.1: body text, wght 400, at FRAG 0 (left) and FRAG 15 (right)")
+    sheet = Sheet(f"machine-made Weft {VERSION}: body text, wght 400, at FRAG 0 (left) and FRAG 15 (right)")
     half = WIDTH // 2
     for size in (16, 18, 20, 22, 24):
         sheet.text(f"{size} px")
@@ -150,27 +171,141 @@ def body_text(vf: str, out: Path) -> None:
 
 
 def lookalikes(vf: str, out: Path) -> None:
-    sheet = Sheet("machine-made Weft 0.1: look-alike pairs")
+    sheet = Sheet(f"machine-made Weft {VERSION}: look-alike pairs")
     for frag in (0, 15):
         for wght in (400, 700):
             sheet.line(LOOKALIKES, font_at(vf, 52, wght, frag), 52, f"wght {wght} FRAG {frag}")
+    sheet.line(LOOKALIKES, font_at(vf, 52, 400, 0, raqm=True), 52, "ss01 (dotted 0)", features=["ss01"])
     for frag in (0, 15):
         sheet.line(LOOKALIKES, font_at(vf, 20, 400, frag), 20, f"20 px FRAG {frag}")
+    sheet.line("ID 0O1lI-8B5S-2Z9gq  l1I|  O0o0O  rnm  cld", font_at(vf, 16, 400, 0), 16, "16 px serial")
+    sheet.save(out)
+
+
+ACCENT_LINES = [
+    "ĀāĂ㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģ",
+    "ĤĥĦħĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇň",
+    "ʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞşŠšŢţŤťŦŧŨũŪū",
+    "ŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽžſȘșȚțẞǾǿ",
+]
+SAMPLES = [
+    "Łódź, Gdańsk, Częstochowa · Plzeň, Ústí, Žďár · Ľubica, Ťahanovce",
+    "Győr, Kőszeg, Hódmezővásárhely · Iași, Timișoara, Brașov",
+    "İstanbul, Muğla, Şanlıurfa · Rīga, Liepāja, Ķekava · Šiauliai, Kėdainiai",
+]
+
+
+def accents(vf: str, out: Path) -> None:
+    sheet = Sheet(f"machine-made Weft {VERSION}: Latin Extended-A, Romanian comma below, combining marks")
+    for wght in (400, 900):
+        sheet.text(f"wght {wght}, FRAG 0")
+        for line in ACCENT_LINES:
+            sheet.line(line, font_at(vf, 44, wght, 0), 44, tall=True)
+    sheet.text("Place names, wght 400 and 700, 28 px")
+    for wght in (400, 700):
+        for line in SAMPLES:
+            sheet.line(line, font_at(vf, 28, wght, 0), 28, tall=True)
+    sheet.text("Combining marks (decomposed text, mark feature): precomposed | base + mark")
+    pairs = ["Á", "Č", "Ő", "Ș", "Ą", "ň", "ű", "ș", "ţ", "ę", "í"]
+    import unicodedata
+    for wght in (400, 900):
+        text = "  ".join(f"{c}{unicodedata.normalize('NFD', c)}" for c in pairs)
+        text += "  j\u030C i\u0308"
+        sheet.line(text, font_at(vf, 36, wght, 0, raqm=True), 36, f"wght {wght}", tall=True)
+    sheet.save(out)
+
+
+BOX = [
+    "┌──────┬──────┐",
+    "│ wght │ FRAG │",
+    "├──────┼──────┤",
+    "│ 400  │  15  │",
+    "└──────┴──────┘",
+]
+CODE = [
+    "if (a ≠ b) { x ← f(0O1lI); }  // ← → ↑ ↓",
+    "let total = price × qty ÷ 2 − 5 ± 1;  £ ¥ € ¢ § ¶",
+    "«guillemets» ‹single› „low“ ‚low‘ ½ ¼ ¾",
+]
+
+
+def code(vf: str, out: Path) -> None:
+    sheet = Sheet(f"machine-made Weft {VERSION}: box drawing, arrows and symbols")
+    for wght in (100, 400, 900):
+        sheet.text(f"wght {wght}, line height = typo ascender + descender (1188 units)")
+        size = 40
+        font = font_at(vf, size, wght, 0)
+        step = round(size * 1.188)
+        img = Image.new("L", (WIDTH, step * len(BOX) + 16), PAPER)
+        d = ImageDraw.Draw(img)
+        asc = round(size * 0.906)
+        for i, line in enumerate(BOX):
+            d.text((PAD, 8 + asc + i * step), line, font=font, fill=INK, anchor="ls")
+        sheet.blocks.append(img)
+        for line in CODE:
+            sheet.line(line.replace(" ≠ ", " != "), font_at(vf, 32, wght, 0), 32, tall=True)
+    sheet.save(out)
+
+
+def designspace(vf: str, out: Path) -> None:
+    sheet = Sheet(f"machine-made Weft {VERSION}: designspace, 5 x 5 (wght across, FRAG down)")
+    wghts = (100, 300, 500, 700, 900)
+    frags = (0, 15, 40, 70, 100)
+    size = 56
+    cell = (WIDTH - PAD * 2 - 120) // len(wghts)
+    head = Image.new("L", (WIDTH, 28), PAPER)
+    d = ImageDraw.Draw(head)
+    for i, wg in enumerate(wghts):
+        d.text((PAD + 120 + i * cell, 4), f"wght {wg}", font=label_font(16), fill=MUTED)
+    sheet.blocks.append(head)
+    for fr in frags:
+        img = Image.new("L", (WIDTH, round(size * 1.3)), PAPER)
+        d = ImageDraw.Draw(img)
+        d.text((PAD, size // 2), f"FRAG {fr}", font=label_font(16), fill=MUTED)
+        for i, wg in enumerate(wghts):
+            d.text((PAD + 120 + i * cell, round(size * 1.05)), "Ąg0R", font=font_at(vf, size, wg, fr),
+                   fill=INK, anchor="ls")
+        sheet.blocks.append(img)
     sheet.save(out)
 
 
+def before_after(vf: str, before: str, out_dir: Path) -> None:
+    sheet = Sheet(f"machine-made Weft: look-alikes, previous release (top) and {VERSION} (bottom)")
+    for label, path in (("before", before), (VERSION, vf)):
+        for wght in (400, 700):
+            sheet.line(LOOKALIKES, font_at(path, 52, wght, 0), 52, f"{label} wght {wght}")
+        sheet.line(LOOKALIKES, font_at(path, 20, 400, 0), 20, f"{label} 20 px")
+        sheet.gap(8)
+    sheet.save(out_dir / "weft-before-after-lookalikes.png")
+    sheet = Sheet(f"machine-made Weft: wght 900, previous release (top) and {VERSION} (bottom)")
+    text = "ÀÉÎÕÜÅÑ «»“”\"  ÿåñ"
+    for label, path in (("before", before), (VERSION, vf)):
+        sheet.line(text, font_at(path, 64, 900, 0), 64, f"{label} 900", tall=True)
+        sheet.line(text, font_at(path, 64, 700, 0), 64, f"{label} 700", tall=True)
+    sheet.save(out_dir / "weft-before-after-black.png")
+
+
+
+
+
 def main(argv: list[str] | None = None) -> int:
     ap = argparse.ArgumentParser(description="Render the Weft proof sheets.")
     ap.add_argument("--font", default="../fonts/weft/variable/MachineMadeWeft[FRAG,wght].ttf")
     ap.add_argument("--out-dir", default="../proofs/weft")
+    ap.add_argument("--before", help="The variable font of the previous release (before/after proofs).")
     args = ap.parse_args(argv)
     out = Path(args.out_dir)
     out.mkdir(parents=True, exist_ok=True)
     charset(args.font, out / "weft-charset.png")
     weight_waterfall(args.font, out / "weft-weight-waterfall.png")
     frag_waterfall(args.font, out / "weft-frag-waterfall.png")
+    designspace(args.font, out / "weft-designspace.png")
     body_text(args.font, out / "weft-body-text.png")
     lookalikes(args.font, out / "weft-lookalikes.png")
+    accents(args.font, out / "weft-accents.png")
+    code(args.font, out / "weft-code.png")
+    if args.before:
+        before_after(args.font, args.before, out)
     return 0
 
 
diff --git a/weft/tools/readability.py b/weft/tools/readability.py
index 0448607..c6769f4 100644
--- a/weft/tools/readability.py
+++ b/weft/tools/readability.py
@@ -10,9 +10,10 @@
 distance between the OCR text and the true text, divided by the length
 of the true text. Whitespace is normalized first.
 
-* Paragraph: FRAG 0, 15, 50 and 100 at 16, 20 and 24 px, wght 400.
+* Paragraph: FRAG 0, 8, 15, 50 and 100 at 16, 20 and 24 px, wght 400.
 * Look-alikes: fixed lines of the characters I l 1 | O 0 r n m c l d
-  5 S 2 Z B 8 g 9 in groups of five, at 20, 24 and 32 px, FRAG 0 and 15. Tesseract
+  5 S 2 Z B 8 g 9 q in groups of five, at 20, 24 and 32 px, at the
+  text-safe FRAG values 0, 8 and 15. Tesseract
   reads it with a whitelist of only these characters, so each error is a
   confusion between look-alikes. Spaces are removed before the compare
   (Tesseract often joins the groups). Per-pair confusion counts are in
@@ -21,10 +22,11 @@
 The reference is a free monospace (default: DejaVu Sans Mono from the
 distribution). It goes through the same steps.
 
-Gate (--gate): for FRAG 0 and 15, the mean paragraph CER of Weft must
-not be more than the reference plus MARGIN, and the mean look-alike CER
-not more than the reference plus LOOKALIKE_MARGIN. FRAG 15 must also
-stay within FRAG15_MARGIN of FRAG 0. FRAG 50 and 100 are reported only.
+Gate (--gate): for FRAG 0, 8 and 15 (the text-safe stages), the mean
+paragraph CER of Weft must not be more than the reference plus MARGIN,
+and the mean look-alike CER not more than the reference plus
+LOOKALIKE_MARGIN. FRAG 8 and 15 must also stay within FRAG15_MARGIN of
+FRAG 0. FRAG 50 and 100 are reported only.
 """
 
 from __future__ import annotations
@@ -48,20 +50,21 @@
 )
 COLUMNS = 48
 SIZES = (16, 20, 24)
-FRAGS = (0, 15, 50, 100)
-GATED_FRAGS = (0, 15)
-PAIRS = ["Il1|", "O0", "rnm", "cld", "5S", "2Z", "B8", "g9"]
+FRAGS = (0, 8, 15, 50, 100)
+GATED_FRAGS = (0, 8, 15)
+PAIRS = ["Il1|", "O0", "rnm", "cld", "5S", "2Z", "B8", "g9q"]
 LOOKALIKE_SIZES = (20, 24, 32)
 UPSCALE = 3        # Tesseract reads small text better at about 30 px x-height
 # Absolute CER margins over the reference. The look-alike line has
-# 240 characters, and Tesseract (trained on common fonts) reads Weft's
-# flagged l and serifed I as 1 more often than DejaVu's. The margin for
-# it was set after the first run (Weft 0.1: about 0.11 against 0.07);
-# it stops a regression, it does not prove parity with the reference.
+# 240 characters. Weft 0.1 needed a margin of 0.06 (about 0.12 against
+# 0.075): Tesseract read its l and I as 1, q as g, and confused O and 0.
+# Weft 0.2 changed l, I, 1, 0 and q (see STATUS.md) and reads better
+# than the reference (about 0.07 against 0.0875), so the margin is 0:
+# Weft must not read worse than DejaVu Sans Mono.
 MARGIN = 0.02
-LOOKALIKE_MARGIN = 0.06
-# FRAG 15 must read like FRAG 0 (the brief: "body text at FRAG 15 reads
-# the same as FRAG 0").
+LOOKALIKE_MARGIN = 0.0
+# FRAG 8 and 15 must read like FRAG 0 (the brief: "body text at FRAG 15
+# reads the same as FRAG 0").
 FRAG15_MARGIN = 0.02
 SEED = "machine-made Weft readability"
 DEFAULT_REFERENCE = "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"
@@ -218,14 +221,17 @@ def main(argv: list[str] | None = None) -> int:
             gate["checks"].append({"frag": f, "test": kind, "cer": value,
                                    "limit": round(limit, 4), "pass": ok})
             gate["pass"] &= ok
-    for kind, k0, k15 in (
-        ("paragraph vs FRAG 0", weft["paragraph"]["FRAG 0"]["cer_mean"], weft["paragraph"]["FRAG 15"]["cer_mean"]),
-        ("lookalikes vs FRAG 0", weft["lookalikes"]["FRAG 0"]["cer"], weft["lookalikes"]["FRAG 15"]["cer"]),
-    ):
-        ok = k15 <= k0 + FRAG15_MARGIN + 1e-9
-        gate["checks"].append({"frag": 15, "test": kind, "cer": k15,
-                               "limit": round(k0 + FRAG15_MARGIN, 4), "pass": ok})
-        gate["pass"] &= ok
+    for f in GATED_FRAGS[1:]:
+        for kind, k0, kf in (
+            ("paragraph vs FRAG 0", weft["paragraph"]["FRAG 0"]["cer_mean"],
+             weft["paragraph"][f"FRAG {f}"]["cer_mean"]),
+            ("lookalikes vs FRAG 0", weft["lookalikes"]["FRAG 0"]["cer"],
+             weft["lookalikes"][f"FRAG {f}"]["cer"]),
+        ):
+            ok = kf <= k0 + FRAG15_MARGIN + 1e-9
+            gate["checks"].append({"frag": f, "test": kind, "cer": kf,
+                                   "limit": round(k0 + FRAG15_MARGIN, 4), "pass": ok})
+            gate["pass"] &= ok
     report = {
         "about": "OCR character error rate (CER). Lower is better. See weft/tools/readability.py.",
         "tesseract": version,
diff --git a/weft/tools/relock.py b/weft/tools/relock.py
index 74ed472..415dd2e 100644
--- a/weft/tools/relock.py
+++ b/weft/tools/relock.py
@@ -25,7 +25,7 @@ def main() -> int:
     attempts = {}
     for name in build.drawn_names():
         gp = pieces.plan_glyph(name, build.strokes_of(name))
-        attempt = interp.make_clean(gp, build.to_font)
+        attempt = interp.make_clean(gp, build.to_font, contours=build.plan_contours)
         if attempt:
             attempts[name] = attempt
     out = Path(build.__file__).with_name("drift_lock.json")