Spaces:

CompactAI-O
/

CompactAI-Papers

Running

App Files Files Community

CompactAI commited on 5 days ago

Commit

c23a2bb

verified ·

1 Parent(s): c65db4f

Upload index.html

Browse files

Files changed (1) hide show

index.html +1376 -18

index.html CHANGED Viewed

@@ -1,19 +1,1377 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
 </html>

+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>CompactAI Papers</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Geist:wght@300..700&family=Geist+Mono:wght@400;500&display=swap" rel="stylesheet">
+  <style>
+    *,
+    *::before,
+    *::after {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    :root {
+      --bg: #000000;
+      --bg-card: #0a0a0a;
+      --bg-card-hover: #0f0f0f;
+      --border-card: #1a1a1a;
+      --text: #ffffff;
+      --text-soft: #f5f5f5;
+      --text-muted: #888888;
+      --text-dim: #555555;
+      --accent: #c8960c;
+      --accent-bright: #ffd633;
+      --accent-muted: #8b6508;
+      --gold-gradient: linear-gradient(135deg, #ffd633 0%, #c8960c 50%, #a0760a 100%);
+      --grid-line: rgba(255, 255, 255, 0.03);
+      --grid-line-major: rgba(255, 255, 255, 0.06);
+      --container-max: none;
+    }
+    html {
+      scroll-behavior: smooth;
+      background: var(--bg);
+    }
+    /* ---- Focus styles ---- */
+    :focus-visible {
+      outline: 2px solid var(--accent-bright);
+      outline-offset: 3px;
+      border-radius: 4px;
+    }
+    .paper-card:focus-visible {
+      outline: 2px solid var(--accent-bright);
+      outline-offset: 2px;
+      border-radius: 12px;
+    }
+    .paper-view-close:focus-visible {
+      outline: 2px solid var(--accent-bright);
+      outline-offset: 2px;
+      border-radius: 8px;
+    }
+    /* ---- Skip link ---- */
+    .skip-link {
+      position: fixed;
+      top: 0;
+      left: 0;
+      z-index: 200;
+      padding: 12px 20px;
+      background: var(--accent);
+      color: #000;
+      font-family: 'Geist', sans-serif;
+      font-size: 14px;
+      font-weight: 600;
+      text-decoration: none;
+      border-radius: 0 0 8px 0;
+      transform: translateY(-100%);
+      transition: transform 0.15s ease;
+    }
+    .skip-link:focus {
+      transform: translateY(0);
+    }
+    /* ---- Screen reader only ---- */
+    .sr-only {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      margin: -1px;
+      overflow: hidden;
+      clip: rect(0, 0, 0, 0);
+      white-space: nowrap;
+      border: 0;
+    }
+    /* ---- Reduced motion ---- */
+    @media (prefers-reduced-motion: reduce) {
+      *,
+      *::before,
+      *::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+      }
+      html {
+        scroll-behavior: auto;
+      }
+    }
+    body {
+      background: var(--bg);
+      color: var(--text);
+      font-family: 'Geist', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+      font-size: 16px;
+      font-weight: 350;
+      line-height: 1.7;
+      min-height: 100vh;
+      position: relative;
+      overflow-x: hidden;
+    }
+    /* ---- Dot grid background ---- */
+    body::before {
+      content: '';
+      position: fixed;
+      inset: 0;
+      pointer-events: none;
+      z-index: 0;
+      background-image:
+        radial-gradient(circle, var(--grid-line) 1px, transparent 1px);
+      background-size: 40px 40px;
+      mask-image: radial-gradient(ellipse 70% 70% at 50% 0%, black 30%, transparent 70%);
+      -webkit-mask-image: radial-gradient(ellipse 70% 70% at 50% 0%, black 30%, transparent 70%);
+    }
+    body::after {
+      content: '';
+      position: fixed;
+      inset: 0;
+      pointer-events: none;
+      z-index: 0;
+      background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 256 256' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='noise'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23noise)' opacity='0.02'/%3E%3C/svg%3E");
+      opacity: 0.4;
+    }
+    /* ---- Container ---- */
+    .container {
+      position: relative;
+      z-index: 1;
+      max-width: var(--container-max);
+      margin: 0 auto;
+      padding: 0 40px;
+    }
+    /* ---- Header ---- */
+    .site-header {
+      padding: 80px 0 48px;
+      text-align: center;
+      position: relative;
+    }
+    .site-title {
+      font-family: 'Geist', sans-serif;
+      font-size: clamp(48px, 8vw, 80px);
+      font-weight: 700;
+      letter-spacing: -0.03em;
+      line-height: 1.05;
+      color: var(--text);
+      animation: fadeUp 0.8s ease-out both;
+    }
+    .site-title .gold {
+      background: var(--gold-gradient);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+    }
+    .site-subtitle {
+      font-family: 'Geist Mono', monospace;
+      font-size: 13px;
+      font-weight: 400;
+      letter-spacing: 0.12em;
+      text-transform: uppercase;
+      color: var(--text-dim);
+      margin-top: 16px;
+      animation: fadeUp 0.8s 0.15s ease-out both;
+    }
+    .header-divider {
+      width: 60px;
+      height: 1px;
+      background: var(--gold-gradient);
+      margin: 32px auto 0;
+      opacity: 0.5;
+      animation: fadeUp 0.8s 0.2s ease-out both;
+    }
+    @keyframes fadeUp {
+      from { opacity: 0; transform: translateY(20px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+    /* ---- Section label ---- */
+    .section-label {
+      font-family: 'Geist Mono', monospace;
+      font-size: 11px;
+      font-weight: 500;
+      letter-spacing: 0.14em;
+      text-transform: uppercase;
+      color: var(--text-dim);
+      margin-bottom: 24px;
+      padding-left: 2px;
+    }
+    /* ---- Paper Grid ---- */
+    .papers-grid {
+      display: grid;
+      grid-template-columns: repeat(3, 1fr);
+      gap: 28px;
+      padding-bottom: 96px;
+      list-style: none;
+    }
+    @media (max-width: 1100px) {
+      .papers-grid {
+        grid-template-columns: repeat(2, 1fr);
+      }
+    }
+    @media (max-width: 600px) {
+      .papers-grid {
+        grid-template-columns: 1fr;
+      }
+    }
+    /* ---- Paper Card (catalog) ---- */
+    .paper-card {
+      position: relative;
+      background: var(--bg-card);
+      border: 1px solid var(--border-card);
+      border-radius: 12px;
+      padding: 32px 36px;
+      cursor: pointer;
+      min-height: 180px;
+      display: flex;
+      flex-direction: column;
+      justify-content: space-between;
+      transition: all 0.35s ease;
+      overflow: hidden;
+      animation: fadeUp 0.6s ease-out both;
+    }
+    .paper-card::before {
+      content: '';
+      position: absolute;
+      inset: 0;
+      border-radius: 12px;
+      background: radial-gradient(
+        600px circle at var(--mx, 50%) var(--my, 50%),
+        rgba(200, 150, 12, 0.06),
+        transparent 40%
+      );
+      opacity: 0;
+      transition: opacity 0.4s ease;
+      pointer-events: none;
+    }
+    .paper-card:hover {
+      border-color: rgba(200, 150, 12, 0.3);
+      background: var(--bg-card-hover);
+      transform: translateY(-2px);
+      box-shadow:
+        0 20px 60px rgba(0, 0, 0, 0.4),
+        0 0 0 1px rgba(200, 150, 12, 0.08);
+    }
+    .paper-card:hover::before {
+      opacity: 1;
+    }
+    .paper-card:active {
+      transform: translateY(0);
+      transition: all 0.1s ease;
+    }
+    .card-title {
+      font-family: 'Geist', sans-serif;
+      font-size: 20px;
+      font-weight: 600;
+      letter-spacing: -0.02em;
+      line-height: 1.3;
+      color: var(--text);
+      margin-bottom: 10px;
+    }
+    .card-author {
+      font-family: 'Geist Mono', monospace;
+      font-size: 11px;
+      font-weight: 500;
+      letter-spacing: 0.06em;
+      color: var(--accent-muted);
+      margin-bottom: 8px;
+    }
+    .card-meta {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      font-family: 'Geist Mono', monospace;
+      font-size: 12px;
+      color: var(--text-dim);
+    }
+    .card-tag {
+      font-family: 'Geist Mono', monospace;
+      font-size: 10px;
+      font-weight: 500;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      color: var(--accent-muted);
+      background: rgba(200, 150, 12, 0.08);
+      padding: 3px 8px;
+      border-radius: 4px;
+      border: 1px solid rgba(200, 150, 12, 0.12);
+    }
+    .card-arrow {
+      position: absolute;
+      right: 24px;
+      top: 50%;
+      transform: translateY(-50%);
+      font-size: 20px;
+      color: var(--text-dim);
+      opacity: 0;
+      transition: all 0.3s ease;
+    }
+    .paper-card:hover .card-arrow {
+      opacity: 1;
+      color: var(--accent);
+    }
+    /* ---- Modal / Paper View ---- */
+    .paper-overlay {
+      position: fixed;
+      inset: 0;
+      z-index: 100;
+      background: rgba(0, 0, 0, 0.9);
+      backdrop-filter: blur(12px);
+      -webkit-backdrop-filter: blur(12px);
+      display: flex;
+      align-items: flex-start;
+      justify-content: center;
+      padding: 0;
+      overflow-y: auto;
+      animation: overlayIn 0.25s ease-out;
+    }
+    @keyframes overlayIn {
+      from { opacity: 0; }
+      to { opacity: 1; }
+    }
+    .paper-view {
+      background: #0d0d0d;
+      border: none;
+      border-radius: 0;
+      max-width: none;
+      width: 100%;
+      min-height: 100vh;
+      padding: 64px clamp(32px, 8vw, 120px) 80px;
+      position: relative;
+      animation: modalIn 0.35s ease-out;
+      box-shadow: none;
+    }
+    @keyframes modalIn {
+      from { opacity: 0; transform: translateY(24px) scale(0.97); }
+      to { opacity: 1; transform: translateY(0) scale(1); }
+    }
+    .paper-view-close {
+      position: fixed;
+      top: 24px;
+      right: 24px;
+      width: 40px;
+      height: 40px;
+      border-radius: 8px;
+      border: 1px solid var(--border-card);
+      background: rgba(10, 10, 10, 0.9);
+      backdrop-filter: blur(8px);
+      -webkit-backdrop-filter: blur(8px);
+      color: var(--text-muted);
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 20px;
+      font-family: 'Geist Mono', monospace;
+      transition: all 0.2s ease;
+      z-index: 10;
+    }
+    .paper-view-close:hover {
+      border-color: rgba(200, 150, 12, 0.4);
+      color: var(--accent);
+      background: #111;
+    }
+    .paper-view-loading {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 200px;
+      flex-direction: column;
+      gap: 16px;
+    }
+    .loading-spinner {
+      width: 32px;
+      height: 32px;
+      border: 2px solid var(--border-card);
+      border-top-color: var(--accent);
+      border-radius: 50%;
+      animation: spin 0.8s linear infinite;
+    }
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+    /* ---- Paper Body (inside modal) ---- */
+    .paper-body {
+      color: var(--text-soft);
+      max-width: 900px;
+      margin: 0 auto;
+    }
+    .paper-body h1 {
+      font-family: 'Geist', sans-serif;
+      font-size: 2rem;
+      font-weight: 700;
+      letter-spacing: -0.03em;
+      line-height: 1.2;
+      color: var(--text);
+      margin-bottom: 8px;
+    }
+    .paper-body h2 {
+      font-family: 'Geist', sans-serif;
+      font-size: 1.3rem;
+      font-weight: 600;
+      letter-spacing: -0.02em;
+      color: var(--text-soft);
+      margin: 36px 0 12px;
+      padding-bottom: 8px;
+      border-bottom: 1px solid var(--border-card);
+    }
+    .paper-body h2:first-child {
+      margin-top: 0;
+    }
+    .paper-body h3 {
+      font-family: 'Geist', sans-serif;
+      font-size: 1.05rem;
+      font-weight: 600;
+      color: var(--text-muted);
+      margin: 22px 0 8px;
+    }
+    .paper-body p {
+      margin-bottom: 14px;
+      line-height: 1.75;
+    }
+    .paper-body ol,
+    .paper-body ul {
+      margin: 0 0 14px 24px;
+    }
+    .paper-body li {
+      margin-bottom: 6px;
+    }
+    .paper-body strong {
+      font-weight: 600;
+      color: var(--text);
+    }
+    .paper-body em {
+      font-style: italic;
+    }
+    .paper-body code {
+      font-family: 'Geist Mono', monospace;
+      font-size: 0.82em;
+      background: rgba(255, 255, 255, 0.05);
+      padding: 2px 7px;
+      border-radius: 4px;
+      border: 1px solid var(--border-card);
+      color: var(--accent);
+    }
+    .paper-body hr {
+      border: none;
+      border-top: 1px solid var(--border-card);
+      margin: 28px 0;
+    }
+    .paper-body blockquote {
+      border-left: 2px solid var(--accent-muted);
+      padding-left: 16px;
+      margin: 18px 0;
+      color: var(--text-muted);
+      font-style: italic;
+    }
+    /* ---- Credit section ---- */
+    .paper-credit {
+      margin-top: 40px;
+      padding-top: 20px;
+      border-top: 1px solid var(--border-card);
+      font-family: 'Geist Mono', monospace;
+      font-size: 13px;
+      color: var(--text-dim);
+      text-align: right;
+      letter-spacing: 0.04em;
+    }
+    .paper-credit .credit-label {
+      font-style: italic;
+    }
+    .paper-credit .credit-names {
+      font-weight: 500;
+      color: var(--text-muted);
+    }
+    /* ---- Papermaker callout ---- */
+    .papermaker-callout {
+      text-align: center;
+      padding: 48px 24px 32px;
+      max-width: 560px;
+      margin: 0 auto;
+    }
+    .papermaker-callout p {
+      font-family: 'Geist', sans-serif;
+      font-size: 14px;
+      font-weight: 350;
+      line-height: 1.6;
+      color: var(--text-dim);
+    }
+    .papermaker-callout .role-name {
+      font-family: 'Geist Mono', monospace;
+      font-weight: 500;
+      color: var(--accent-muted);
+    }
+    /* ---- Footer ---- */
+    .site-footer {
+      text-align: center;
+      padding: 0 0 64px;
+      font-family: 'Geist Mono', monospace;
+      font-size: 11px;
+      letter-spacing: 0.1em;
+      text-transform: uppercase;
+      color: var(--text-dim);
+      opacity: 0.5;
+    }
+    /* ---- Empty State ---- */
+    .empty-state {
+      text-align: center;
+      padding: 80px 24px;
+      grid-column: 1 / -1;
+    }
+    .empty-state p {
+      font-size: 16px;
+      color: var(--text-dim);
+      font-style: italic;
+    }
+    /* ---- Error State ---- */
+    .error-banner {
+      text-align: center;
+      padding: 60px 24px;
+      grid-column: 1 / -1;
+    }
+    .error-banner p {
+      font-family: 'Geist Mono', monospace;
+      font-size: 13px;
+      color: var(--text-dim);
+    }
+    /* ---- Responsive ---- */
+    @media (max-width: 640px) {
+      .container {
+        padding: 0 20px;
+      }
+      .site-header {
+        padding: 56px 0 36px;
+      }
+      .site-title {
+        font-size: clamp(36px, 10vw, 56px);
+      }
+      .paper-card {
+        padding: 22px 24px;
+        min-height: 140px;
+      }
+      .paper-view {
+        padding: 32px 20px;
+        min-height: auto;
+      }
+      .papers-grid {
+        gap: 12px;
+      }
+    }
+    @media print {
+      body {
+        background: white;
+        color: black;
+      }
+      body::before,
+      body::after {
+        display: none;
+      }
+      .paper-overlay {
+      position: static;
+      background: none;
+      backdrop-filter: none;
+    }
+    .paper-view {
+      background: white;
+      color: black;
+      box-shadow: none;
+      border: none;
+      min-height: auto;
+      padding: 24px 0;
+      position: static;
+      animation: none;
+    }
+      .paper-view-close {
+        display: none;
+      }
+    }
+  </style>
+</head>
+<body>
+  <a href="#mainContent" class="skip-link">Skip to papers</a>
+  <div class="sr-only" aria-live="polite" aria-atomic="true" id="announcer"></div>
+  <header class="site-header">
+    <div class="container">
+      <h1 class="site-title">Compact<span class="gold">AI</span> Papers</h1>
+      <p class="site-subtitle">Research &amp; ideas from the community</p>
+      <div class="header-divider"></div>
+    </div>
+  </header>
+  <main class="container" id="mainContent" aria-label="Papers collection">
+    <h2 class="section-label">Papers</h2>
+    <ul class="papers-grid" id="papersGrid" role="list"></ul>
+  </main>
+  <section class="papermaker-callout" aria-label="Papermaker role">
+    <p>Have an idea worth writing up? If a mod spots it and likes it, you might earn the <span class="role-name">@Papermaker</span> role &mdash; a nod that you helped push CompactAI forward.</p>
+  </section>
+  <footer class="site-footer">
+    <div class="container">
+      <span>CompactAI</span>
+    </div>
+  </footer>
+  <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+  <script type="text/markdown" id="paper-STM_paper-md"># STM and the Circle Thing
+## what STM actually is
+STM stands for Subtractive Training Method. It's still experimental — nobody in the chat has proven it works in practice yet, people keep daring each other to "do stm" on a checkpoint and see what falls out. The premise though is pretty simple, almost annoyingly so once you hear it.
+Normally when you train a model you shove the whole dataset at it for an epoch, watch the loss drop, then do it again. STM says: after that first pass, don't just rerun the same data. Look at WHICH samples caused the biggest sudden drops in loss, and yank those out. Keep the rest. Train again. Repeat.
+The reasoning, in the words of the person who proposed it in the channel: a sample that produces a huge plummet in loss is basically the model going "oh yeah I got that one." Any more gradient steps on that sample after that point are mostly memorization — the model is just carving that exact example deeper into its weights, not learning anything generalizable from it. Wasteful. The samples that bring loss down slowly and gradually, on the other hand, are the ones the model is genuinely *figuring out*. Those are where generalization comes from, so you let it keep chewing on them.
+So you end up with a shrinking dataset every epoch. The easy stuff drops away. What's left is the stuff the model still has to actually think about.
+A pretty common follow up from people in the thread was "wait, so generalization happens with stm?" and the answer was basically yeah, that's the bet. You're trying to bias training toward generalization by starving it of the samples it would otherwise overfit to.
+…People in chat noted that this isn't quite the same as hard-example mining or curriculum learning, even though it rhymes with them. Curriculum learning typically *adds* harder samples over time. STM doesn't add anything — it only ever removes. The dataset is monotonically shrinking. You start with everything and trim down to the residue of stuff that's actually hard for this specific model. So the "curriculum" emerges from what's left rather than from a schedule somebody hand-designed.
+Also, the criterion isn't "the loss is currently high on this sample." It's "the loss DROPPED a lot on this sample" — a derivative thing, not a level thing. A sample can have low absolute loss and still be valuable if its loss has been decreasing gradually rather than collapsing. Conversely a sample with high loss but a sudden crash gets cut.
+## the other circle thing (Apollonian gasket, for the record)
+Worth disambiguating because the same channel has been throwing around a totally separate "circles" idea — storing token embeddings as addresses inside an integer Apollonian gasket, keyed by prime tuples from a twin-prime engine. Each token maps to a circle via f: token → (p₁, p₂), twin primes become semantic neighbors "for free" because the +2 gap is the local Apollonian step, the weight matrix becomes the curvature graph, etc. Inference becomes a bounded curvature recall — truncate by curvature ≤ K, filter by primality, verify Descartes-consistency.
+This is NOT the same circle the STM phase is talking about. The gasket is a representation/storage idea for embeddings. Circling is a data-selection pass during training. They could in principle be combined (somebody in the chat mused "that might be where my gasket fits") but they're different proposals from different people solving different problems. If you hear "circle" without context, ask which one.
+## what would need to happen to prove STM out
+Nobody has done this yet as of the chats I read. The obvious experiment:
+1. Pretrain a small model normally to some checkpoint.
+2. Fork it. One copy keeps training on the full dataset. The other copy starts STM — circle the easy samples after each epoch, drop them, continue.
+3. Compare validation loss and downstream eval scores after equal compute (not equal epochs, equal compute, since STM epochs get cheaper as the set shrinks).
+If STM wins, the prediction is it should generalize better and overfit less, because by construction it's not letting the model grind on samples it has already nailed. If it loses, the most likely failure mode is that the "easy samples" were actually carrying signal the model still needed reinforcement on, and dropping them caused forgetting.
+There was also a suggestion in the channel to do STM on pretraining specifically and *then* do finetuning normally on top, which seems sensible — you don't want to be subtracting samples during a phase where you're already dataset-starved.
+## tldr for someone skimming
+- **STM** = Subtractive Training Method. Each epoch, throw out the samples whose loss dropped the most last time. Train on what's left. Repeat.
+- **Circling** = the evaluation pass that identifies which samples to throw out. First phase of STM.
+- Theory: big sudden loss drops = already learned = further training just memorizes. Gradual loss drops = still learning = keep training on those.
+- Still theoretical. Somebody needs to actually run it.
+- The Apollonian gasket "circle" thing is unrelated, don't mix them up.
+---
+*notes compiled from the #general chat history; if I got anybody's idea wrong, yell at me and I'll fix the doc.*
+Credit goes to Dragonoid & the CompactAI team</script>
+  <script type="text/markdown" id="paper-apollonian_gasket-md"># Token Embeddings Inside an Integer Apollonian Gasket
+## where this came from
+So there's this idea that kept popping up in the #general channel. Mage threw it out there while we were all talking about weird embedding schemes, and honestly it's the kind of thing that sounds like math fanfiction until you sit down and actually think about it for twenty minutes. Then it starts seeming less crazy.
+The basic pitch: what if instead of learning token embeddings as big float matrices through SGD, you placed every token as an address inside an Apollonian gasket — the fractal you get when you recursively pack circles into the gaps between other circles, forever — and you keyed each address to a pair of twin primes?
+Yeah. I know. But keep reading.
+## the geometry part
+An Apollonian gasket is what you get from the Descartes circle theorem: for any four mutually tangent circles, their curvatures (1/radius) satisfy a quadratic relation. Start with three tangent circles, compute the two circles tangent to all three, pick one, and recurse. You get this infinitely detailed fractal packing where every circle has an integer curvature if you start with the right initial curvatures.
+The trick is that circles in an integer Apollonian gasket naturally form a kind of hierarchy. Big circles have small curvatures. As you go deeper the curvatures get bigger. Circles tangent to each other are "neighbors." The gasket has this beautiful property where the curvature of a circle encodes something about its position in the hierarchy — where it sits relative to everything else.
+## the twin prime part
+Now the wild part. Mage's suggestion was to map each token to a circle via a function f: token → (p₁, p₂) where p₁ and p₂ are twin primes (primes that differ by exactly 2, like 17 and 19). The idea is that "semantic neighbors" come for free because the +2 gap between twin primes maps naturally onto the local step structure of the Apollonian gasket.
+The weight matrix — the thing that normally stores all the relationships between tokens as learned floating point numbers — becomes the curvature graph of the gasket. Instead of "the embedding for 'cat' is related to the embedding for 'dog' by some learned vector," you'd say "the curvature of the circle representing 'cat' has a specific Descartes relation to the curvature of the circle representing 'dog.'"
+Inference becomes a bounded curvature recall: you truncate the search to circles with curvature ≤ K, filter by primality (making sure you're on actual valid addresses), and verify Descartes-consistency (making sure the geometric relations actually hold). It's deterministic. You're not "predicting" the next token's embedding — you're traversing a fixed geometric structure.
+## why this might not be completely insane
+A few things that make this more interesting than your average stoner math thought, based on the back and forth in the channel:
+First, there's something appealing about the fact that the structure is fixed. Embeddings in normal transformers are a black box — you train them, they end up somewhere, you hope the geometry is nice. With an Apollonian gasket, the geometry is given. The question becomes whether the geometry is *useful*, not whether you can learn a useful geometry. Totally different problem.
+Second, the twin prime mapping means token space has a built-in notion of "closeness" that comes from number theory rather than from co-occurrence statistics. Twin primes are conjectured to be infinite (unproven, sure, but there are plenty of them for any practical vocabulary size), and the fact that they're spaced by exactly 2 gives you a natural adjacency relation. If you can map semantically similar tokens to nearby primes, the geometry does the rest.
+Third, it's absurdly compressible. You don't store a giant embedding matrix — you store the algorithm that generates the gasket and the mapping from vocabulary items to prime pairs. For a 50k vocabulary, you're storing 50k integer pairs rather than 50k × 768 floats. The storage goes from hundreds of megabytes to... kilobytes. Maybe tens of kilobytes.
+## the obvious problems
+Nobody in the chat was pretending this was solved. Some issues that came up:
+- How do you *assign* tokens to primes? You need a mapping from tokens to (p₁, p₂) pairs that puts semantically similar tokens near each other in the gasket. If you just assign randomly, the geometry is useless. But if you need to learn the assignment, you've just moved the learning problem somewhere else.
+- The gasket is 2D (well, it lives in the plane). Token embeddings are typically 768D or higher. You're trying to cram a high-dimensional semantic space into a 2D fractal. There are ways to extend the Descartes theorem to higher dimensions (Soddy's theorem generalizes), but the nice integer properties of the Apollonian gasket are specifically a 2D phenomenon.
+- "Bounded curvature recall" sounds nice in theory but what does it actually mean for language modeling? You're essentially doing a kind of geometric lookup. How does attention work in this scheme? Does it even make sense to talk about attention when the "embeddings" are fixed geometric positions?
+- The twin prime conjecture is unproven. If twin primes are finite (they're almost certainly not, but we don't have a proof), you'd run out of addresses for large vocabularies. Even if they're infinite, the density of twin primes thins out — mapping a million-token vocabulary might push you into very large primes, and the corresponding circles would have enormous curvatures.
+## what would need to happen to test this
+Nobody's built it. The experiment would look something like:
+1. Pick a small vocabulary (say 1000 tokens) and manually assign them to twin prime pairs. The assignment doesn't have to be perfect — you just need to demonstrate that semantically related tokens end up geometrically close in the gasket.
+2. Build a tiny transformer (or whatever architecture) where the embedding lookup is replaced by gasket traversal. The model doesn't learn embeddings — it learns to navigate the gasket.
+3. Train it on a simple task (next token prediction on a small corpus) and see if it converges *at all*. The null hypothesis is that it doesn't learn anything useful, because the geometric prior is wrong. If it does learn, that's interesting.
+4. Compare to an identical model with learned embeddings. If the gasket version is even in the same ballpark, that's a big deal given the compression advantage.
+Mage suggested this could be combined with STM (Subtractive Training Method) from the other paper, since you'd want to be very careful about which training examples you keep when your embedding scheme is this constrained. But combining two untested ideas seems like a good way to not know which one is failing.
+## how this is different from existing work
+I actually looked this time. There's no literature on using Apollonian gaskets for token embeddings. The closest things are:
+- Hyperbolic embeddings (Poincaré ball, etc.) which use negative curvature spaces to represent hierarchies. But these are continuous, learned, and don't have the integer/prime structure.
+- Fractal-based neural network initialization schemes (very niche, mostly theoretical).
+- Some work on representing knowledge graphs in hyperbolic or spherical geometries.
+None of them use Apollonian gaskets, twin primes, or curvature graphs as the actual embedding mechanism. This is new ground, for better or worse.
+## tldr
+- Represent tokens as circles in an integer Apollonian gasket, addressed by twin prime pairs
+- Semantic neighbors are geometrically close "for free" because of the Descartes curvature relation
+- The weight matrix is replaced by the curvature graph
+- Inference = bounded curvature recall + primality filter + Descartes verification
+- Crazy compression: kilobytes instead of hundreds of megabytes for the embedding table
+- Completely untested, might be mathematically impossible for high-dimensional semantics
+- If it worked even a little bit, it'd be worth writing home about
+---
+Credit goes to Mage & the CompactAI team
+</script>
+  <script type="text/markdown" id="paper-overta_hypothesis-md"># The Overta Hypothesis: Training Knowledge-Free Foundation Models
+## the core idea, stated plainly
+Amy's been working on something that sounds backwards at first: train a language model from scratch that knows *nothing* about the world. Not "knows less." Nothing. The model wouldn't know what a human is. Wouldn't know that Earth exists. Wouldn't know what "Paris" or "coffee" or "gravity" refers to. What it WOULD know is how to reason, how to hold a conversation, how to use tools to look things up, and how to do in-context learning from whatever you give it at inference time.
+She calls it OFM — Overta Foundation Model. (She owns overta.org, nothing on it yet.)
+The pitch is: instead of cramming world knowledge into model weights — which is what every single LLM from GPT-2 onward has tried to do — you let the model use its entire parameter budget for reasoning capability. Facts live outside the model, in retrievable documents. The model is just the engine that processes them.
+## what "no world knowledge" actually means
+This is weirder than it sounds. When Amy says the model wouldn't know what a human is, she means it literally. Here's the kind of definition she'd provide *externally* at inference time, via a search tool or context window:
+> "We are entities interacting with the physical world and able to do precise manipulation and also self-locomotion, through deforming and displacing our body."
+The model has never seen this before. It doesn't come pre-loaded with it. But it knows how to *use* a definition once provided. It knows how to reason from premises. It knows that if X is an entity that can manipulate objects, and you ask it about X's capabilities, it should reference the definition.
+The training data for this kind of model would be purely synthetic conversations where:
+- Characters have defined properties stated explicitly in the context
+- Reasoning chains are spelled out step by step
+- Facts are always grounded in explicitly provided information
+- The model never relies on "common sense" or "world knowledge" because there isn't any
+Amy's seed data example, hand-written, gives the flavor:
+```
+<message from="other">
+describe whats happening now
+</message>
+<message from="self">
+<think>
+They're asking me to describe "whats happening now". Right now I'm talking
+to them and outputting text. I don't know of anything else happening now.
+So I'll describe that to them.
+</think>
+I (some entity which processes text and outputs text) am conversing with
+you, what I assume to be an entity which also can process text and output
+text of your own. I'm outputting text to respond to your request.
+</message>
+```
+Notice: the model doesn't say "I am an AI assistant." It says "I (some entity which processes text and outputs text)." It describes itself from first principles using only what's observable in the conversation. That's the whole philosophy.
+## why this might be a good idea
+The main argument, as it crystallized across multiple conversations:
+1. **Hallucination isn't a bug, it's a design choice.** LLMs hallucinate because they're trained to memorize facts and then regenerate them probabilistically. If you don't train them to memorize facts, they can't hallucinate facts. They can only fail to reason correctly, which is a different failure mode.
+2. **Parameter efficiency.** A 350M model that spends zero parameters on knowing the capital of France or the plot of Hamlet can spend all 350M parameters on reasoning circuits. Amy's hypothesis is that this gets you more "intelligence per parameter" than any model that mixes knowledge and reasoning.
+3. **Grounding is explicit.** When the model uses a fact, you know exactly where that fact came from — it was in the context window, provided by a search tool or the user. There's no mystery about whether the model is "remembering" something or "making it up."
+4. **Updatability.** World knowledge changes. Models don't. But if the model doesn't contain world knowledge, there's nothing to go stale. You just update the retrieval database.
+5. **Alignment surface.** A model with no priors about what's true or false, good or bad, normal or weird — it only knows what you tell it in the moment. That means the user, not the training data, defines the ethical frame and factual premises. (This cuts both ways, obviously.)
+## why it might be impossible
+Nobody's done it yet, and Amy's early experiments have been rough. Some problems:
+- **Language IS knowledge.** You can't learn English grammar without incidentally learning that doctors treat patients, that fire is hot, that people have names. The boundary between "reasoning" and "knowing" is blurrier than the hypothesis assumes. Costikoooo pointed this out in the chat — the model might pick up unwanted world knowledge just from the structure of the training conversations.
+- **The cold start problem.** Amy's pipeline is: manually write ~200 seed examples → finetune a Qwen3 4B to generate more → use that to generate the full training dataset. But the seed examples have to be insanely good, because everything cascades from them. Claude Opus "doesn't get it even close first try and needs a lot of iterating," per Amy. The AI models she's using to *generate* the training data were themselves trained on world knowledge, so they tend to sneak it in.
+- **Brittleness.** Her earlier experiment with programmatic data generators (code that generates conversations procedurally, not using LLMs at all) produced a model that could do tool calling but was "the most brittle thing imaginable." It only worked with names in its predefined list. Generalization was poor.
+- **The in-context bandwidth problem.** If every fact has to be provided in the context window, you need a REALLY good retrieval system and a very long context window. The model becomes only as good as its RAG pipeline.
+- **What even counts as "knowledge"?** Dragonoid asked about ethics — if the model gets intelligent and someone malicious uses it, you're in trouble. Amy said ethics would be taught as abstract values. But are values "knowledge"? Where do you draw the line? The philosophy gets tangled fast.
+## the procedural generation approach
+Amy's earlier, more interesting (imo) approach wasn't to use LLMs at all. She built a system of TypeScript "generators" — code functions that each handled one aspect of conversation generation. A generator might add a user message saying "My name is Joe," then mutate the conversation state so Joe's name is stored. Later generators reference that state. The system randomly chains generators together to create diverse conversations, all procedurally, all guaranteed consistent because the state machine enforces it.
+She trained a 350M model from scratch on this procedural data (Qwen3 architecture, custom tokenizer, ~1 hour per training run on a 16GB GPU). The model learned to:
+- Remember user names (because the generator state tracked them)
+- Search for information it didn't have (because generators included search tool calls)
+- Stay in character as "an entity that processes text"
+But it was brittle. It only generalized to names in the generator's list. Math didn't work. Longer training might have helped — she only trained for about an hour per run.
+The key insight though: with this approach, you can add a *new capability* just by writing a new generator and retraining. Want the model to handle timers? Write a timer generator. Want it to understand spatial relationships? Spatial generator. The capabilities are modular because the training data is modular.
+This procedural approach is more philosophically pure than the LLM-distillation approach. No LLM was used to generate the training data, so no world knowledge leaks in. But it's also much more labor-intensive — you're basically writing a program that writes programs that simulate conversations, and you have to anticipate every capability you want the model to have.
+## what needs to happen
+The minimum viable experiment:
+1. Build a procedural data generator that covers ~20 distinct capabilities (name memory, search, clarification, multi-turn reasoning, simple math from provided formulas, etc.)
+2. Train a small model (~100M) from scratch exclusively on this data
+3. Test whether it can handle *novel* names, *novel* facts provided in context, and *novel* combinations of capabilities
+4. Compare to an identical model trained on standard web text — does the Overta model hallucinate less? Reason worse? Something in between?
+Amy's currently paused work on this to focus on other projects, but the repo and approach are documented enough that someone could pick it up.
+## tldr
+- Train a model that knows zero facts about the world, only how to reason and converse
+- All knowledge comes from the context window or retrieval at inference time
+- Training data is procedurally generated, not scraped from the web
+- Claims: no hallucination (can't make up facts you never learned), better parameter efficiency, explicit grounding
+- Problems: language itself encodes knowledge, procedural generation is labor-intensive, brittleness
+- Amy's been poking at this with 350M models trained on synthetic data; promising but not there yet
+---
+Credit goes to Amy & the CompactAI team
+</script>
+  <script type="text/markdown" id="paper-attention_experiment-md"># An Experiment With Attention
+## where this came from
+wop posted this on HuggingFace a couple days ago. It started as a simple question: can you replace full attention with something cheaper and still keep enough context to get the right next token? The answer turned out to be "no, not yet" — but the way it got there is more interesting than the headline.
+The setup is clean and reproducible, which is refreshing. No massive training runs, no weasel words about "promising directions." Just a concrete benchmark, two architectures, and numbers.
+## the question, stated properly
+A context window isn't just a flat sequence of tokens. In practice it's usually a mix of: task instructions, style hints, formatting rules, and the actual content. These don't always matter at every token — some instructions are "globally relevant but locally weak." The emoji rule in a system prompt. A formatting constraint. The model needs to carry them the whole way even though they might not matter at each individual prediction step.
+wop's framing: can a compressed context state preserve those weak early rules as the sequence gets long? And how does that compare to ordinary attention?
+## the setup
+Two small models, head to head:
+- **attention**: standard causal transformer-style attention (the baseline)
+- **compressed**: replaces token-to-token attention with a learned compressed memory state made of a few implicit slots
+Important detail: the compressed model doesn't explicitly classify tokens into categories. It just reads tokens, updates a compact state, and uses that state for prediction. The structure stays implicit — no hand-crafted "this is a rule, this is content" partitioning.
+The dataset is synthetic and hardcoded (keeps things clean). Each example has: two early rules, one item, a long distractor-filled prefix, and a target that needs the model to recover the early rules later. This means the benchmark specifically stresses rule retention over distance, not just general token prediction.
+Three context lengths tested: ctx64, ctx256, ctx1028.
+## what happened
+The short version: attention won clearly on quality, and it also won clearly on speed. The compressed model didn't show any rule-retention advantage.
+At ctx64:
+- attention: val_acc 0.938, rule_acc 0.906
+- compressed: val_acc 0.699, rule_acc 0.492
+At ctx256:
+- attention: val_acc 0.757, rule_acc 0.581
+- compressed: val_acc 0.633, rule_acc 0.358
+At ctx1028:
+- attention: val_acc 0.701, rule_acc 0.492
+- compressed: val_acc 0.577, rule_acc 0.263
+Speed was even more stark. At ctx1028, attention finished in about 9.9 seconds while the compressed model took about 229.4 seconds. So the compressed model was not only less accurate, it was dramatically slower.
+## why this isn't just "compression bad"
+The lesson is narrower and more useful than the headline:
+1. A naive compressed recurrent context state does not automatically beat attention
+2. Preserving weak parallel instructions is harder than just keeping a rolling summary
+3. Full attention is still very strong, even on a task specifically designed to stress early-rule retention
+There's also an implementation caveat. The compressed model updates memory step-by-step in sequence order, which creates a lot of serial work. The attention baseline benefits from the highly optimized parallel kernels that exist for transformers. Some of the speed gap is architectural, but some is just implementation reality.
+## what this means for the broader idea
+wop is careful not to over-claim. The motivating intuition — that context isn't flat, that some instructions matter globally but weakly, that a good alternative to attention would need to preserve those signals — that intuition is still valid. What changed is that the first compressed block was too simple to do it well. It formed a bottleneck, but not a smart enough one.
+If someone wants to replace or relax attention, the replacement probably needs:
+- A better way to preserve weak long-range constraints
+- A more parallel implementation
+- A more selective memory update rule
+- A benchmark where rule retention is measured directly, not hidden inside average loss
+The next step isn't "compress harder." It's compress more carefully.
+## what came out of it
+The experiment made the question concrete. Instead of abstract talk about "efficient context," there's now a clear picture: attention is expensive but extremely effective, compressed context isn't enough by itself, and weak parallel instructions are a real stress test. If cheaper context mechanisms are going to work, they need to preserve global obligations without collapsing into a vague summary.
+wop used Kaggle notebooks for the GPU, Codex from OpenAI for assistance, and a HuggingFace ZeroGPU space for the thumbnail. The repo is at github.com/koo1140/attention-experiment if you want to reproduce it.
+---
+Credit goes to wop (poe) & the CompactAI team
+</script>
+  <script type="text/markdown" id="paper-sparrow_fant-md"># Sparrow, FANT, and the Weird Stuff That Works
+## where this came from
+Shane (Crownelius) posted this on HuggingFace after sitting on the story for a while. It's part technical writeup, part personal history, and part challenge to the community: here's a bunch of half-built things, some of them work surprisingly well, come help figure out why.
+The headline number that's been making the rounds: Sparrow, a 1M-parameter model, scores 95.6% on a 1,900-question math eval where Owl Alpha scores 61.4%. That's not a typo. One million parameters vs a 70B-class frontier model.
+## the backstory
+Shane got into building models through an unusual route. He dropped a fine-tune that scored unusually high on EQ — the empathy benchmark nobody really gambles on. A publishing outfit reached out. They wanted full books generated through Claude, architected prompt-by-prompt. The gig ran over $25,000 in API credits. Shane designed every prompt. About 60% of that publisher's data pipeline still uses his curation.
+That experience flipped his focus from using models to building them. Specifically, tiny ones — small enough to fit on a 12GB card, small enough that every architectural decision is exposed and wrong choices are embarrassing.
+## FANT and the stuff that shouldn't work
+FANT (github.com/Crownelius/fant3) is the experimentation framework. Three iterations so far, each a complete rewrite. The philosophy is that at small enough scale, you can try genuinely weird ideas and actually see what they do.
+The standout example is SleepGate — a memory consolidation routine that runs every 100 training steps. It's half a screen of code, most of it comments. On FANT 2 at 5 million parameters, on a 1,000-problem procedural math eval, it delivers a 5.3-point improvement. Off one architectural decision. Without changing the optimizer, the data, or the training schedule.
+That's the kind of result that creates more questions than it answers. Why does a tiny consolidation pass move the needle that much? Nobody's fully sure yet. But it does.
+## the new weird thing: SpinorApollonian Memory
+This one takes some explaining. Shane found a paper by Jerzy Kocik on tangency spinors — a way of classifying Apollonian disk packings using two-dimensional Minkowski spinors. The Descartes circle theorem turns out to be the Minkowski quadratic form in signature (1,3). That's real math, not a metaphor.
+The practical application: memory writes get split by chirality. Left-spinning packs go to one bucket, right-spinning packs go to another. It's geometric routing instead of threshold routing. The failure mode that had been causing problems for two months — packs starving each other into uselessness — vanished. Same pattern at every scale tested, from 5M up through 742M.
+As Shane puts it: "Sounds like peanut butter on a hamburger, but the ablation table says it works."
+## Sparrow: 1M parameters vs Owl Alpha
+Sparrow is a separate model from FANT — different skeleton, different router, different everything. It's small and surgical, built specifically for math. Across 38 head-to-head evals (n=50 each, numeric scoring), Sparrow ties or beats Owl Alpha on 33 of 38 (87%).
+The five losses are all on simple multiplication and division at digit counts where Owl Alpha's training data is dense — fair wins for the big model. But on the interesting tasks — Goldbach, Collatz, Fermat-little, complex modulus, dot products, distance, determinants — Sparrow dominates:
+- +100 percentage points in some cases
+- +98 pp
+- +88 pp
+A 1M-parameter byte-level model beating a 70B-class frontier model by margins you'd normally suspect are bugs. Shane checked it twice, bothered three friends, re-ran at three temperatures. Same numbers.
+The trick: Sparrow uses a calc-tag wrapper for arithmetic. It learns to call it correctly. On 5-digit multiplication specifically: Owl Alpha at 12%, Gemma 3 27B at 0%, Sparrow at 100%. The model doesn't do the math — it learns to use the tool. That's the whole trick.
+## the open problem
+Shane can't get Sparrow's approach to work with FANT's architecture. There's something about how Sparrow handles symbolic state that should connect to FANT's recursion stack, but the fusion has been elusive for weeks. The breadcrumbs are public — repo's open, issues are open, the challenge is sitting there for anyone who wants to try.
+"Half-built spaceships are best shared."
+## tldr
+- FANT is an experimentation framework for tiny models (5M–742M params)
+- SleepGate: a 100-step memory consolidation pass that adds 5.3 points on its own
+- SpinorApollonian Memory: geometric routing by chirality using Minkowski spinors, fixes a starvation failure mode
+- Sparrow: 1M-parameter math model that beats Owl Alpha (70B-class) on 87% of head-to-head evals
+- The trick is tool use (calc-tag wrapper), not raw computation
+- FANT + Sparrow fusion is unsolved — open challenge for the community
+---
+Credit goes to Crownelius (Shane) & the CompactAI team
+</script>
+  <script>
+    var PAPERS = [
+  {
+    "id": "STM_paper-md",
+    "title": "STM and the Circle Thing",
+    "date": "2026-05",
+    "author": "Dragonoid",
+    "tags": [
+      "training",
+      "experimental"
+    ]
+  },
+  {
+    "id": "apollonian_gasket-md",
+    "title": "Token Embeddings Inside an Integer Apollonian Gasket",
+    "date": "2026-05",
+    "author": "Mage",
+    "tags": [
+      "embeddings",
+      "geometry",
+      "number-theory",
+      "experimental"
+    ]
+  },
+  {
+    "id": "overta_hypothesis-md",
+    "title": "The Overta Hypothesis: Knowledge-Free Foundation Models",
+    "date": "2026-05",
+    "author": "Amy",
+    "tags": [
+      "training",
+      "alignment",
+      "reasoning",
+      "experimental"
+    ]
+  },
+  {
+    "id": "attention_experiment-md",
+    "title": "An Experiment With Attention",
+    "date": "2026-05",
+    "author": "wop",
+    "tags": [
+      "attention",
+      "benchmark",
+      "experimental"
+    ]
+  },
+  {
+    "id": "sparrow_fant-md",
+    "title": "Sparrow, FANT, and the Weird Stuff That Works",
+    "date": "2026-05",
+    "author": "Crownelius",
+    "tags": [
+      "math",
+      "small-models",
+      "experimental"
+    ]
+  }
+];
+    (function() {
+      var grid = document.getElementById('papersGrid');
+      // Announce messages to screen readers via aria-live region
+      function announce(msg) {
+        var el = document.getElementById('announcer');
+        if (el) {
+          el.textContent = '';
+          // Force re-announce by clearing then setting
+          setTimeout(function() { el.textContent = msg; }, 50);
+        }
+      }
+      if (PAPERS.length === 0) {
+        grid.innerHTML = '<li class="empty-state" role="listitem"><p>No papers yet.</p></li>';
+        return;
+      }
+      PAPERS.forEach(function(paper, i) {
+        grid.appendChild(createCard(paper, i));
+      });
+      function createCard(paper, index) {
+        var li = document.createElement('li');
+        li.setAttribute('role', 'listitem');
+        var card = document.createElement('div');
+        card.className = 'paper-card';
+        card.style.animationDelay = (index * 80) + 'ms';
+        card.setAttribute('tabindex', '0');
+        card.setAttribute('role', 'button');
+        card.setAttribute('aria-label', 'Read paper: ' + paper.title);
+        if (paper.date) {
+          card.setAttribute('aria-describedby', 'meta-' + paper.id);
+        }
+        var tagsHtml = '';
+        if (paper.tags && paper.tags.length) {
+          tagsHtml = paper.tags.map(function(t) {
+            return '<span class="card-tag">' + escapeHtml(t) + '</span>';
+          }).join(' ');
+        }
+        card.innerHTML =
+          '<h3 class="card-title">' + escapeHtml(paper.title) + '</h3>' +
+          (paper.author ? '<div class="card-author">' + escapeHtml(paper.author) + '</div>' : '') +
+          '<div class="card-meta" id="meta-' + paper.id + '">' +
+            (paper.date ? '<span>' + escapeHtml(paper.date) + '</span>' : '') +
+            tagsHtml +
+          '</div>' +
+          '<span class="card-arrow" aria-hidden="true">&rarr;</span>';
+        // Tilt effect
+        card.addEventListener('mousemove', function(e) {
+          if (window.matchMedia('(prefers-reduced-motion: reduce)').matches) return;
+          var rect = card.getBoundingClientRect();
+          var x = e.clientX - rect.left;
+          var y = e.clientY - rect.top;
+          card.style.setProperty('--mx', x + 'px');
+          card.style.setProperty('--my', y + 'px');
+        });
+        card.addEventListener('mouseleave', function() {
+          card.style.removeProperty('--mx');
+          card.style.removeProperty('--my');
+        });
+        // Click handler
+        card.addEventListener('click', function() {
+          openPaper(paper, card);
+        });
+        // Keyboard handler: Enter or Space to activate
+        card.addEventListener('keydown', function(e) {
+          if (e.key === 'Enter' || e.key === ' ') {
+            e.preventDefault();
+            openPaper(paper, card);
+          }
+        });
+        li.appendChild(card);
+        return li;
+      }
+      function openPaper(paper, triggerEl) {
+        var previousFocus = triggerEl || document.activeElement;
+        var overlay = document.createElement('div');
+        overlay.className = 'paper-overlay';
+        overlay.setAttribute('role', 'dialog');
+        overlay.setAttribute('aria-modal', 'true');
+        overlay.setAttribute('aria-label', 'Paper: ' + paper.title);
+        var view = document.createElement('div');
+        view.className = 'paper-view';
+        view.setAttribute('role', 'document');
+        view.setAttribute('aria-busy', 'true');
+        view.innerHTML =
+          '<button class="paper-view-close" aria-label="Close paper viewer">&times;</button>' +
+          '<div class="paper-view-loading" role="status">' +
+            '<div class="loading-spinner" aria-hidden="true"></div>' +
+            '<span style="color:var(--text-dim);font-family:Geist Mono,monospace;font-size:13px">Loading paper...</span>' +
+          '</div>';
+        overlay.appendChild(view);
+        document.body.appendChild(overlay);
+        document.body.style.overflow = 'hidden';
+        var closeBtn = view.querySelector('.paper-view-close');
+        // Focus the close button
+        closeBtn.focus();
+        // Focus trap: find all focusable elements in the overlay
+        function getFocusableEls() {
+          return overlay.querySelectorAll(
+            'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+          );
+        }
+        var close = function() {
+          overlay.style.opacity = '0';
+          overlay.style.transition = 'opacity 0.2s ease';
+          setTimeout(function() {
+            overlay.remove();
+            document.body.style.overflow = '';
+            if (previousFocus && typeof previousFocus.focus === 'function') {
+              previousFocus.focus();
+            }
+            announce('Paper viewer closed.');
+          }, 200);
+        };
+        closeBtn.addEventListener('click', close);
+        overlay.addEventListener('click', function(e) {
+          if (e.target === overlay) close();
+        });
+        // Escape key handler
+        document.addEventListener('keydown', function handler(e) {
+          if (e.key === 'Escape') {
+            close();
+            document.removeEventListener('keydown', handler);
+          }
+        });
+        // Focus trap: keep Tab within the overlay
+        overlay.addEventListener('keydown', function(e) {
+          if (e.key !== 'Tab') return;
+          var focusable = getFocusableEls();
+          if (focusable.length === 0) return;
+          var first = focusable[0];
+          var last = focusable[focusable.length - 1];
+          if (e.shiftKey) {
+            if (document.activeElement === first) {
+              e.preventDefault();
+              last.focus();
+            }
+          } else {
+            if (document.activeElement === last) {
+              e.preventDefault();
+              first.focus();
+            }
+          }
+        });
+        // Load from embedded markdown
+        var mdEl = document.getElementById('paper-' + paper.id);
+        if (mdEl && mdEl.textContent) {
+          var parsed = parsePaper(mdEl.textContent.trim());
+          renderView(view, parsed, previousFocus, close);
+        } else {
+          view.querySelector('.paper-view-loading').innerHTML =
+            '<p role="alert" style="color:var(--text-dim);font-family:Geist Mono,monospace;font-size:13px">Paper content not found.</p>';
+          view.removeAttribute('aria-busy');
+        }
+      }
+      function parsePaper(md) {
+        var lines = md.split('\n');
+        var creditLine = '';
+        var contentLines = [];
+        var foundCredit = false;
+        for (var i = lines.length - 1; i >= 0; i--) {
+          var trimmed = lines[i].trim();
+          if (!foundCredit && trimmed.toLowerCase().indexOf('credit goes to') === 0) {
+            creditLine = trimmed;
+            foundCredit = true;
+          } else {
+            contentLines.unshift(lines[i]);
+          }
+        }
+        var contentMd = contentLines.join('\n').trim();
+        var html = marked.parse(contentMd);
+        return { html: html, credit: creditLine };
+      }
+      function renderView(view, parsed, previousFocus, closeFn) {
+        var creditHtml = '';
+        if (parsed.credit) {
+          var creditText = parsed.credit;
+          var labelEnd = creditText.indexOf(':');
+          var labelPart = creditText.substring(0, labelEnd + 1);
+          var namesPart = creditText.substring(labelEnd + 1).trim();
+          creditHtml =
+            '<footer class="paper-credit" role="contentinfo">' +
+              '<span class="credit-label">' + escapeHtml(labelPart) + '</span> ' +
+              '<span class="credit-names">' + escapeHtml(namesPart) + '</span>' +
+            '</footer>';
+        }
+        view.innerHTML =
+          '<button class="paper-view-close" aria-label="Close paper viewer">&times;</button>' +
+          '<article class="paper-body" role="article" aria-label="Paper content">' + parsed.html + '</article>' +
+          creditHtml;
+        view.removeAttribute('aria-busy');
+        // Re-bind close button using the shared close function
+        var closeBtn = view.querySelector('.paper-view-close');
+        closeBtn.addEventListener('click', closeFn);
+        // Refocus close button so focus trap works after re-render
+        closeBtn.focus();
+        announce('Paper loaded.');
+      }
+      function escapeHtml(str) {
+        var div = document.createElement('div');
+        div.appendChild(document.createTextNode(str));
+        return div.innerHTML;
+      }
+    })();
+  </script>
+</body>
 </html>