diff --git a/docs/catalog/blocks/weight-wave.mdx b/docs/catalog/blocks/weight-wave.mdx
new file mode 100644
index 0000000000..8a1a2fd6ae
--- /dev/null
+++ b/docs/catalog/blocks/weight-wave.mdx
@@ -0,0 +1,43 @@
+---
+title: "Weight Wave"
+description: "A crest of thickness travels along a headline: each character swells from light to black and leans forward as the wave passes, driven by the wght and slnt variable-font axes rather than by transforms."
+---
+
+<video className="w-full aspect-video rounded-xl object-cover bg-zinc-100 dark:bg-zinc-800" src="https://static.heygen.ai/hyperframes-oss/docs/images/catalog/blocks/weight-wave.mp4" poster="https://static.heygen.ai/hyperframes-oss/docs/images/catalog/blocks/weight-wave.png" autoPlay muted loop playsInline />
+
+## Install
+
+```bash Terminal
+npx hyperframes add weight-wave
+```
+
+That writes `compositions/weight-wave.html`, plus 2 supporting files under `compositions/assets/fonts/`.
+
+## Add it to your video
+
+It runs for 6 seconds at 1920×1080. Paste this into your composition:
+
+```html index.html
+<div
+  data-composition-id="weight-wave"
+  data-composition-src="compositions/weight-wave.html"
+  data-start="0"
+  data-duration="6"
+  data-track-index="1"
+  data-width="1920"
+  data-height="1080"
+></div>
+```
+
+Move it in time with `data-start`. Put it on a different timeline row with
+`data-track-index`. See [data attributes](/concepts/data-attributes) for the rest.
+
+{/* hf:generated-footer */}
+
+Tagged `typography` `kinetic-type` `title` `variable-font` `text`.
+
+## Related topics
+
+- [Browse the complete Catalog](/catalog)
+- [Add assets and Catalog items in Studio](/studio/assets-and-blocks)
+- [Build a richer composition](/go-further)
diff --git a/docs/docs.json b/docs/docs.json
index c51c359780..c8a1eabc83 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -466,6 +466,7 @@
               "catalog/blocks/mk-placeholder-grid",
               "catalog/blocks/mk-progress-stat",
               "catalog/blocks/mk-specs-list",
+              "catalog/blocks/weight-wave",
               "catalog/blocks/yt-lcd-background",
               "catalog/blocks/yt-logo-intro",
               "catalog/blocks/yt-prism-title",
diff --git a/docs/public/catalog-index.json b/docs/public/catalog-index.json
index 8255b52d5e..f772b6ae70 100644
--- a/docs/public/catalog-index.json
+++ b/docs/public/catalog-index.json
@@ -2164,6 +2164,21 @@
     "href": "/catalog/blocks/vpn-youtube-spot",
     "preview": "https://static.heygen.ai/hyperframes-oss/docs/images/catalog/blocks/vpn-youtube-spot.png"
   },
+  {
+    "name": "weight-wave",
+    "type": "block",
+    "title": "Weight Wave",
+    "description": "A crest of thickness travels along a headline: each character swells from light to black and leans forward as the wave passes, driven by the wght and slnt variable-font axes rather than by transforms.",
+    "tags": [
+      "typography",
+      "kinetic-type",
+      "title",
+      "variable-font",
+      "text"
+    ],
+    "href": "/catalog/blocks/weight-wave",
+    "preview": "https://static.heygen.ai/hyperframes-oss/docs/images/catalog/blocks/weight-wave.png"
+  },
   {
     "name": "whip-pan",
     "type": "block",
diff --git a/registry/blocks/weight-wave/assets/fonts/OFL.txt b/registry/blocks/weight-wave/assets/fonts/OFL.txt
new file mode 100644
index 0000000000..d4361a99fe
--- /dev/null
+++ b/registry/blocks/weight-wave/assets/fonts/OFL.txt
@@ -0,0 +1,93 @@
+Copyright 2020 The Recursive Project Authors (https://github.com/arrowtype/recursive)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/registry/blocks/weight-wave/assets/fonts/Recursive-wght-slnt-latin.woff2 b/registry/blocks/weight-wave/assets/fonts/Recursive-wght-slnt-latin.woff2
new file mode 100644
index 0000000000..f7205e9b80
Binary files /dev/null and b/registry/blocks/weight-wave/assets/fonts/Recursive-wght-slnt-latin.woff2 differ
diff --git a/registry/blocks/weight-wave/registry-item.json b/registry/blocks/weight-wave/registry-item.json
new file mode 100644
index 0000000000..dafd1cadf0
--- /dev/null
+++ b/registry/blocks/weight-wave/registry-item.json
@@ -0,0 +1,116 @@
+{
+  "$schema": "https://hyperframes.heygen.com/schema/registry-item.json",
+  "name": "weight-wave",
+  "type": "hyperframes:block",
+  "title": "Weight Wave",
+  "description": "A crest of thickness travels along a headline: each character swells from light to black and leans forward as the wave passes, driven by the wght and slnt variable-font axes rather than by transforms.",
+  "dimensions": {
+    "width": 1920,
+    "height": 1080
+  },
+  "duration": 6,
+  "tags": ["typography", "kinetic-type", "title", "variable-font", "text"],
+  "license": "OFL-1.1",
+  "variables": [
+    {
+      "id": "text",
+      "type": "string",
+      "label": "Headline",
+      "default": "PRESSURE MOVES THROUGH TYPE",
+      "maxLength": 64
+    },
+    {
+      "id": "color",
+      "type": "color",
+      "label": "Text color",
+      "default": "#f5f5f7"
+    },
+    {
+      "id": "background",
+      "type": "color",
+      "label": "Background",
+      "default": "#0b0b0d"
+    },
+    {
+      "id": "weightFrom",
+      "type": "number",
+      "label": "Weight (rest)",
+      "default": 400,
+      "min": 300,
+      "max": 1000,
+      "step": 10
+    },
+    {
+      "id": "weightTo",
+      "type": "number",
+      "label": "Weight (crest)",
+      "default": 1000,
+      "min": 300,
+      "max": 1000,
+      "step": 10
+    },
+    {
+      "id": "crestWidth",
+      "type": "number",
+      "label": "Crest width",
+      "default": 4,
+      "min": 1,
+      "max": 24,
+      "step": 0.5,
+      "unit": "chars"
+    },
+    {
+      "id": "sweepSpeed",
+      "type": "number",
+      "label": "Sweep speed",
+      "default": 0.5,
+      "min": 0.05,
+      "max": 3,
+      "step": 0.05,
+      "unit": "passes/s"
+    },
+    {
+      "id": "slant",
+      "type": "number",
+      "label": "Slant at crest",
+      "default": -12,
+      "min": -15,
+      "max": 0,
+      "step": 0.5,
+      "unit": "deg"
+    },
+    {
+      "id": "direction",
+      "type": "enum",
+      "label": "Direction",
+      "default": "ltr",
+      "options": [
+        {
+          "value": "ltr",
+          "label": "Left to right"
+        },
+        {
+          "value": "rtl",
+          "label": "Right to left"
+        }
+      ]
+    }
+  ],
+  "files": [
+    {
+      "path": "weight-wave.html",
+      "target": "compositions/weight-wave.html",
+      "type": "hyperframes:composition"
+    },
+    {
+      "path": "assets/fonts/Recursive-wght-slnt-latin.woff2",
+      "target": "compositions/assets/fonts/Recursive-wght-slnt-latin.woff2",
+      "type": "hyperframes:asset"
+    },
+    {
+      "path": "assets/fonts/OFL.txt",
+      "target": "compositions/assets/fonts/OFL.txt",
+      "type": "hyperframes:asset"
+    }
+  ]
+}
diff --git a/registry/blocks/weight-wave/weight-wave.html b/registry/blocks/weight-wave/weight-wave.html
new file mode 100644
index 0000000000..8aef4b356f
--- /dev/null
+++ b/registry/blocks/weight-wave/weight-wave.html
@@ -0,0 +1,299 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=1920, height=1080" />
+    <title>Weight Wave</title>
+    <style>
+      /*
+        Real variable font, bundled locally — a CDN fetch would be a render-time
+        network dependency, and a STATIC font would silently render every
+        character at one weight (the whole effect vanishes while nothing errors).
+        Subset of Recursive (SIL OFL 1.1) with every axis pinned except the two
+        this block drives. Ranges below are the font's REAL fvar records, read
+        out of the binary: wght 300..1000 (not 100..900) and slnt -15..0. The
+        pinned three are MONO 0 (proportional sans, not the monospace face),
+        CASL 0 (linear/neutral, not casual) and CRSV 0 (roman letterforms —
+        Recursive's 0.5 default swaps in cursive singlestorey forms as soon as
+        slnt goes negative, which would pop mid-wave instead of interpolating).
+      */
+      @font-face {
+        font-family: "Recursive Wave";
+        font-style: normal;
+        font-weight: 300 1000;
+        font-display: block;
+        src: url("assets/fonts/Recursive-wght-slnt-latin.woff2") format("woff2");
+      }
+    </style>
+    <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
+    <style>
+      *,
+      *::before,
+      *::after {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      html,
+      body {
+        background: transparent;
+        overflow: hidden;
+      }
+      body {
+        width: 1920px;
+        height: 1080px;
+      }
+
+      #ww-root {
+        position: relative;
+        width: 1920px;
+        height: 1080px;
+        overflow: hidden;
+      }
+
+      /* Full-bleed fill lives on a CHILD: the producer can drop a background
+         painted on the composition root itself (frame renders black). */
+      #ww-bg {
+        position: absolute;
+        inset: 0;
+        background: var(--background, #0b0b0d);
+      }
+
+      #ww-stage {
+        position: absolute;
+        inset: 0;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      }
+
+      #ww-line {
+        display: block;
+        width: 1760px;
+        text-align: center;
+        white-space: pre;
+        font-family: "Recursive Wave", sans-serif;
+        font-size: 132px;
+        line-height: 1.15;
+        letter-spacing: 0.005em;
+        color: var(--color, #f5f5f7);
+        /* Default instance: the resting end of the wave. If the variable font
+           fails to load, every glyph stays here and the probe below shouts. */
+        font-variation-settings:
+          "wght" 400,
+          "slnt" 0;
+      }
+
+      /* Per-character axis stamping target: no transform, no opacity — the
+         letterforms themselves change. */
+      .ww-ch {
+        display: inline-block;
+      }
+    </style>
+  </head>
+  <body>
+    <div
+      id="ww-root"
+      data-composition-id="weight-wave"
+      data-start="0"
+      data-duration="6"
+      data-width="1920"
+      data-height="1080"
+      data-composition-variables='[
+        {"id":"text","type":"string","label":"Headline","default":"PRESSURE MOVES THROUGH TYPE","maxLength":64},
+        {"id":"color","type":"color","label":"Text color","default":"#f5f5f7"},
+        {"id":"background","type":"color","label":"Background","default":"#0b0b0d"},
+        {"id":"weightFrom","type":"number","label":"Weight (rest)","default":400,"min":300,"max":1000,"step":10},
+        {"id":"weightTo","type":"number","label":"Weight (crest)","default":1000,"min":300,"max":1000,"step":10},
+        {"id":"crestWidth","type":"number","label":"Crest width","default":4,"min":1,"max":24,"step":0.5,"unit":"chars"},
+        {"id":"sweepSpeed","type":"number","label":"Sweep speed","default":0.5,"min":0.05,"max":3,"step":0.05,"unit":"passes/s"},
+        {"id":"slant","type":"number","label":"Slant at crest","default":-12,"min":-15,"max":0,"step":0.5,"unit":"deg"},
+        {"id":"direction","type":"enum","label":"Direction","default":"ltr","options":[{"value":"ltr","label":"Left to right"},{"value":"rtl","label":"Right to left"}]}
+      ]'
+    >
+      <div id="ww-bg"></div>
+
+      <div id="ww-stage" class="clip" data-start="0" data-duration="6" data-track-index="0">
+        <div id="ww-line"></div>
+      </div>
+
+      <script>
+        (function () {
+          window.__timelines = window.__timelines || {};
+
+          var FONT_FAMILY = '"Recursive Wave", sans-serif';
+          /* The bundled font's real fvar bounds — declared once here, and
+             mirrored in the variable min/max above. A slider must not offer a
+             weight the font cannot render. */
+          var WGHT_MIN = 300;
+          var WGHT_MAX = 1000;
+          var SLNT_MIN = -15;
+          var LINE_MAX_WIDTH = 1760;
+          var BASE_FONT_SIZE = 132;
+          var MIN_FONT_SIZE = 40;
+
+          var root = document.getElementById("ww-root");
+          var line = document.getElementById("ww-line");
+          var duration = Number(root.getAttribute("data-duration")) || 6;
+
+          var vars =
+            window.__hyperframes && window.__hyperframes.getVariables
+              ? window.__hyperframes.getVariables()
+              : {};
+
+          function num(value, fallback, min, max) {
+            var n = Number(value);
+            if (!Number.isFinite(n)) n = fallback;
+            return Math.min(max, Math.max(min, n));
+          }
+
+          var TEXT =
+            typeof vars.text === "string" && vars.text.length
+              ? vars.text
+              : "PRESSURE MOVES THROUGH TYPE";
+          var W_FROM = num(vars.weightFrom, 400, WGHT_MIN, WGHT_MAX);
+          var W_TO = num(vars.weightTo, 1000, WGHT_MIN, WGHT_MAX);
+          var CREST = num(vars.crestWidth, 4, 1, 24);
+          var SPEED = num(vars.sweepSpeed, 0.5, 0.05, 3);
+          var SLANT = num(vars.slant, -12, SLNT_MIN, 0);
+          var RTL = vars.direction === "rtl";
+
+          /* ── Build one span per character ─────────────────────────────────
+             Spaces get a span too, so the crest travels at a constant rate in
+             index space and the visual gap between words is honoured. */
+          var chars = Array.prototype.slice.call(TEXT);
+          var spans = chars.map(function (ch) {
+            var el = document.createElement("span");
+            el.className = "ww-ch";
+            el.textContent = ch;
+            line.appendChild(el);
+            return el;
+          });
+          var N = spans.length;
+
+          /* Fit at the HEAVIEST instance so the line never overflows mid-sweep;
+             the crest widens glyphs as it passes. */
+          var fitCanvas = document.createElement("canvas").getContext("2d");
+          var heaviest = Math.max(W_FROM, W_TO);
+          var fontSize = BASE_FONT_SIZE;
+          while (fontSize > MIN_FONT_SIZE) {
+            fitCanvas.font = heaviest + " " + fontSize + "px " + FONT_FAMILY;
+            if (fitCanvas.measureText(TEXT).width <= LINE_MAX_WIDTH) break;
+            fontSize -= 2;
+          }
+          line.style.fontSize = fontSize + "px";
+
+          /* ── The wave ─────────────────────────────────────────────────────
+             Closed form, no accumulators: every frame's state is a pure
+             function of the timeline position p, so a direct seek to frame N
+             and playing through to frame N produce identical pixels.
+
+               crest(p) = -CREST + wrap(p * duration * SPEED) * (N - 1 + 2*CREST)
+               f_i      = clamp(0, 1, 1 - |i - crest| / CREST)
+               wght_i   = round(lerp(W_FROM, W_TO, f_i))
+               slnt_i   = lerp(0, SLANT, f_i)
+
+             Per-character stagger is not a separate mechanism — it falls out of
+             the crest's distance to each index. */
+          var state = { p: 0 };
+          var travel = N - 1 + 2 * CREST;
+
+          function paint() {
+            var pass = state.p * duration * SPEED;
+            var phase = pass - Math.floor(pass); // wraps cleanly: f_i == 0 at both ends
+            var crest = -CREST + phase * travel;
+            if (RTL) crest = N - 1 - crest;
+            for (var i = 0; i < N; i++) {
+              var f = 1 - Math.abs(i - crest) / CREST;
+              if (f < 0) f = 0;
+              else if (f > 1) f = 1;
+              var wght = Math.round(W_FROM + (W_TO - W_FROM) * f);
+              var slnt = SLANT * f;
+              spans[i].style.fontVariationSettings =
+                '"wght" ' + wght + ', "slnt" ' + slnt.toFixed(2);
+            }
+          }
+
+          var tl = gsap.timeline({ paused: true });
+          tl.to(state, { p: 1, duration: duration, ease: "none", onUpdate: paint }, 0);
+          paint();
+          window.__timelines["weight-wave"] = tl;
+
+          /* ── The trap, made loud ──────────────────────────────────────────
+             A static font (or a failed load) renders every character at one
+             weight: the effect is invisible and nothing throws.
+
+             Measuring advance width does NOT detect that here. Recursive is
+             DUPLEXED — "HAMBURGEFONSTIV" measures exactly 925px at wght 300 and
+             at wght 1000, and identically at slnt 0 and -15. (Nice for layout:
+             the headline never reflows as the crest passes. Fatal for a
+             width-delta probe, which reads every weight as identical and cries
+             wolf on a perfectly healthy font.)
+
+             So rasterize and count ink, which cannot be duplexed away, AND ask
+             the font-loading API whether the family is actually there. Both are
+             needed: ink alone gives a false PASS when the family is missing,
+             because the fallback varies its ink with weight too. */
+          function probeAxes() {
+            var family = "Recursive Wave";
+            var loaded = !!(document.fonts && document.fonts.check('100px "' + family + '"'));
+            var c = document.createElement("canvas");
+            c.width = 1000;
+            c.height = 160;
+            var ctx = c.getContext("2d", { willReadFrequently: true });
+            function ink(weight) {
+              ctx.clearRect(0, 0, c.width, c.height);
+              ctx.font = weight + ' 100px "' + family + '"';
+              ctx.fillStyle = "#fff";
+              ctx.fillText("HAMBURGEFONSTIV", 10, 120);
+              var data = ctx.getImageData(0, 0, c.width, c.height).data;
+              var n = 0;
+              for (var i = 3; i < data.length; i += 4) if (data[i] > 8) n++;
+              return n;
+            }
+            var light = ink(WGHT_MIN);
+            var black = ink(WGHT_MAX);
+            // Only wght is probed: it is the axis whose absence is measurable
+            // from JS, and both axes ship in the same file — if wght is live,
+            // the variable font loaded. slnt is verified visually.
+            return {
+              fontLoaded: loaded,
+              wghtLive: black > light * 1.2,
+              inkAtMinWeight: light,
+              inkAtMaxWeight: black,
+            };
+          }
+
+          function publishProbe() {
+            var status = probeAxes();
+            status.ok = status.fontLoaded && status.wghtLive;
+            window.__WW_FONT_STATUS = status;
+            root.setAttribute("data-ww-font", status.ok ? "ok" : "missing-axes");
+            if (!status.ok) {
+              console.error(
+                "weight-wave: the variable font is not usable (loaded=" +
+                  status.fontLoaded +
+                  ", ink at wght " +
+                  WGHT_MIN +
+                  "=" +
+                  status.inkAtMinWeight +
+                  " vs " +
+                  WGHT_MAX +
+                  "=" +
+                  status.inkAtMaxWeight +
+                  "). assets/fonts/Recursive-wght-slnt-latin.woff2 did not load, or was " +
+                  "replaced with a static font — every character will render at one weight.",
+              );
+            }
+          }
+
+          if (document.fonts && document.fonts.ready) {
+            document.fonts.ready.then(publishProbe);
+          } else {
+            publishProbe();
+          }
+        })();
+      </script>
+    </div>
+  </body>
+</html>
diff --git a/registry/registry.json b/registry/registry.json
index bff47f2948..b6c564ade0 100644
--- a/registry/registry.json
+++ b/registry/registry.json
@@ -706,6 +706,10 @@
     {
       "name": "beat-freeze-cut",
       "type": "hyperframes:block"
+    },
+    {
+      "name": "weight-wave",
+      "type": "hyperframes:block"
     }
   ]
 }