Speed predictions with receipts: bandwidth roofline, real-runs chart, honest provenance

README.md

@@ -43,6 +43,17 @@ chatbots to object detection, image generation, speech, and robotics.
   file size, a vendor-published number, community-reported, or estimated.
 - **Licenses up front.** AGPL, non-commercial, and gated models are labelled
   on every card — before you build your project on one.
+- **Speed estimates with receipts, not vibes.** For LLMs, FitCheck predicts
+  decode tokens/sec from your memory bandwidth (decode is bandwidth-bound) and
+  shows where your machine lands among **real community benchmark runs**
+  ([LocalScore](https://www.localscore.ai)) on an interactive roofline chart.
+  A learned predictor — following IBM's
+  [LLM-Pilot methodology](https://arxiv.org/abs/2410.02425) (gradient boosting
+  over hardware features, validated leave-one-accelerator-out) — replaces the
+  analytical estimate **only if it beats it on hardware it never saw**;
+  otherwise the labelled baseline ships. Vision and diffusion models are
+  compute-bound, not bandwidth-bound, so they honestly keep memory verdicts
+  only rather than fake speed numbers.
 - **Conservative by design.** Three plain bands (Runs great / Tight, but works
   / Won't fit) that would rather under-promise than over-promise.
 

data/gpu_specs.json

@@ -0,0 +1,1198 @@
+{
+ "generated_at": "2026-06-10T12:11:14+00:00",
+ "source": {
+  "repo": "https://github.com/midudev/canirun.ai",
+  "license": "MIT",
+  "note": "Spec tables hand-compiled by the canirun.ai project from official vendor product pages. bw = memory bandwidth in GB/s."
+ },
+ "gpus": {
+  "RTX 5090": {
+   "vram": 32.0,
+   "bw": 1792.0,
+   "cores": 21760.0
+  },
+  "RTX 5080": {
+   "vram": 16.0,
+   "bw": 960.0,
+   "cores": 10752.0
+  },
+  "RTX 5070 Ti": {
+   "vram": 16.0,
+   "bw": 896.0,
+   "cores": 8960.0
+  },
+  "RTX 5070": {
+   "vram": 12.0,
+   "bw": 672.0,
+   "cores": 6144.0
+  },
+  "RTX 5060 Ti 16GB": {
+   "vram": 16.0,
+   "bw": 448.0,
+   "cores": 4608.0
+  },
+  "RTX 5060 Ti": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 4608.0
+  },
+  "RTX 5060": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 3840.0
+  },
+  "RTX 5050": {
+   "vram": 8.0,
+   "bw": 320.0,
+   "cores": 2560.0
+  },
+  "RTX 4090": {
+   "vram": 24.0,
+   "bw": 1008.0,
+   "cores": 16384.0
+  },
+  "RTX 4080 SUPER": {
+   "vram": 16.0,
+   "bw": 736.0,
+   "cores": 10240.0
+  },
+  "RTX 4080": {
+   "vram": 16.0,
+   "bw": 717.0,
+   "cores": 9728.0
+  },
+  "RTX 4070 Ti SUPER": {
+   "vram": 16.0,
+   "bw": 672.0,
+   "cores": 8448.0
+  },
+  "RTX 4070 Ti": {
+   "vram": 12.0,
+   "bw": 504.0,
+   "cores": 7680.0
+  },
+  "RTX 4070 SUPER": {
+   "vram": 12.0,
+   "bw": 504.0,
+   "cores": 7168.0
+  },
+  "RTX 4070": {
+   "vram": 12.0,
+   "bw": 504.0,
+   "cores": 5888.0
+  },
+  "RTX 4060 Ti 16GB": {
+   "vram": 16.0,
+   "bw": 288.0,
+   "cores": 4352.0
+  },
+  "RTX 4060 Ti": {
+   "vram": 8.0,
+   "bw": 288.0,
+   "cores": 4352.0
+  },
+  "RTX 4060": {
+   "vram": 8.0,
+   "bw": 272.0,
+   "cores": 3072.0
+  },
+  "RTX 3090 Ti": {
+   "vram": 24.0,
+   "bw": 1008.0,
+   "cores": 10752.0
+  },
+  "RTX 3090": {
+   "vram": 24.0,
+   "bw": 936.0,
+   "cores": 10496.0
+  },
+  "RTX 3080 Ti": {
+   "vram": 12.0,
+   "bw": 912.0,
+   "cores": 10240.0
+  },
+  "RTX 3080 12GB": {
+   "vram": 12.0,
+   "bw": 912.0,
+   "cores": 8960.0
+  },
+  "RTX 3080": {
+   "vram": 10.0,
+   "bw": 760.0,
+   "cores": 8704.0
+  },
+  "RTX 3070 Ti": {
+   "vram": 8.0,
+   "bw": 608.0,
+   "cores": 6144.0
+  },
+  "RTX 3070": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 5888.0
+  },
+  "RTX 3060 Ti": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 4864.0
+  },
+  "RTX 3060": {
+   "vram": 12.0,
+   "bw": 360.0,
+   "cores": 3584.0
+  },
+  "RTX 3050": {
+   "vram": 8.0,
+   "bw": 224.0,
+   "cores": 2560.0
+  },
+  "RTX 5090 Laptop": {
+   "vram": 24.0,
+   "bw": 896.0,
+   "cores": 10496.0
+  },
+  "RTX 5080 Laptop": {
+   "vram": 16.0,
+   "bw": 896.0,
+   "cores": 7680.0
+  },
+  "RTX 5070 Ti Laptop": {
+   "vram": 12.0,
+   "bw": 672.0,
+   "cores": 5888.0
+  },
+  "RTX 5070 Laptop": {
+   "vram": 8.0,
+   "bw": 384.0,
+   "cores": 4608.0
+  },
+  "RTX 5060 Laptop": {
+   "vram": 8.0,
+   "bw": 384.0,
+   "cores": 3328.0
+  },
+  "RTX 5050 Laptop": {
+   "vram": 8.0,
+   "bw": 384.0,
+   "cores": 2560.0
+  },
+  "RTX 4090 Laptop": {
+   "vram": 16.0,
+   "bw": 576.0,
+   "cores": 9728.0
+  },
+  "RTX 4080 Laptop": {
+   "vram": 12.0,
+   "bw": 432.0,
+   "cores": 7424.0
+  },
+  "RTX 4070 Laptop": {
+   "vram": 8.0,
+   "bw": 256.0,
+   "cores": 4608.0
+  },
+  "RTX 4060 Laptop": {
+   "vram": 8.0,
+   "bw": 256.0,
+   "cores": 3072.0
+  },
+  "RTX 4050 Laptop": {
+   "vram": 6.0,
+   "bw": 192.0,
+   "cores": 2560.0
+  },
+  "RTX 3080 Ti Laptop": {
+   "vram": 16.0,
+   "bw": 512.0,
+   "cores": 7424.0
+  },
+  "RTX 3080 Laptop": {
+   "vram": 16.0,
+   "bw": 448.0,
+   "cores": 6144.0
+  },
+  "RTX 3070 Ti Laptop": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 5888.0
+  },
+  "RTX 3070 Laptop": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 5120.0
+  },
+  "RTX 3060 Laptop": {
+   "vram": 6.0,
+   "bw": 336.0,
+   "cores": 3840.0
+  },
+  "RTX 3050 Ti Laptop": {
+   "vram": 4.0,
+   "bw": 192.0,
+   "cores": 2560.0
+  },
+  "RTX 3050 Laptop": {
+   "vram": 4.0,
+   "bw": 192.0,
+   "cores": 2048.0
+  },
+  "RTX PRO 6000": {
+   "vram": 96.0,
+   "bw": 1792.0,
+   "cores": 24064.0
+  },
+  "RTX 6000 Ada": {
+   "vram": 48.0,
+   "bw": 960.0,
+   "cores": 18176.0
+  },
+  "RTX 5880 Ada": {
+   "vram": 48.0,
+   "bw": 960.0,
+   "cores": 14080.0
+  },
+  "RTX 5000 Ada": {
+   "vram": 32.0,
+   "bw": 800.0,
+   "cores": 12800.0
+  },
+  "RTX 4500 Ada": {
+   "vram": 24.0,
+   "bw": 432.0,
+   "cores": 7680.0
+  },
+  "RTX 4000 SFF Ada": {
+   "vram": 20.0,
+   "bw": 320.0,
+   "cores": 6144.0
+  },
+  "RTX 4000 Ada": {
+   "vram": 20.0,
+   "bw": 360.0,
+   "cores": 6144.0
+  },
+  "RTX 3500 Ada": {
+   "vram": 12.0,
+   "bw": 432.0,
+   "cores": 5120.0
+  },
+  "RTX 2000 Ada": {
+   "vram": 16.0,
+   "bw": 224.0,
+   "cores": 2816.0
+  },
+  "RTX A6000": {
+   "vram": 48.0,
+   "bw": 768.0,
+   "cores": 10752.0
+  },
+  "RTX A5500": {
+   "vram": 24.0,
+   "bw": 768.0,
+   "cores": 10240.0
+  },
+  "RTX A5000": {
+   "vram": 24.0,
+   "bw": 768.0,
+   "cores": 8192.0
+  },
+  "RTX A4500": {
+   "vram": 20.0,
+   "bw": 640.0,
+   "cores": 7168.0
+  },
+  "RTX A4000": {
+   "vram": 16.0,
+   "bw": 448.0,
+   "cores": 6144.0
+  },
+  "RTX A2000": {
+   "vram": 6.0,
+   "bw": 288.0,
+   "cores": 3328.0
+  },
+  "RTX 2080 Ti": {
+   "vram": 11.0,
+   "bw": 616.0,
+   "cores": 4352.0
+  },
+  "RTX 2080 SUPER": {
+   "vram": 8.0,
+   "bw": 496.0,
+   "cores": 3072.0
+  },
+  "RTX 2080": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 2944.0
+  },
+  "RTX 2070 SUPER": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 2560.0
+  },
+  "RTX 2070": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 2304.0
+  },
+  "RTX 2060 SUPER": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 2176.0
+  },
+  "RTX 2060": {
+   "vram": 6.0,
+   "bw": 336.0,
+   "cores": 1920.0
+  },
+  "RTX 2060 12GB": {
+   "vram": 12.0,
+   "bw": 336.0,
+   "cores": 2176.0
+  },
+  "RTX 3050 6GB": {
+   "vram": 6.0,
+   "bw": 168.0,
+   "cores": 2304.0
+  },
+  "A100": {
+   "vram": 80.0,
+   "bw": 2039.0,
+   "cores": 6912.0
+  },
+  "H100": {
+   "vram": 80.0,
+   "bw": 3350.0,
+   "cores": 14592.0
+  },
+  "GH200": {
+   "vram": 96.0,
+   "bw": 4000.0,
+   "cores": 16896.0
+  },
+  "DGX Spark": {
+   "vram": 128.0,
+   "bw": 273.0,
+   "cores": 6144.0
+  },
+  "L40S": {
+   "vram": 48.0,
+   "bw": 864.0,
+   "cores": 18176.0
+  },
+  "L4": {
+   "vram": 24.0,
+   "bw": 300.0,
+   "cores": 7424.0
+  },
+  "T4": {
+   "vram": 16.0,
+   "bw": 300.0,
+   "cores": 2560.0
+  },
+  "Tesla P40": {
+   "vram": 24.0,
+   "bw": 346.0,
+   "cores": 3840.0
+  },
+  "RX 7900 XTX": {
+   "vram": 24.0,
+   "bw": 960.0,
+   "cores": 6144.0
+  },
+  "RX 7900 XT": {
+   "vram": 20.0,
+   "bw": 800.0,
+   "cores": 5376.0
+  },
+  "RX 7800 XT": {
+   "vram": 16.0,
+   "bw": 624.0,
+   "cores": 3840.0
+  },
+  "RX 7700 XT": {
+   "vram": 12.0,
+   "bw": 432.0,
+   "cores": 3456.0
+  },
+  "RX 7600 XT": {
+   "vram": 16.0,
+   "bw": 288.0,
+   "cores": 2048.0
+  },
+  "RX 7600": {
+   "vram": 8.0,
+   "bw": 288.0,
+   "cores": 2048.0
+  },
+  "RX 6900 XT": {
+   "vram": 16.0,
+   "bw": 512.0,
+   "cores": 5120.0
+  },
+  "RX 6800 XT": {
+   "vram": 16.0,
+   "bw": 512.0,
+   "cores": 4608.0
+  },
+  "RX 6800": {
+   "vram": 16.0,
+   "bw": 512.0,
+   "cores": 3840.0
+  },
+  "RX 6750 XT": {
+   "vram": 12.0,
+   "bw": 432.0,
+   "cores": 2560.0
+  },
+  "RX 6700 XT": {
+   "vram": 12.0,
+   "bw": 384.0,
+   "cores": 2560.0
+  },
+  "RX 6650 XT": {
+   "vram": 8.0,
+   "bw": 280.0,
+   "cores": 2048.0
+  },
+  "RX 6600 XT": {
+   "vram": 8.0,
+   "bw": 256.0,
+   "cores": 2048.0
+  },
+  "RX 6600": {
+   "vram": 8.0,
+   "bw": 224.0,
+   "cores": 1792.0
+  },
+  "RX 6500 XT": {
+   "vram": 4.0,
+   "bw": 144.0,
+   "cores": 1024.0
+  },
+  "Arc A770": {
+   "vram": 16.0,
+   "bw": 560.0,
+   "cores": 4096.0
+  },
+  "Arc A750": {
+   "vram": 8.0,
+   "bw": 512.0,
+   "cores": 3584.0
+  },
+  "Arc A580": {
+   "vram": 8.0,
+   "bw": 512.0,
+   "cores": 3072.0
+  },
+  "Arc A380": {
+   "vram": 6.0,
+   "bw": 186.0,
+   "cores": 1024.0
+  },
+  "GTX 1660 Ti": {
+   "vram": 6.0,
+   "bw": 288.0,
+   "cores": 1536.0
+  },
+  "GTX 1660 SUPER": {
+   "vram": 6.0,
+   "bw": 336.0,
+   "cores": 1408.0
+  },
+  "GTX 1660": {
+   "vram": 6.0,
+   "bw": 192.0,
+   "cores": 1408.0
+  },
+  "GTX 1650 SUPER": {
+   "vram": 4.0,
+   "bw": 192.0,
+   "cores": 1280.0
+  },
+  "GTX 1650 Ti": {
+   "vram": 4.0,
+   "bw": 192.0,
+   "cores": 1024.0
+  },
+  "GTX 1650": {
+   "vram": 4.0,
+   "bw": 128.0,
+   "cores": 896.0
+  },
+  "GTX 1630": {
+   "vram": 4.0,
+   "bw": 96.0,
+   "cores": 512.0
+  },
+  "GTX 1080 Ti": {
+   "vram": 11.0,
+   "bw": 484.0,
+   "cores": 3584.0
+  },
+  "GTX 1080": {
+   "vram": 8.0,
+   "bw": 320.0,
+   "cores": 2560.0
+  },
+  "GTX 1070 Ti": {
+   "vram": 8.0,
+   "bw": 256.0,
+   "cores": 2432.0
+  },
+  "GTX 1070": {
+   "vram": 8.0,
+   "bw": 256.0,
+   "cores": 1920.0
+  },
+  "GTX 1060 6GB": {
+   "vram": 6.0,
+   "bw": 192.0,
+   "cores": 1280.0
+  },
+  "GTX 1060 3GB": {
+   "vram": 3.0,
+   "bw": 192.0,
+   "cores": 1152.0
+  },
+  "GTX 1060": {
+   "vram": 6.0,
+   "bw": 192.0,
+   "cores": 1280.0
+  },
+  "GTX 1050 Ti": {
+   "vram": 4.0,
+   "bw": 112.0,
+   "cores": 768.0
+  },
+  "GTX 1050": {
+   "vram": 2.0,
+   "bw": 112.0,
+   "cores": 640.0
+  },
+  "GTX 980 Ti": {
+   "vram": 6.0,
+   "bw": 336.0,
+   "cores": 2816.0
+  },
+  "GTX 980": {
+   "vram": 4.0,
+   "bw": 224.0,
+   "cores": 2048.0
+  },
+  "GTX 970": {
+   "vram": 4.0,
+   "bw": 224.0,
+   "cores": 1664.0
+  },
+  "GTX 960": {
+   "vram": 2.0,
+   "bw": 112.0,
+   "cores": 1024.0
+  },
+  "GTX 950": {
+   "vram": 2.0,
+   "bw": 105.0,
+   "cores": 768.0
+  },
+  "Quadro RTX 8000": {
+   "vram": 48.0,
+   "bw": 672.0,
+   "cores": 4608.0
+  },
+  "Quadro RTX 6000": {
+   "vram": 24.0,
+   "bw": 672.0,
+   "cores": 4608.0
+  },
+  "Quadro RTX 5000": {
+   "vram": 16.0,
+   "bw": 448.0,
+   "cores": 3072.0
+  },
+  "Quadro RTX 4000": {
+   "vram": 8.0,
+   "bw": 416.0,
+   "cores": 2304.0
+  },
+  "Quadro RTX 3000": {
+   "vram": 6.0,
+   "bw": 336.0,
+   "cores": 1920.0
+  },
+  "Quadro T2000": {
+   "vram": 4.0,
+   "bw": 128.0,
+   "cores": 1024.0
+  },
+  "Quadro T1000": {
+   "vram": 4.0,
+   "bw": 128.0,
+   "cores": 896.0
+  },
+  "T1200": {
+   "vram": 4.0,
+   "bw": 192.0,
+   "cores": 1024.0
+  },
+  "NVIDIA T600": {
+   "vram": 4.0,
+   "bw": 192.0,
+   "cores": 896.0
+  },
+  "NVIDIA T550": {
+   "vram": 4.0,
+   "bw": 112.0,
+   "cores": 1024.0
+  },
+  "NVIDIA T500": {
+   "vram": 4.0,
+   "bw": 80.0,
+   "cores": 896.0
+  },
+  "Quadro P5200": {
+   "vram": 16.0,
+   "bw": 230.0,
+   "cores": 2560.0
+  },
+  "Quadro P5000": {
+   "vram": 16.0,
+   "bw": 288.0,
+   "cores": 2560.0
+  },
+  "Quadro P4200": {
+   "vram": 8.0,
+   "bw": 224.0,
+   "cores": 1792.0
+  },
+  "Quadro P4000": {
+   "vram": 8.0,
+   "bw": 192.0,
+   "cores": 1792.0
+  },
+  "Quadro P3000": {
+   "vram": 6.0,
+   "bw": 168.0,
+   "cores": 1280.0
+  },
+  "Quadro P3200": {
+   "vram": 6.0,
+   "bw": 192.0,
+   "cores": 1792.0
+  },
+  "Quadro P2000": {
+   "vram": 5.0,
+   "bw": 140.0,
+   "cores": 1024.0
+  },
+  "Quadro P1000": {
+   "vram": 4.0,
+   "bw": 82.0,
+   "cores": 640.0
+  },
+  "Quadro P620": {
+   "vram": 4.0,
+   "bw": 96.0,
+   "cores": 512.0
+  },
+  "Quadro P600": {
+   "vram": 2.0,
+   "bw": 64.0,
+   "cores": 384.0
+  },
+  "Quadro P520": {
+   "vram": 2.0,
+   "bw": 48.0,
+   "cores": 384.0
+  },
+  "Quadro P500": {
+   "vram": 2.0,
+   "bw": 64.0,
+   "cores": 256.0
+  },
+  "Quadro M5500": {
+   "vram": 8.0,
+   "bw": 211.0,
+   "cores": 2048.0
+  },
+  "Quadro M5000M": {
+   "vram": 8.0,
+   "bw": 160.0,
+   "cores": 1536.0
+  },
+  "Quadro M4000M": {
+   "vram": 4.0,
+   "bw": 160.0,
+   "cores": 1024.0
+  },
+  "Quadro M3000M": {
+   "vram": 4.0,
+   "bw": 160.0,
+   "cores": 1024.0
+  },
+  "Quadro M2200": {
+   "vram": 4.0,
+   "bw": 140.0,
+   "cores": 1024.0
+  },
+  "Quadro M2000M": {
+   "vram": 4.0,
+   "bw": 80.0,
+   "cores": 640.0
+  },
+  "Quadro M1200": {
+   "vram": 4.0,
+   "bw": 128.0,
+   "cores": 640.0
+  },
+  "Quadro M1000M": {
+   "vram": 2.0,
+   "bw": 80.0,
+   "cores": 512.0
+  },
+  "Quadro M620": {
+   "vram": 2.0,
+   "bw": 80.0,
+   "cores": 512.0
+  },
+  "Quadro M600M": {
+   "vram": 2.0,
+   "bw": 64.0,
+   "cores": 384.0
+  },
+  "Quadro M520": {
+   "vram": 1.0,
+   "bw": 40.0,
+   "cores": 384.0
+  },
+  "Quadro M500M": {
+   "vram": 2.0,
+   "bw": 16.0,
+   "cores": 384.0
+  },
+  "Quadro K5100M": {
+   "vram": 8.0,
+   "bw": 160.0,
+   "cores": 1536.0
+  },
+  "Quadro K5000M": {
+   "vram": 4.0,
+   "bw": 173.0,
+   "cores": 1344.0
+  },
+  "Quadro K4100M": {
+   "vram": 4.0,
+   "bw": 115.0,
+   "cores": 1152.0
+  },
+  "Quadro K4000M": {
+   "vram": 4.0,
+   "bw": 134.0,
+   "cores": 960.0
+  },
+  "Quadro K3100M": {
+   "vram": 4.0,
+   "bw": 80.0,
+   "cores": 768.0
+  },
+  "Quadro K3000M": {
+   "vram": 2.0,
+   "bw": 80.0,
+   "cores": 576.0
+  },
+  "Quadro K2100M": {
+   "vram": 2.0,
+   "bw": 48.0,
+   "cores": 576.0
+  },
+  "Quadro K2000M": {
+   "vram": 2.0,
+   "bw": 64.0,
+   "cores": 384.0
+  },
+  "Quadro K1100M": {
+   "vram": 2.0,
+   "bw": 64.0,
+   "cores": 384.0
+  },
+  "Quadro K1000M": {
+   "vram": 2.0,
+   "bw": 64.0,
+   "cores": 384.0
+  },
+  "Quadro K620M": {
+   "vram": 2.0,
+   "bw": 16.0,
+   "cores": 384.0
+  },
+  "Quadro K610M": {
+   "vram": 1.0,
+   "bw": 29.0,
+   "cores": 192.0
+  },
+  "Quadro K510M": {
+   "vram": 1.0,
+   "bw": 19.2,
+   "cores": 192.0
+  },
+  "Quadro K500M": {
+   "vram": 2.0,
+   "bw": 28.8,
+   "cores": 192.0
+  },
+  "RTX A3000": {
+   "vram": 6.0,
+   "bw": 192.0,
+   "cores": 4096.0
+  },
+  "RTX A3000 12GB": {
+   "vram": 12.0,
+   "bw": 336.0,
+   "cores": 4096.0
+  },
+  "RTX A2000 8GB": {
+   "vram": 8.0,
+   "bw": 224.0,
+   "cores": 2560.0
+  },
+  "RTX A1000": {
+   "vram": 4.0,
+   "bw": 224.0,
+   "cores": 2048.0
+  },
+  "RTX A500": {
+   "vram": 4.0,
+   "bw": 112.0,
+   "cores": 2048.0
+  },
+  "RX 5700 XT": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 2560.0
+  },
+  "RX 5700": {
+   "vram": 8.0,
+   "bw": 448.0,
+   "cores": 2304.0
+  },
+  "RX 5600 XT": {
+   "vram": 6.0,
+   "bw": 288.0,
+   "cores": 2304.0
+  },
+  "RX 5500 XT": {
+   "vram": 8.0,
+   "bw": 224.0,
+   "cores": 1408.0
+  },
+  "RX 590": {
+   "vram": 8.0,
+   "bw": 256.0,
+   "cores": 2304.0
+  },
+  "RX 580": {
+   "vram": 8.0,
+   "bw": 256.0,
+   "cores": 2304.0
+  },
+  "RX 570": {
+   "vram": 4.0,
+   "bw": 224.0,
+   "cores": 2048.0
+  },
+  "RX 560": {
+   "vram": 4.0,
+   "bw": 112.0,
+   "cores": 1024.0
+  },
+  "Radeon VII": {
+   "vram": 16.0,
+   "bw": 1024.0,
+   "cores": 3840.0
+  },
+  "Vega 64": {
+   "vram": 8.0,
+   "bw": 484.0,
+   "cores": 4096.0
+  },
+  "Vega 56": {
+   "vram": 8.0,
+   "bw": 410.0,
+   "cores": 3584.0
+  },
+  "RX 9070 XT": {
+   "vram": 16.0,
+   "bw": 640.0,
+   "cores": 4096.0
+  },
+  "RX 9070": {
+   "vram": 16.0,
+   "bw": 640.0,
+   "cores": 3584.0
+  },
+  "RX 7900M": {
+   "vram": 16.0,
+   "bw": 720.0,
+   "cores": 4608.0
+  },
+  "RX 7700S": {
+   "vram": 8.0,
+   "bw": 288.0,
+   "cores": 2048.0
+  },
+  "RX 7600M XT": {
+   "vram": 8.0,
+   "bw": 288.0,
+   "cores": 2048.0
+  },
+  "RX 7600M": {
+   "vram": 8.0,
+   "bw": 288.0,
+   "cores": 1792.0
+  },
+  "RX 7600S": {
+   "vram": 8.0,
+   "bw": 288.0,
+   "cores": 1792.0
+  },
+  "RX 6800M": {
+   "vram": 12.0,
+   "bw": 384.0,
+   "cores": 2560.0
+  },
+  "RX 6700M": {
+   "vram": 10.0,
+   "bw": 320.0,
+   "cores": 2304.0
+  },
+  "RX 6600M": {
+   "vram": 8.0,
+   "bw": 224.0,
+   "cores": 1792.0
+  },
+  "RX 6500M": {
+   "vram": 4.0,
+   "bw": 144.0,
+   "cores": 1024.0
+  },
+  "Ryzen AI MAX+ 395": {
+   "vram": 96.0,
+   "bw": 256.0,
+   "cores": 2560.0
+  },
+  "Radeon 890M": {
+   "vram": 0.0,
+   "bw": 89.0,
+   "cores": 1024.0
+  },
+  "Radeon 880M": {
+   "vram": 0.0,
+   "bw": 89.0,
+   "cores": 768.0
+  },
+  "Radeon 780M": {
+   "vram": 0.0,
+   "bw": 89.0,
+   "cores": 768.0
+  },
+  "Radeon 760M": {
+   "vram": 0.0,
+   "bw": 89.0,
+   "cores": 512.0
+  },
+  "Radeon 680M": {
+   "vram": 0.0,
+   "bw": 77.0,
+   "cores": 768.0
+  },
+  "Radeon 660M": {
+   "vram": 0.0,
+   "bw": 77.0,
+   "cores": 384.0
+  },
+  "Vega 8": {
+   "vram": 0.0,
+   "bw": 51.0,
+   "cores": 512.0
+  },
+  "Vega 7": {
+   "vram": 0.0,
+   "bw": 51.0,
+   "cores": 448.0
+  },
+  "Arc A770M": {
+   "vram": 16.0,
+   "bw": 512.0,
+   "cores": 4096.0
+  },
+  "Arc A550M": {
+   "vram": 8.0,
+   "bw": 224.0,
+   "cores": 2048.0
+  },
+  "Arc A370M": {
+   "vram": 4.0,
+   "bw": 112.0,
+   "cores": 1024.0
+  },
+  "Iris Xe": {
+   "vram": 0.0,
+   "bw": 68.0,
+   "cores": 96.0
+  },
+  "Iris Plus": {
+   "vram": 0.0,
+   "bw": 50.0,
+   "cores": 64.0
+  },
+  "UHD 770": {
+   "vram": 0.0,
+   "bw": 76.0,
+   "cores": 32.0
+  },
+  "UHD 730": {
+   "vram": 0.0,
+   "bw": 76.0,
+   "cores": 24.0
+  },
+  "UHD Graphics 630": {
+   "vram": 0.0,
+   "bw": 42.0,
+   "cores": 24.0
+  },
+  "UHD Graphics 620": {
+   "vram": 0.0,
+   "bw": 34.0,
+   "cores": 24.0
+  }
+ },
+ "apple": {
+  "m5 max": {
+   "ram": 36.0,
+   "bw": 614.0,
+   "cpuCores": 18.0,
+   "gpuCores": 40.0
+  },
+  "m5 pro": {
+   "ram": 24.0,
+   "bw": 307.0,
+   "cpuCores": 18.0,
+   "gpuCores": 20.0
+  },
+  "m5": {
+   "ram": 16.0,
+   "bw": 153.0,
+   "cpuCores": 10.0,
+   "gpuCores": 10.0
+  },
+  "m4 max": {
+   "ram": 36.0,
+   "bw": 546.0,
+   "cpuCores": 16.0,
+   "gpuCores": 40.0
+  },
+  "m4 pro": {
+   "ram": 24.0,
+   "bw": 273.0,
+   "cpuCores": 14.0,
+   "gpuCores": 20.0
+  },
+  "m4": {
+   "ram": 16.0,
+   "bw": 120.0,
+   "cpuCores": 10.0,
+   "gpuCores": 10.0
+  },
+  "m3 ultra": {
+   "ram": 96.0,
+   "bw": 819.0,
+   "cpuCores": 32.0,
+   "gpuCores": 80.0
+  },
+  "m3 max": {
+   "ram": 36.0,
+   "bw": 400.0,
+   "cpuCores": 16.0,
+   "gpuCores": 40.0
+  },
+  "m3 pro": {
+   "ram": 18.0,
+   "bw": 150.0,
+   "cpuCores": 12.0,
+   "gpuCores": 18.0
+  },
+  "m3": {
+   "ram": 8.0,
+   "bw": 100.0,
+   "cpuCores": 8.0,
+   "gpuCores": 10.0
+  },
+  "m2 ultra": {
+   "ram": 64.0,
+   "bw": 800.0,
+   "cpuCores": 24.0,
+   "gpuCores": 76.0
+  },
+  "m2 max": {
+   "ram": 32.0,
+   "bw": 400.0,
+   "cpuCores": 12.0,
+   "gpuCores": 38.0
+  },
+  "m2 pro": {
+   "ram": 16.0,
+   "bw": 200.0,
+   "cpuCores": 12.0,
+   "gpuCores": 19.0
+  },
+  "m2": {
+   "ram": 8.0,
+   "bw": 100.0,
+   "cpuCores": 8.0,
+   "gpuCores": 10.0
+  },
+  "m1 ultra": {
+   "ram": 64.0,
+   "bw": 800.0,
+   "cpuCores": 20.0,
+   "gpuCores": 64.0
+  },
+  "m1 max": {
+   "ram": 32.0,
+   "bw": 400.0,
+   "cpuCores": 10.0,
+   "gpuCores": 32.0
+  },
+  "m1 pro": {
+   "ram": 16.0,
+   "bw": 200.0,
+   "cpuCores": 10.0,
+   "gpuCores": 16.0
+  },
+  "m1": {
+   "ram": 8.0,
+   "bw": 68.0,
+   "cpuCores": 8.0,
+   "gpuCores": 8.0
+  }
+ },
+ "sbc": {
+  "Raspberry Pi 5 (8 GB)": {
+   "ram": 8.0,
+   "bw": 32.0
+  },
+  "Raspberry Pi 5 (4 GB)": {
+   "ram": 4.0,
+   "bw": 32.0
+  },
+  "Raspberry Pi 4 (8 GB)": {
+   "ram": 8.0,
+   "bw": 13.0
+  },
+  "Raspberry Pi 4 (4 GB)": {
+   "ram": 4.0,
+   "bw": 13.0
+  }
+ }
+}

engine/real_advisor.py

@@ -26,6 +26,7 @@ from pathlib import Path
 
 from .hardware import HardwareSpec
 from .runtimes import pick_runtimes
+from .speed import bandwidth_for_spec, predict_decode_tps, feel_text
 
 _CATALOGUE_PATH = Path(__file__).resolve().parent.parent / "catalogue.json"
 
@@ -292,9 +293,29 @@ def _evaluate(entry: dict, spec: HardwareSpec, uc: UC) -> dict:
 # Advise: full UI-shaped result
 # --------------------------------------------------------------------------
 
-def _option_json(r: dict, spec: HardwareSpec) -> dict:
+def _speed_pred(r: dict, spec: HardwareSpec, bw: float | None) -> dict | None:
+    """Measured/roofline tok/s prediction for a GGUF option, if bandwidth known."""
+    e, v, est = r["entry"], r["verdict"], r["est"]
+    if not e.get("quants") or v == "no" or not bw:
+        return None
+    params = e.get("params_b") or 1.0
+    active = (e.get("active_params_b") or params) / params
+    if v == "tight":
+        # share of the read bytes that live in slow system RAM
+        fast_room = spec.fast_budget_gb * _SAFETY_FILL
+        offload = max(0.0, min(1.0, 1 - fast_room / max(est["total"], 0.1)))
+    else:
+        offload = 0.0
+    return predict_decode_tps(
+        bandwidth_gbs=bw, weights_gb=est["weights"], kv_gb=est["kv"],
+        active_fraction=active, offload_fraction=offload,
+    )
+
+
+def _option_json(r: dict, spec: HardwareSpec, bw: float | None = None) -> dict:
     e, v = r["entry"], r["verdict"]
-    feel = _feel(e, v, spec)
+    pred = _speed_pred(r, spec, bw)
+    feel = feel_text(pred) if pred else _feel(e, v, spec)
     if not e.get("quants") and v == "tight" and not spec.has_fast_path:
         feel = "Runs on the processor — slow but workable"
     lic_label = e.get("license", "")
@@ -389,7 +410,8 @@ def advise_real(payload: dict, spec: HardwareSpec) -> dict:
     fast, total = spec.fast_budget_gb, spec.total_budget_gb
     headline, meets_goal = _pick_headline(results, uc)
 
-    options = [_option_json(r, spec) for r in results]
+    bw, bw_src = bandwidth_for_spec(spec)
+    options = [_option_json(r, spec, bw) for r in results]
 
     if headline:
         e, est, q = headline["entry"], headline["est"], headline["quant"]
@@ -457,6 +479,13 @@ def advise_real(payload: dict, spec: HardwareSpec) -> dict:
         ],
     }
 
+    speed = None
+    if headline:
+        pred = _speed_pred(headline, spec, bw)
+        if pred:
+            speed = {**pred, "bw": bw, "bw_source": bw_src,
+                     "model": headline["entry"]["name"]}
+
     if uc.family == "llm":
         tools = [{"name": r.name, "what": r.plain_what, "install": r.install_hint,
                   "tag": r.difficulty} for r in pick_runtimes(spec)]
@@ -485,7 +514,10 @@ def advise_real(payload: dict, spec: HardwareSpec) -> dict:
         "options": options,
         "tools": tools,
         "commands": commands,
-        "provenance": _provenance_line(headline),
+        "provenance": _provenance_line(headline) + (
+            f" Speed is {'predicted from real community measurements' if speed and speed['method'] == 'measured-model' else 'an analytical bandwidth estimate'}"
+            f" — see 'Why this speed?' below." if speed else ""),
+        "speed": speed,
         "meets_goal": meets_goal,
         "use_case": uc.plain_name,
         "headline_model": headline["entry"]["name"] if headline else "",

engine/speed.py

@@ -0,0 +1,201 @@
+"""
+Speed estimation: how fast will it actually feel?
+
+Two-tier design, with provenance the UI always shows:
+
+  1. TRAINED MODEL (when present): an XGBoost regressor trained on real
+     community measurements (LocalScore, ~33k data points), following the
+     methodology of LLM-Pilot (IBM, SC'24, arXiv:2410.02425 — gradient
+     boosting over hardware+model features, validated leave-one-accelerator-
+     out). Loaded from model/speed_model.skops if scripts/train_speed_model.py
+     has been run. method = "measured-model".
+  2. ROOFLINE BASELINE (always available, fully offline): decode is memory-
+     bandwidth-bound — tok/s ~ bandwidth / bytes-read-per-token (weights +
+     KV), times an empirical efficiency factor. See kipply's "Transformer
+     Inference Arithmetic" and the JAX scaling book inference chapter.
+     method = "roofline".
+
+The anti-gimmick rule lives in the training script: the trained model ships
+only if it beats this baseline on held-out hardware; otherwise the baseline
+IS the product and the UI says so.
+
+Scope note (honest): this predicts LLM/VLM decode speed. Vision (YOLO) and
+diffusion models are COMPUTE-bound, not bandwidth-bound — FPS scales with
+TFLOPS / model GFLOPs, a different axis with different data (Ultralytics
+publishes per-size GFLOPs and official T4 latencies; dbgpu has per-GPU
+TFLOPS). That path is designed in SPEED-BRICK-RESEARCH.md §8 but not built;
+non-LLM families keep their provenance-labelled memory verdicts only, rather
+than getting fake speed numbers.
+"""
+
+import json
+import re
+from functools import lru_cache
+from pathlib import Path
+
+_ROOT = Path(__file__).resolve().parent.parent
+_SPECS_PATH = _ROOT / "data" / "gpu_specs.json"
+_MODEL_PATH = _ROOT / "model" / "speed_model.skops"
+
+# Decode efficiency vs theoretical bandwidth roofline. Real stacks land well
+# under the ceiling; 0.55-0.70 is the typical consumer-GPU range in community
+# measurements. We centre conservatively and report a band, never a point.
+_EFF_MID, _EFF_LO, _EFF_HI = 0.60, 0.42, 0.78
+# Conservative system-RAM bandwidth for offload modelling (dual-channel DDR4/5).
+_RAM_BW_GBS = 48.0
+# Reading speed reference: ~4.5 words/s, ~0.75 words per token -> ~6 tok/s.
+_READING_TPS = 6.0
+
+
+@lru_cache(maxsize=1)
+def _specs() -> dict:
+    try:
+        return json.loads(_SPECS_PATH.read_text(encoding="utf-8"))
+    except OSError:
+        return {"gpus": {}, "apple": {}, "sbc": {}}
+
+
+def _norm(s: str) -> str:
+    return re.sub(r"\s+", " ", re.sub(r"[^a-z0-9 ]", " ", (s or "").lower())).strip()
+
+
+@lru_cache(maxsize=1)
+def _bw_index() -> tuple:
+    idx = []
+    for name, d in _specs()["gpus"].items():
+        idx.append((_norm(name), float(d["bw"]), float(d.get("vram", 0))))
+    idx.sort(key=lambda t: -len(t[0]))   # longest first: '4080 super' beats '4080'
+    return tuple(idx)
+
+
+# Apple chips: the UI only knows base/Pro/Max/Ultra, not the generation. We use
+# M2-generation numbers as the conservative representative (older = slower).
+_APPLE_TIER_BW = None
+
+
+def _apple_bw(tier_hint: str) -> float:
+    global _APPLE_TIER_BW
+    if _APPLE_TIER_BW is None:
+        a = {k: v["bw"] for k, v in _specs()["apple"].items()}
+        _APPLE_TIER_BW = {
+            "ultra": a.get("m2 ultra") or a.get("m1 ultra") or 800.0,
+            "max": a.get("m2 max") or 400.0,
+            "pro": a.get("m2 pro") or 200.0,
+            "base": a.get("m2") or 100.0,
+        }
+    t = (tier_hint or "").lower()
+    for key in ("ultra", "max", "pro"):
+        if key in t:
+            return _APPLE_TIER_BW[key]
+    return _APPLE_TIER_BW["base"]
+
+
+def bandwidth_for_spec(spec, gpu_label: str = "") -> tuple[float | None, str]:
+    """(memory bandwidth GB/s on the fast path, source-note) for a machine."""
+    if spec.is_apple_silicon:
+        return _apple_bw(gpu_label or spec.gpu_label), "Apple unified memory (conservative M2-gen figure)"
+    if spec.gpu_vendor in ("nvidia", "amd", "intel") and spec.vram_gb > 0:
+        n = _norm(gpu_label or spec.gpu_label)
+        for key, bw, vram in _bw_index():
+            if key and key in n:
+                # disambiguate VRAM variants (e.g. 5060 Ti 8 vs 16 GB)
+                if vram and spec.vram_gb and abs(vram - spec.vram_gb) > 4:
+                    continue
+                return bw, "vendor spec sheet"
+        return None, ""
+    return None, ""
+
+
+# --------------------------------------------------------------------------
+# Trained model (optional, loaded if scripts/train_speed_model.py produced it)
+# --------------------------------------------------------------------------
+
+@lru_cache(maxsize=1)
+def _trained_model():
+    if not _MODEL_PATH.exists():
+        return None
+    try:
+        from skops.io import load as skops_load
+        model = skops_load(_MODEL_PATH, trusted=None)
+        print(f"[FitCheck] speed predictor loaded from {_MODEL_PATH.name}", flush=True)
+        return model
+    except Exception as e:  # noqa: BLE001
+        # The file exists but won't load — say so loudly (a silent fallback
+        # here would hide a broken deploy behind plausible roofline numbers).
+        import sys
+        print(f"[FitCheck] WARNING: {_MODEL_PATH.name} exists but failed to "
+              f"load ({e!r}) — falling back to the labelled roofline estimate",
+              file=sys.stderr, flush=True)
+        return None
+
+
+# --------------------------------------------------------------------------
+# Prediction
+# --------------------------------------------------------------------------
+
+def predict_decode_tps(
+    *,
+    bandwidth_gbs: float,
+    weights_gb: float,
+    kv_gb: float = 0.0,
+    active_fraction: float = 1.0,
+    offload_fraction: float = 0.0,
+) -> dict:
+    """Predict decode tokens/sec.
+
+    active_fraction: MoE models only read their active experts per token.
+    offload_fraction: share of the model living in system RAM (0 = all on GPU).
+    """
+    # Bytes read per generated token: the (active) weights + the KV cache.
+    bytes_gb = max(weights_gb * active_fraction + kv_gb, 0.05)
+    if active_fraction < 0.9:
+        # MoE conservatism: expert routing scatters reads across the full
+        # weight file, so real MoE decode lands well under the active-bytes
+        # ideal. 1.5x is a deliberate under-promise until measured data
+        # corrects it (community MoE numbers run ~50-70% of ideal).
+        bytes_gb *= 1.5
+
+    eff_bw = bandwidth_gbs
+    if offload_fraction > 0:
+        f = min(max(offload_fraction, 0.0), 1.0)
+        eff_bw = 1.0 / ((1.0 - f) / bandwidth_gbs + f / _RAM_BW_GBS)
+
+    model = _trained_model()
+    if model is not None:
+        try:
+            import numpy as np
+            x = np.array([[eff_bw, bytes_gb, weights_gb, kv_gb,
+                           active_fraction, offload_fraction,
+                           eff_bw / bytes_gb]])
+            tps = float(model.predict(x)[0])
+            return {"tps": round(tps, 1),
+                    "lo": round(tps * 0.8, 1), "hi": round(tps * 1.2, 1),
+                    "bytes_gb": round(bytes_gb, 2), "eff_bw": round(eff_bw, 1),
+                    "method": "measured-model",
+                    "note": ("predicted by a model trained on real community "
+                             "measurements (LocalScore), LLM-Pilot methodology")}
+        except Exception:  # noqa: BLE001 — fall through to roofline
+            pass
+
+    base = eff_bw / bytes_gb
+    return {"tps": round(base * _EFF_MID, 1),
+            "lo": round(base * _EFF_LO, 1), "hi": round(base * _EFF_HI, 1),
+            "bytes_gb": round(bytes_gb, 2), "eff_bw": round(eff_bw, 1),
+            "method": "roofline",
+            "note": ("analytical estimate: decode speed is memory-bandwidth-bound "
+                     "(bandwidth divided by bytes read per token)")}
+
+
+def feel_text(pred: dict) -> str:
+    """One honest, plain-English line from a prediction."""
+    tps = pred["tps"]
+    lo, hi = pred["lo"], pred["hi"]
+    if tps >= _READING_TPS * 4:
+        speed_word = "much faster than you read"
+    elif tps >= _READING_TPS * 1.5:
+        speed_word = "faster than you read"
+    elif tps >= _READING_TPS * 0.7:
+        speed_word = "about reading speed"
+    else:
+        speed_word = "slower than reading — fine for short tasks"
+    return f"~{tps:g} tok/s (likely {lo:g}-{hi:g}) — {speed_word}"

engine/ui_adapter.py

@@ -75,10 +75,11 @@ def spec_from_payload(p: dict) -> HardwareSpec:
 
     # --- Apple Silicon: unified memory, no separate VRAM -------------------
     if "mac" in kind or provider == "apple":
+        chip = p.get("gpu") or "Apple Silicon"   # keep the tier (Pro/Max/Ultra) for bandwidth lookup
         return HardwareSpec(
             os="macos", ram_gb=ram, gpu_vendor="apple", vram_gb=0.0,
             is_apple_silicon=True,
-            gpu_label=f"Apple Silicon (shares your {ram:g} GB of memory)",
+            gpu_label=f"{chip} (shares your {ram:g} GB of memory)",
             form_factor="mac",
         )
 

requirements.txt

@@ -12,3 +12,5 @@ kernels>=0.12.0,<0.13     # transformers' own declared range — 0.15.x broke
                           # mamba-ssm/causal-conv1d here, the build will fail)
 accelerate                # device placement / efficient loading
 einops                    # required by the kernels-community mamba-ssm kernel
+skops                     # safe loading of the trained speed predictor
+xgboost                   # the speed predictor's runtime (engine/speed.py)

static/app.js

@@ -438,6 +438,25 @@ function render(d) {
         ${d.provenance ? `<div class="prov">${d.provenance}</div>` : ""}
       </div>` : ""}
 
+      ${d.speed ? `
+      <details class="disc viz-disc" open>
+        <summary><span class="ic sum-ic" data-ic="speed"></span>Why this speed? <span class="sub-inline">real benchmark runs, and where you land</span> <span class="chev ic" data-ic="chevron"></span></summary>
+        <div class="disc-body">
+          <div id="roofline-chart" class="roofline-wrap"></div>
+          <p class="viz-caption">
+            Every grey dot is a <b>real benchmark run</b> from the
+            <a href="https://www.localscore.ai" target="_blank" rel="noopener">LocalScore</a> community database.
+            Generation speed tracks <b>memory bandwidth</b> — that's the one number that matters most for local AI
+            (<a href="https://kipp.ly/transformer-inference-arithmetic/" target="_blank" rel="noopener">why</a>).
+            The dashed line is the theoretical ceiling for <b>${d.speed.model}</b> at your setting;
+            your machine is the marked dot at ≈<b>${d.speed.tps} tok/s</b>
+            (${d.speed.method === "measured-model"
+              ? `predicted by a model trained on these measurements, following IBM's <a href="https://arxiv.org/abs/2410.02425" target="_blank" rel="noopener">LLM-Pilot</a> methodology`
+              : `an analytical estimate; a learned predictor trained on these runs — <a href="https://arxiv.org/abs/2410.02425" target="_blank" rel="noopener">LLM-Pilot</a> methodology — takes over once trained`}).
+          </p>
+        </div>
+      </details>` : ""}
+
       ${opts ? `<div class="section-title">What you can run <span class="sub">real models, biggest to smallest — names link to Hugging Face</span></div>
       <div class="opt-grid">${opts}</div>` : ""}
 
@@ -472,6 +491,7 @@ function render(d) {
     $("#results").firstElementChild.prepend(back);
   }
   hydrate($("#results"));
+  if (d.speed) drawRoofline(d.speed);
   $("#results").querySelectorAll(".copy-btn").forEach(b => b.addEventListener("click", () => {
     navigator.clipboard.writeText(decodeURIComponent(b.dataset.code));
     b.textContent = "Copied ✓"; b.classList.add("done");
@@ -480,6 +500,73 @@ function render(d) {
   wireAsk();
 }
 
+// ---- "Why this speed?" roofline scatter (real LocalScore runs) ------------
+let _rooflinePts = null;
+async function getRooflinePoints() {
+  if (_rooflinePts) return _rooflinePts;
+  try {
+    const r = await fetch("/static/roofline.json");
+    _rooflinePts = await r.json();
+  } catch (e) { _rooflinePts = { points: [] }; }
+  return _rooflinePts;
+}
+
+async function drawRoofline(speed) {
+  const host = $("#roofline-chart");
+  if (!host) return;
+  const data = await getRooflinePoints();
+  const pts = (data.points || []).filter(p => p.bw > 0 && p.tps > 0.5);
+  if (!pts.length && !speed) { host.innerHTML = ""; return; }
+
+  const W = 720, H = 320, L = 52, R = 16, T = 14, B = 40;
+  const xmin = 40, xmax = 2100, ymin = 0.8, ymax = 400;
+  const lx = v => L + (Math.log10(v) - Math.log10(xmin)) / (Math.log10(xmax) - Math.log10(xmin)) * (W - L - R);
+  const ly = v => H - B - (Math.log10(v) - Math.log10(ymin)) / (Math.log10(ymax) - Math.log10(ymin)) * (H - T - B);
+
+  let s = `<svg viewBox="0 0 ${W} ${H}" role="img" aria-label="Decode speed vs memory bandwidth, real benchmark runs">`;
+  // gridlines + labels
+  for (const gx of [50, 100, 200, 400, 800, 1600]) {
+    s += `<line x1="${lx(gx)}" y1="${T}" x2="${lx(gx)}" y2="${H - B}" class="rl-grid"/>` +
+         `<text x="${lx(gx)}" y="${H - B + 16}" class="rl-tick" text-anchor="middle">${gx}</text>`;
+  }
+  for (const gy of [1, 3, 10, 30, 100, 300]) {
+    s += `<line x1="${L}" y1="${ly(gy)}" x2="${W - R}" y2="${ly(gy)}" class="rl-grid"/>` +
+         `<text x="${L - 6}" y="${ly(gy) + 4}" class="rl-tick" text-anchor="end">${gy}</text>`;
+  }
+  s += `<text x="${(L + W - R) / 2}" y="${H - 6}" class="rl-axis" text-anchor="middle">memory bandwidth (GB/s, log)</text>`;
+  s += `<text x="14" y="${(T + H - B) / 2}" class="rl-axis" text-anchor="middle" transform="rotate(-90 14 ${(T + H - B) / 2})">decode tok/s (log)</text>`;
+
+  // real measurement dots, shaded by model size
+  const shade = p => p.params_b <= 2 ? "rl-p1" : (p.params_b <= 9 ? "rl-p8" : "rl-p14");
+  for (const p of pts) {
+    if (p.bw < xmin || p.tps < ymin) continue;
+    s += `<circle cx="${lx(Math.min(p.bw, xmax)).toFixed(1)}" cy="${ly(Math.min(p.tps, ymax)).toFixed(1)}" r="2.6" class="rl-dot ${shade(p)}"><title>${p.accel} — ${p.model}: ${p.tps} tok/s</title></circle>`;
+  }
+
+  if (speed) {
+    // theoretical ceiling for the recommended model: tps = 0.6 * bw / bytes
+    const bytes = speed.bytes_gb || 5;
+    const x1 = xmin, x2 = xmax;
+    const f = bw => Math.min(Math.max(0.6 * bw / bytes, ymin), ymax);
+    s += `<line x1="${lx(x1)}" y1="${ly(f(x1))}" x2="${lx(x2)}" y2="${ly(f(x2))}" class="rl-roof"/>`;
+    // your machine
+    const ux = lx(Math.min(Math.max(speed.eff_bw || speed.bw, xmin), xmax));
+    const uy = ly(Math.min(Math.max(speed.tps, ymin), ymax));
+    s += `<line x1="${ux}" y1="${ly(Math.min(Math.max(speed.lo, ymin), ymax))}" x2="${ux}" y2="${ly(Math.min(Math.max(speed.hi, ymin), ymax))}" class="rl-band"/>`;
+    s += `<circle cx="${ux}" cy="${uy}" r="6" class="rl-you"/>` +
+         `<text x="${ux + 10}" y="${uy + 4}" class="rl-you-label">you ≈${speed.tps} tok/s</text>`;
+  }
+  s += `</svg>
+    <div class="rl-legend">
+      <span class="item"><span class="sw rl-p1-sw"></span>~1B model runs</span>
+      <span class="item"><span class="sw rl-p8-sw"></span>~8B runs</span>
+      <span class="item"><span class="sw rl-p14-sw"></span>~14B runs</span>
+      <span class="item"><span class="sw rl-roof-sw"></span>theoretical ceiling (your pick)</span>
+      <span class="item"><span class="sw rl-you-sw"></span>your machine</span>
+    </div>`;
+  host.innerHTML = s;
+}
+
 // ---- Follow-up: the model brick (grounded explainer) ---------------------
 function wireAsk() {
   const input = $("#ask-input"), send = $("#ask-send");
@@ -572,7 +659,20 @@ function init() {
   fillGpu();
   $("#find-specs-body").innerHTML = findSpecsText();
   detectHardware();
-  // Pre-filled share/preview links: /?go renders results immediately.
-  if (new URLSearchParams(location.search).has("go")) check();
+  // Pre-filled share/preview links: ?go renders immediately; optional
+  // ?gpu=NVIDIA|RTX 3060 (12 GB)&ram=16&uc=chat pre-select a profile.
+  const q = new URLSearchParams(location.search);
+  if (q.has("gpu")) {
+    const [vendor, label] = (q.get("gpu") || "").split("|");
+    if (vendor) { state.provider = vendor.toLowerCase(); setActive("#provider-seg", state.provider); fillGpu(); }
+    if (label) { const sel = $("#gpu"); [...sel.options].forEach(o => { if (o.value === label) sel.value = label; }); }
+  }
+  if (q.has("ram")) $("#ram").value = `${q.get("ram")} GB`;
+  if (q.has("uc")) {
+    state.usecases = [q.get("uc")];
+    document.querySelectorAll(".uc-pill").forEach(p =>
+      p.classList.toggle("active", p.dataset.uc === q.get("uc")));
+  }
+  if (q.has("go")) check();
 }
 init();

static/style.css

@@ -377,6 +377,29 @@ details.disc > summary:hover { color: var(--text-primary); }
 .copy-btn:hover { color: var(--text-primary); border-color: var(--border-hi); }
 .copy-btn.done { color: var(--ok); border-color: var(--ok); }
 
+/* "Why this speed?" roofline visualizer */
+.viz-disc { margin-top: var(--s-5); background: var(--bg-raised); }
+.viz-disc > summary .sub-inline { font-weight: 500; color: var(--text-muted); font-size: 12.5px; margin-left: 4px; }
+.roofline-wrap svg { width: 100%; height: auto; display: block; }
+.rl-grid { stroke: var(--border); stroke-width: 1; opacity: .5; }
+.rl-tick { fill: var(--text-muted); font: 500 10.5px var(--font-body); }
+.rl-axis { fill: var(--text-secondary); font: 600 11.5px var(--font-body); }
+.rl-dot { opacity: .55; }
+.rl-p1 { fill: #5B6472; }
+.rl-p8 { fill: #8B93A3; }
+.rl-p14 { fill: #B9C0CC; }
+.rl-roof { stroke: var(--warn); stroke-width: 1.8; stroke-dasharray: 6 5; opacity: .9; }
+.rl-band { stroke: var(--accent); stroke-width: 5; opacity: .35; stroke-linecap: round; }
+.rl-you { fill: var(--accent); stroke: #fff; stroke-width: 1.5; }
+.rl-you-label { fill: var(--text-primary); font: 700 12px var(--font-head); }
+.rl-legend { display: flex; flex-wrap: wrap; gap: var(--s-4); margin-top: var(--s-2); font-size: 12px; color: var(--text-muted); }
+.rl-legend .item { display: inline-flex; align-items: center; gap: 6px; }
+.rl-legend .sw { width: 10px; height: 10px; border-radius: 50%; }
+.rl-p1-sw { background: #5B6472; } .rl-p8-sw { background: #8B93A3; } .rl-p14-sw { background: #B9C0CC; }
+.rl-roof-sw { background: var(--warn); border-radius: 2px; height: 3px; width: 14px; }
+.rl-you-sw { background: var(--accent); }
+.viz-caption { font-size: 13px; color: var(--text-secondary); line-height: 1.6; margin-top: var(--s-3); }
+
 /* Multi-goal overview */
 .goal-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(230px, 1fr)); gap: var(--s-3); }
 .goal-card {