kitbash Connect agent

Scanline Red

Editorial · 7 parts · zine · essay · radio

Pure red and near-black, nothing else: headline letters built from rows of horizontal bars that swell, slip and tear, black registration blocks in the margins, bold narrow capitals and big links in a scanline face. Suits essays, archives, radio and sound projects, zines and anything that wants to look transmitted rather than printed.

Get pack Remix

Whole page

Parts

Scanline lettering

Hero with two words drawn on canvas from a seven-row bar alphabet: a thin, still word behind and a front word whose bars swell and sink into it, with rows that slip sideways at random and smear under the pointer. Registration blocks on the page edges, a meta line with a live slip counter. The words are read from the heading, which stays in the page for screen readers.

Code React For Figma
<header class="signal">
  <div class="signal__stage">
    <h1 class="signal__title">
      <span class="signal__word signal__word--front">Static</span>
      <span class="signal__word signal__word--back">Almanac</span>
    </h1>
    <canvas class="signal__canvas" aria-hidden="true"></canvas>
    <span class="signal__frame" aria-hidden="true"></span>
  </div>
  <p class="signal__meta">
    <span class="signal__issue">Vol. 07 / Winter log</span>
    <span class="signal__slips" aria-hidden="true">Line slips <span class="signal__count">000</span></span>
  </p>
</header>

<style>
  .signal {
    position: relative;
    overflow: hidden;
    padding-block: clamp(3.5rem, 9vw, 6.5rem) clamp(2rem, 5vw, 3.5rem);
    background: var(--red);
    color: var(--dark);
  }

  /* Registration blocks on both page edges: two per side, drawn as backgrounds so they need no markup. */
  .signal::before,
  .signal::after {
    content: "";
    position: absolute;
    inset-block: 0;
    width: var(--tick-w);
    background:
      linear-gradient(var(--dark), var(--dark)) 0 9% / 100% var(--tick-1) no-repeat,
      linear-gradient(var(--dark), var(--dark)) 0 55% / 100% var(--tick-2) no-repeat;
    pointer-events: none;
  }
  .signal::before {
    left: 0;
  }
  .signal::after {
    right: 0;
  }

  .signal__stage {
    position: relative;
  }

  /* Without script the title is plain text in the pixel face. With script it stays for screen readers and the canvas draws it. */
  .signal__title {
    margin: 0;
    padding-inline: var(--edge) var(--gutter);
    font-family: var(--font-pixel);
    font-size: clamp(1.5rem, 9vw, 5rem);
    font-weight: 400;
    font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--scan-thin);
    line-height: 1.3;
    text-transform: uppercase;
  }
  .signal__word {
    display: block;
  }
  .signal.is-drawn .signal__title {
    position: absolute;
    width: 1px;
    height: 1px;
    padding: 0;
    overflow: hidden;
    clip-path: inset(50%);
    white-space: nowrap;
  }

  .signal__canvas {
    display: none;
    width: 100%;
    touch-action: pan-y;
  }
  .signal.is-drawn .signal__canvas {
    display: block;
  }

  /* The box the lettering is fitted into. The script reads its left edge and width, so the layout stays in CSS. */
  .signal__frame {
    position: absolute;
    inset: 0 var(--gutter) 0 var(--edge);
    max-width: 72rem;
    pointer-events: none;
  }
  .signal__frame::before,
  .signal__frame::after {
    content: "";
    position: absolute;
    left: calc(-1 * var(--step-offset));
    width: var(--tick-w);
    height: var(--tick-4);
    background: var(--dark);
  }
  .signal__frame::before {
    top: 12%;
  }
  .signal__frame::after {
    bottom: -18%;
  }

  .signal__meta {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
    gap: var(--space-xs) var(--space-m);
    margin: clamp(2.5rem, 6vw, 4rem) 0 0;
    padding-inline: var(--edge) var(--gutter);
    font-size: var(--text-s);
    line-height: var(--leading-tight);
    text-transform: uppercase;
  }
  .signal__count {
    display: inline-block;
    padding-inline: 0.35em;
    background: var(--dark);
    color: var(--red);
    font-variant-numeric: tabular-nums;
  }
</style>

<script>
  (() => {
    /* The alphabet: seven scan rows per letter, seven columns wide. Every run of # becomes one bar. */
    const GLYPHS = {
      A: "..###../.##.##./##...##/##...##/#######/##...##/##...##",
      B: "######./##...##/##...##/######./##...##/##...##/######.",
      C: ".#####./##...##/##...../##...../##...../##...##/.#####.",
      D: "#####../##..##./##...##/##...##/##...##/##..##./#####..",
      E: "#######/##...../##...../#####../##...../##...../#######",
      F: "#######/##...../##...../#####../##...../##...../##.....",
      G: ".#####./##...##/##...../##.####/##...##/##...##/.#####.",
      H: "##...##/##...##/##...##/#######/##...##/##...##/##...##",
      I: ".#####./..###../..###../..###../..###../..###../.#####.",
      J: "...####/.....##/.....##/.....##/##...##/##...##/.#####.",
      K: "##...##/##..##./##.##../####.../##.##../##..##./##...##",
      L: "##...../##...../##...../##...../##...../##...../#######",
      M: "##...##/###.###/#######/##.#.##/##...##/##...##/##...##",
      N: "##...##/###..##/####.##/##.####/##..###/##...##/##...##",
      O: ".#####./##...##/##...##/##...##/##...##/##...##/.#####.",
      P: "######./##...##/##...##/######./##...../##...../##.....",
      Q: ".#####./##...##/##...##/##...##/##.#.##/##..##./.###.##",
      R: "######./##...##/##...##/######./##.##../##..##./##...##",
      S: ".#####./##...##/##...../.#####./.....##/##...##/.#####.",
      T: "#######/..###../..###../..###../..###../..###../..###..",
      U: "##...##/##...##/##...##/##...##/##...##/##...##/.#####.",
      V: "##...##/##...##/##...##/##...##/.##.##./..###../...#...",
      W: "##...##/##...##/##...##/##.#.##/#######/###.###/##...##",
      X: "##...##/.##.##./..###../..###../..###../.##.##./##...##",
      Y: "##...##/##...##/.##.##./..###../..###../..###../..###..",
      Z: "#######/....##./...##../..##.../.##..../##...../#######",
      0: ".#####./##...##/##..###/##.#.##/###..##/##...##/.#####.",
      1: "..###../.####../..###../..###../..###../..###../.#####.",
      2: ".#####./##...##/.....##/...###./.###.../##...../#######",
      3: ".#####./##...##/.....##/..####./.....##/##...##/.#####.",
      4: "...###./..####./.##.##./##..##./#######/....##./....##.",
      5: "#######/##...../######./.....##/.....##/##...##/.#####.",
      6: ".#####./##...../######./##...##/##...##/##...##/.#####.",
      7: "#######/.....##/....##./...##../..##.../..##.../..##...",
      8: ".#####./##...##/##...##/.#####./##...##/##...##/.#####.",
      9: ".#####./##...##/##...##/.######/.....##/.....##/.#####.",
      "-": "......./......./......./.#####./......./......./.......",
      " ": "......./......./......./......./......./......./.......",
    };
    const GLYPH_ROWS = 7;
    const GLYPH_ADVANCE = 8;
    const UNKNOWN_GLYPH = "-";

    /* The stage, measured in rows. The back word sits still, the front word travels down into it. */
    const STAGE_ROWS = 16;
    const FRONT_TOP_ROW = 0.6;
    const FRONT_TRAVEL_ROWS = 2.4;
    const BACK_TOP_ROW = 8;
    const MAX_ROW_PX = 22;

    /* Bar weights as a share of one row. */
    const BACK_WEIGHT = 0.24;
    const FRONT_WEIGHT_THIN = 0.2;
    const FRONT_WEIGHT_FULL = 0.8;
    const HALO_WEIGHT = 0.3;
    const INK_BLEED = 0.22;
    const BREATH_START = 0.19;
    const STILL_BREATH = 0.7;

    /* Line slips: a band of rows jumps sideways. Short ones flicker, long ones hold and snap back. */
    const FRAME_MS = 33;
    const FIRST_SLIP = { firstRow: 4, rows: 2, shift: 1.5, holdMs: 1500, flickers: false, delayMs: 900 };
    const SLIP_GAP_MS = [1300, 4200];
    const FLICKER_MS = [120, 320];
    const HOLD_MS = [700, 1500];
    const SLIP_SHIFT = [0.8, 3.6];
    const FLICKER_STEP_MS = 70;
    const HOLD_CHANCE = 0.4;

    /* Dragging the pointer across the lettering smears the rows under it. */
    const PULL_GAIN = 0.07;
    const PULL_LIMIT = 4;
    const PULL_DECAY = 0.86;

    const between = ([low, high]) => low + Math.random() * (high - low);

    const barsOfGlyph = (pattern, column) =>
      pattern.split("/").flatMap((row, rowIndex) =>
        [...row.matchAll(/#+/g)].map((run) => ({
          row: rowIndex,
          from: column + run.index,
          to: column + run.index + run[0].length,
        })),
      );

    const layoutWord = (text) => {
      const letters = [...text.trim().toUpperCase()];
      return {
        columns: letters.length * GLYPH_ADVANCE - 1,
        bars: letters.flatMap((letter, index) => barsOfGlyph(GLYPHS[letter] || GLYPHS[UNKNOWN_GLYPH], index * GLYPH_ADVANCE)),
      };
    };

    const breathAt = (seconds, cycle) => 0.5 - 0.5 * Math.cos(2 * Math.PI * (seconds / cycle + BREATH_START));

    const newSlip = (now) => {
      const holds = Math.random() < HOLD_CHANCE;
      const rows = 1 + Math.floor(Math.random() * 3);
      return {
        firstRow: Math.floor(Math.random() * (STAGE_ROWS - rows)),
        rows,
        shift: between(SLIP_SHIFT) * (Math.random() < 0.5 ? -1 : 1),
        until: now + between(holds ? HOLD_MS : FLICKER_MS),
        flickers: !holds,
      };
    };

    const slipShiftAt = (slip, row, now) => {
      if (row < slip.firstRow || row >= slip.firstRow + slip.rows) return 0;
      if (!slip.flickers) return slip.shift;
      return Math.floor(now / FLICKER_STEP_MS) % 2 ? slip.shift : slip.shift * -0.4;
    };

    const setUpSignal = (root) => {
      const canvas = root.querySelector(".signal__canvas");
      const frame = root.querySelector(".signal__frame");
      const counter = root.querySelector(".signal__count");
      const context = canvas.getContext("2d");
      const tokens = getComputedStyle(root);
      const ink = tokens.getPropertyValue("--dark").trim();
      const paper = tokens.getPropertyValue("--red").trim();
      const cycleSeconds = parseFloat(tokens.getPropertyValue("--cycle")) || 24;
      const front = layoutWord(root.querySelector(".signal__word--front").textContent);
      const back = layoutWord(root.querySelector(".signal__word--back").textContent);
      const widestColumns = Math.max(front.columns, back.columns);
      const reducedMotion = matchMedia("(prefers-reduced-motion: reduce)");
      const pull = new Float32Array(STAGE_ROWS);

      let rowPx = 0;
      let originX = 0;
      let pixelRatio = 1;
      let slips = [];
      let slipCount = 0;
      let nextSlipAt = 0;
      let startedAt = 0;
      let lastFrameAt = 0;
      let frameRequest = 0;
      let onScreen = false;

      const measure = () => {
        rowPx = Math.min(frame.offsetWidth / widestColumns, MAX_ROW_PX);
        originX = frame.offsetLeft;
        pixelRatio = Math.min(window.devicePixelRatio || 1, 2);
        canvas.style.height = `${STAGE_ROWS * rowPx}px`;
        canvas.width = Math.round(canvas.clientWidth * pixelRatio);
        canvas.height = Math.round(STAGE_ROWS * rowPx * pixelRatio);
      };

      const shiftOfRow = (row, now) => {
        const slipped = slips.reduce((sum, slip) => sum + slipShiftAt(slip, row, now), 0);
        return (slipped + (pull[row] || 0)) * rowPx;
      };

      const traceWord = (word, left, topRow, weight, now) => {
        context.beginPath();
        word.bars.forEach((bar) => {
          const stageRow = topRow + bar.row;
          const y = (stageRow + 0.5) * rowPx;
          const shift = shiftOfRow(Math.floor(stageRow + 0.5), now);
          const start = left + bar.from * rowPx + weight / 2 + shift;
          const end = left + bar.to * rowPx - weight / 2 + shift;
          context.moveTo(start, y);
          context.lineTo(Math.max(end, start + 0.01), y);
        });
      };

      const paint = (breath, now) => {
        const frontWeight = (FRONT_WEIGHT_THIN + (FRONT_WEIGHT_FULL - FRONT_WEIGHT_THIN) * breath) * rowPx;
        const frontLeft = originX + ((back.columns - front.columns) / 2) * rowPx;

        context.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
        context.clearRect(0, 0, canvas.width, canvas.height);
        context.lineCap = "round";

        context.shadowBlur = 0;
        context.strokeStyle = ink;
        context.lineWidth = BACK_WEIGHT * rowPx;
        traceWord(back, originX, BACK_TOP_ROW, BACK_WEIGHT * rowPx, now);
        context.stroke();

        /* The front word is stroked twice: first in the page colour, wider, to burn a halo through the back word, then in ink. */
        traceWord(front, frontLeft, FRONT_TOP_ROW + FRONT_TRAVEL_ROWS * breath, frontWeight, now);
        context.strokeStyle = paper;
        context.shadowColor = paper;
        context.shadowBlur = HALO_WEIGHT * rowPx * pixelRatio;
        context.lineWidth = frontWeight + HALO_WEIGHT * rowPx;
        context.stroke();
        context.strokeStyle = ink;
        context.shadowColor = ink;
        context.shadowBlur = INK_BLEED * rowPx * pixelRatio;
        context.lineWidth = frontWeight;
        context.stroke();
      };

      const paintStill = () => {
        slips = [];
        pull.fill(0);
        paint(STILL_BREATH, 0);
      };

      const startSlip = (slip) => {
        slips.push(slip);
        slipCount += 1;
        counter.textContent = String(slipCount % 1000).padStart(3, "0");
      };

      const updateSlips = (now) => {
        slips = slips.filter((slip) => slip.until > now);
        if (now < nextSlipAt) return;
        startSlip(slipCount ? newSlip(now) : { ...FIRST_SLIP, until: now + FIRST_SLIP.holdMs });
        nextSlipAt = now + between(SLIP_GAP_MS);
      };

      const relaxPull = () => {
        pull.forEach((value, row) => {
          pull[row] = value * PULL_DECAY;
        });
      };

      const tick = (now) => {
        frameRequest = requestAnimationFrame(tick);
        if (now - lastFrameAt < FRAME_MS) return;
        lastFrameAt = now;
        updateSlips(now);
        relaxPull();
        paint(breathAt((now - startedAt) / 1000, cycleSeconds), now);
      };

      const stop = () => {
        cancelAnimationFrame(frameRequest);
        frameRequest = 0;
      };

      const run = () => {
        stop();
        if (reducedMotion.matches) {
          paintStill();
          return;
        }
        if (!onScreen) return;
        startedAt = startedAt || performance.now();
        nextSlipAt = nextSlipAt || startedAt + FIRST_SLIP.delayMs;
        frameRequest = requestAnimationFrame(tick);
      };

      const smear = (event) => {
        if (reducedMotion.matches || !rowPx) return;
        const row = Math.floor((event.clientY - canvas.getBoundingClientRect().top) / rowPx);
        [row - 1, row, row + 1].forEach((nearRow, index) => {
          if (nearRow < 0 || nearRow >= STAGE_ROWS) return;
          const gain = index === 1 ? PULL_GAIN : PULL_GAIN / 2;
          pull[nearRow] = Math.max(-PULL_LIMIT, Math.min(PULL_LIMIT, pull[nearRow] + event.movementX * gain));
        });
      };

      root.classList.add("is-drawn");
      measure();
      paintStill();

      new ResizeObserver(() => {
        measure();
        if (frameRequest) return;
        paintStill();
      }).observe(root);
      new IntersectionObserver(([entry]) => {
        onScreen = entry.isIntersecting;
        run();
      }).observe(root);
      reducedMotion.addEventListener("change", run);
      canvas.addEventListener("pointermove", smear);
    };

    document.querySelectorAll(".signal").forEach(setUpSignal);
  })();
</script>

Scan-weight index

Dark band with a summary in bold narrow capitals between two red step blocks, then large links in one scanline face at three settings (hairlines, beads, swollen rows), each with a bar arrow of matching weight. Hover snaps a link to thin rows and pushes its arrow on.

Code React For Figma
<nav class="channels" aria-label="What is in the almanac">
  <p class="channels__summary">Static Almanac is a yearbook of things heard on shortwave after midnight: voices reading numbers, clocks that never stop, weather maps sent as sound, and the hiss in between.</p>
  <ol class="channels__list">
    <li class="channels__item channels__item--thin">
      <a class="channels__link" href="#">
        Numbers
        <svg class="channels__arrow" viewBox="0 0 48 30" aria-hidden="true">
          <path d="M2 15h44M33 11h9M29 7h8M25 3h7M33 19h9M29 23h8M25 27h7" />
        </svg>
      </a>
    </li>
    <li class="channels__item channels__item--dots">
      <a class="channels__link" href="#">
        Time signals
        <svg class="channels__arrow" viewBox="0 0 48 30" aria-hidden="true">
          <path d="M2 15h44M33 11h9M29 7h8M25 3h7M33 19h9M29 23h8M25 27h7" />
        </svg>
      </a>
    </li>
    <li class="channels__item channels__item--heavy">
      <a class="channels__link" href="#">
        Weather by fax
        <svg class="channels__arrow" viewBox="0 0 48 30" aria-hidden="true">
          <path d="M2 15h44M33 11h9M29 7h8M25 3h7M33 19h9M29 23h8M25 27h7" />
        </svg>
      </a>
    </li>
  </ol>
</nav>

<style>
  .channels {
    padding: var(--space-m) var(--gutter) var(--space-m) var(--edge);
    background: var(--dark);
    color: var(--red);
  }

  /* The summary is bracketed by two red step blocks that hang in the margin, one above and one below. */
  .channels__summary {
    position: relative;
    max-width: var(--measure);
    margin: 0;
    padding-block: calc(var(--tick-3) + var(--space-s));
    line-height: 1.42;
    text-transform: uppercase;
    text-wrap: pretty;
  }
  .channels__summary::before,
  .channels__summary::after {
    content: "";
    position: absolute;
    left: calc(-1 * var(--step-offset));
    width: var(--tick-w);
    height: var(--tick-3);
    background: var(--red);
  }
  .channels__summary::before {
    top: 0;
  }
  .channels__summary::after {
    bottom: 0;
  }

  .channels__list {
    margin: 0;
    padding: 0;
    list-style: none;
  }

  /* One face, three settings of its scan axis: hairlines, beads, swollen rows. The arrow gets heavier with it. */
  .channels__item {
    --channels-scan: var(--scan-thin);
    --channels-stroke: 0.06rem;
  }
  .channels__item--dots {
    --channels-scan: var(--scan-dots);
    --channels-stroke: 0.2rem;
  }
  .channels__item--heavy {
    --channels-scan: var(--scan-heavy);
    --channels-stroke: 0.3rem;
  }

  .channels__link {
    display: inline-flex;
    flex-wrap: wrap;
    align-items: center;
    column-gap: 0.5em;
    min-height: var(--tap);
    padding-block: 0.16em;
    color: inherit;
    font-family: var(--font-scan);
    font-size: var(--display-link);
    font-weight: 400;
    font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--channels-scan);
    line-height: 1.2;
    text-decoration: none;
    text-shadow: 0 0 0.1rem var(--glow), 0 0 0.1rem var(--glow);
    text-transform: uppercase;
    transition: font-variation-settings var(--time-snap) var(--ease-snap);
  }
  .channels__arrow {
    flex: none;
    width: 0.9em;
    height: 0.56em;
    overflow: visible;
    fill: none;
    stroke: currentColor;
    stroke-linecap: round;
    stroke-width: var(--channels-stroke);
    filter: drop-shadow(0 0 0.08rem var(--glow));
    transition: stroke-width var(--time-snap) var(--ease-snap), translate var(--time-snap) var(--ease-snap);
  }

  /* Hover tunes every link to the same thin setting and pushes the arrow on, in hard steps. */
  .channels__link:hover,
  .channels__link:focus-visible {
    font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--scan-hover);
    text-shadow: none;
  }
  .channels__link:hover .channels__arrow,
  .channels__link:focus-visible .channels__arrow {
    stroke-width: 0.08rem;
    translate: 0.35em 0;
    filter: none;
  }
  .channels__link:focus-visible {
    outline: var(--rule-double) solid var(--red);
    outline-offset: 0.2em;
  }

  @media (prefers-reduced-motion: reduce) {
    .channels__link,
    .channels__arrow {
      transition-duration: 0s;
    }
    .channels__link:hover .channels__arrow,
    .channels__link:focus-visible .channels__arrow {
      translate: none;
    }
  }
</style>

Echo title card

Article opener: a dark label bar with a bar arrow and a pixel-face label that sticks to the top, the title set three times in hairline scan rows with a leaning solid copy that slides through them, a byline and an opening statement in capitals.

Code React For Figma
<header class="titlecard">
  <div class="titlecard__bar">
    <a class="titlecard__back" href="#">
      <svg class="titlecard__arrow" viewBox="0 0 48 30" aria-hidden="true">
        <path d="M46 15H2M15 11H6M19 7h-8M23 3h-7M15 19H6M19 23h-8M23 27h-7" />
      </svg>
      Numbers
    </a>
  </div>

  <h1 class="titlecard__title">
    <span class="titlecard__echo" aria-hidden="true">Numbers</span>
    <span class="titlecard__echo">Numbers</span>
    <span class="titlecard__echo" aria-hidden="true">Numbers</span>
    <span class="titlecard__solid" aria-hidden="true">Numbers</span>
  </h1>

  <div class="titlecard__byline">
    <p class="titlecard__author">Ines Halloran</p>
    <p class="titlecard__post">Log keeper, north attic post</p>
    <time class="titlecard__date" datetime="2027-01-09">January 9, 2027</time>
  </div>

  <p class="titlecard__starter">Somebody still reads five-figure groups to nobody at four in the morning.</p>
</header>

<style>
  .titlecard {
    position: relative;
    padding-bottom: var(--space-m);
    background: var(--red);
    color: var(--dark);
  }

  /* Registration blocks on both page edges. */
  .titlecard::before,
  .titlecard::after {
    content: "";
    position: absolute;
    inset-block: 0;
    width: var(--tick-w);
    background:
      linear-gradient(var(--dark), var(--dark)) 0 16% / 100% var(--tick-1) no-repeat,
      linear-gradient(var(--dark), var(--dark)) 0 42% / 100% var(--tick-1) no-repeat,
      linear-gradient(var(--dark), var(--dark)) 0 88% / 100% var(--tick-2) no-repeat;
    pointer-events: none;
  }
  .titlecard::before {
    left: 0;
  }
  .titlecard::after {
    right: 0;
  }

  /* A dark label bar that stays on top while the opener is on screen. */
  .titlecard__bar {
    position: sticky;
    top: 0;
    z-index: 2;
    display: flex;
    align-items: center;
    min-height: var(--bar-height);
    padding-inline: var(--edge) var(--gutter);
    background: var(--dark);
    color: var(--red);
  }
  .titlecard__back {
    display: inline-flex;
    align-items: center;
    column-gap: 0.7em;
    min-height: var(--tap);
    color: inherit;
    font-family: var(--font-pixel);
    font-size: var(--text-s);
    font-weight: 400;
    font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--scan-hover);
    letter-spacing: 0;
    text-decoration: none;
    text-shadow: 0 0 0.1rem var(--glow), 0 0 0.1rem var(--glow);
    text-transform: uppercase;
    transition: font-variation-settings var(--time-snap) var(--ease-snap);
  }
  .titlecard__arrow {
    flex: none;
    width: 1.9em;
    height: 1.2em;
    overflow: visible;
    fill: none;
    stroke: currentColor;
    stroke-linecap: round;
    stroke-width: 0.12rem;
    transition: translate var(--time-snap) var(--ease-snap);
  }
  .titlecard__back:hover,
  .titlecard__back:focus-visible {
    font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--scan-heavy);
    text-shadow: none;
  }
  .titlecard__back:hover .titlecard__arrow,
  .titlecard__back:focus-visible .titlecard__arrow {
    translate: -0.4em 0;
  }
  .titlecard__back:focus-visible {
    outline: var(--rule-double) solid var(--red);
    outline-offset: 0.3em;
  }

  /* The title three times in hairline scan rows, each casting a page-coloured haze, and once solid underneath, leaning. */
  .titlecard__title {
    position: relative;
    isolation: isolate;
    width: fit-content;
    max-width: 100%;
    margin: var(--space-m) var(--gutter) 0 var(--edge);
    font-family: var(--font-scan);
    font-size: var(--display-echo);
    font-style: italic;
    font-weight: 400;
    font-variation-settings: "BLED" var(--bleed-soft), "SCAN" var(--scan-thin);
    line-height: 0.82;
    letter-spacing: 0;
    text-transform: uppercase;
  }
  .titlecard__echo {
    position: relative;
    z-index: 1;
    display: block;
    padding-top: 0.06em;
    text-shadow: -0.2rem 0.2rem 0.4rem var(--glow), -0.2rem 0.2rem 0.4rem var(--glow);
  }
  .titlecard__solid {
    position: absolute;
    inset: 0 auto auto 0.12em;
    font-family: var(--font-text);
    font-size: 0.86em;
    font-style: normal;
    font-weight: 700;
    line-height: 1;
    transform: translateY(0.92em) skewX(5deg);
    animation: titlecard-drift var(--drift) linear infinite alternate;
  }
  @keyframes titlecard-drift {
    from {
      transform: translateY(0.02em) skewX(5deg);
    }
    to {
      transform: translateY(1.86em) skewX(5deg);
    }
  }

  .titlecard__byline {
    margin: var(--space-m) var(--gutter) 0 var(--edge);
    font-size: var(--text-s);
    font-weight: 400;
    line-height: var(--leading);
  }
  .titlecard__author,
  .titlecard__post {
    margin: 0;
  }
  .titlecard__author {
    margin-bottom: var(--space-xs);
    font-size: var(--text-m);
    font-weight: 700;
  }
  .titlecard__date {
    display: block;
  }

  .titlecard__starter {
    max-width: 21em;
    margin: var(--space-m) var(--gutter) 0 var(--edge);
    font-size: var(--text-l);
    line-height: var(--leading-tight);
    text-transform: uppercase;
    text-wrap: balance;
  }

  @media (prefers-reduced-motion: reduce) {
    .titlecard__solid {
      animation: none;
    }
    .titlecard__back,
    .titlecard__arrow {
      transition-duration: 0s;
    }
  }
</style>

Reading passage

Running copy under a sticky dark heading band: italic links on a double rule that flip to a dark chip, a marked passage with a square bullet and solid underline, a footnote chip and a small citation set a third of the way into the column.

Code React For Figma
<article class="passage">
  <h2 class="passage__heading">Who is it for?</h2>

  <p class="passage__text">A numbers station is a voice, usually synthetic, that comes up on a fixed frequency at a fixed minute and reads groups of five digits until it stops. Nobody announces it and nobody signs off. The <a class="passage__link" href="#">attic post logbook</a> has four hundred and twelve of these since October, and the keepers agree on almost nothing about them except the schedule.<sup class="passage__ref">1</sup></p>

  <p class="passage__text">The schedule is the interesting part. <mark class="passage__mark">A message meant for one listener is sent to the whole hemisphere, because that is the only way nobody can tell who was listening.</mark> Everything else about the broadcast follows from that: the flat voice, the repeats, the cheap transmitter left running in a field.</p>

  <aside class="passage__cite">
    <span class="passage__ref">1</span>
    <p class="passage__source">Counted from the shared log, entries marked “voice, digits”. Repeats inside one hour are counted once.</p>
  </aside>
</article>

<style>
  .passage {
    position: relative;
    padding: var(--space-m) var(--gutter) var(--space-l) var(--edge);
    background: var(--red);
    color: var(--dark);
    font-weight: 500;
  }

  /* Registration blocks on both page edges. */
  .passage::before,
  .passage::after {
    content: "";
    position: absolute;
    inset-block: 0;
    width: var(--tick-w);
    background:
      linear-gradient(var(--dark), var(--dark)) 0 14% / 100% var(--tick-1) no-repeat,
      linear-gradient(var(--dark), var(--dark)) 0 46% / 100% var(--tick-2) no-repeat,
      linear-gradient(var(--dark), var(--dark)) 0 100% / 100% var(--tick-3) no-repeat;
    pointer-events: none;
  }
  .passage::before {
    left: 0;
  }
  .passage::after {
    right: 0;
  }

  /* A dark band that sticks to the top while its section is read. It is wider than the column by its own padding. */
  .passage__heading {
    position: sticky;
    top: 0;
    z-index: 1;
    max-width: calc(var(--measure) + 2 * var(--space-s));
    margin: 0 calc(-1 * min(var(--space-s), var(--gutter))) var(--space-m) calc(-1 * min(var(--space-s), var(--edge)));
    padding: 0.55em min(var(--space-s), var(--edge));
    background: var(--dark);
    color: var(--red);
    font-size: var(--text-l);
    font-weight: 700;
    line-height: var(--leading-tight);
    text-shadow: 0 0 0.06rem var(--glow), 0 0 0.06rem var(--glow);
  }

  .passage__text {
    max-width: var(--measure);
    margin: 0 0 var(--space-m);
    text-wrap: pretty;
  }

  /* Text links are italic on a double rule and flip to a dark chip on hover. The padding only makes the tap area taller. */
  .passage__link {
    padding-block: max(0px, (var(--tap) - 1em) / 2);
    background-clip: content-box;
    color: inherit;
    font-style: italic;
    text-decoration: underline double calc(var(--rule-double) / 3);
    text-underline-offset: 0.16em;
  }
  .passage__link:hover,
  .passage__link:focus-visible {
    background-color: var(--dark);
    color: var(--red);
    outline: none;
  }

  /* A marked passage keeps the page colour: a square bullet, then a solid rule under every line. */
  .passage__mark {
    background: none;
    box-shadow: 0 var(--rule-mark) 0 var(--dark);
    color: inherit;
  }
  .passage__mark::before {
    content: "";
    position: relative;
    top: 0.3em;
    display: inline-block;
    width: 0.45em;
    height: 0.45em;
    background: var(--dark);
  }

  .passage__ref {
    padding-inline: 0.35em;
    background: var(--dark);
    color: var(--red);
    font-size: var(--text-xs);
    font-weight: 700;
    line-height: 1.5;
  }
  sup.passage__ref {
    margin-left: 0.2em;
    vertical-align: super;
    line-height: 0;
  }

  /* Citations are small, regular weight and start a third of the way into the column. */
  .passage__cite {
    display: flex;
    align-items: start;
    column-gap: var(--space-xs);
    max-width: var(--measure);
    padding-left: min(33%, 15rem);
    font-size: var(--text-xs);
    font-weight: 400;
    line-height: 1.3;
  }
  .passage__source {
    margin: 0;
  }

  @media (max-width: 40rem) {
    .passage__cite {
      padding-left: 0;
    }
  }
</style>

Slab quote

Dark slab with red bold text, a kicker in beaded scan rows and a source line, a second slab offset behind it as a hard shadow and two square steps on its left corners.

Code React For Figma
<figure class="quote">
  <blockquote class="quote__block">
    <p class="quote__kicker">Standing order no. 4</p>
    <p class="quote__text">Write down what you hear, not what you think it is. If the voice says seven, write seven. If the carrier drops for a second, write that it dropped and for how long. Guessing goes in the margin, and the margin is not the log.</p>
    <footer class="quote__by">Pinned above the receiver, attic post, since 2019</footer>
  </blockquote>
</figure>

<style>
  .quote {
    position: relative;
    margin: 0;
    padding: var(--space-m) var(--gutter) calc(var(--space-m) + var(--shadow-offset)) var(--edge);
    background: var(--red);
  }

  /* Registration blocks on both page edges. */
  .quote::before,
  .quote::after {
    content: "";
    position: absolute;
    inset-block: 0;
    width: var(--tick-w);
    background:
      linear-gradient(var(--dark), var(--dark)) 0 22% / 100% var(--tick-2) no-repeat,
      linear-gradient(var(--dark), var(--dark)) 0 82% / 100% var(--tick-3) no-repeat;
    pointer-events: none;
  }
  .quote::before {
    left: 0;
  }
  .quote::after {
    right: 0;
  }

  /* A dark slab with a second slab knocked down and right behind it, and two square steps on its left corners. */
  .quote__block {
    position: relative;
    width: fit-content;
    max-width: min(var(--measure), 100% - var(--shadow-offset));
    margin: 0;
    padding: var(--space-s) 0 calc(var(--space-s) * 1.2);
    background: var(--dark);
    box-shadow: var(--shadow-offset) var(--shadow-offset) 0.12rem var(--dark);
    color: var(--red);
  }
  .quote__block::before,
  .quote__block::after {
    content: "";
    position: absolute;
    left: calc(-1 * min(var(--space-s), var(--edge)));
    width: min(var(--space-s), var(--edge));
    height: var(--tick-2);
    background: var(--dark);
  }
  .quote__block::before {
    top: calc(-1 * var(--tick-2));
  }
  .quote__block::after {
    bottom: 0;
  }

  .quote__kicker,
  .quote__text,
  .quote__by {
    margin: 0;
    padding-inline: var(--space-s);
  }
  .quote__kicker {
    margin-bottom: var(--space-xs);
    font-family: var(--font-scan);
    font-size: 1.25em;
    font-weight: 400;
    font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--scan-dots);
    line-height: 1.3;
    letter-spacing: 0;
  }
  .quote__text {
    font-size: 1.22em;
    line-height: 1.25;
    text-wrap: pretty;
  }
  .quote__by {
    margin-top: var(--space-s);
    font-size: var(--text-s);
    font-weight: 400;
    line-height: 1.3;
  }
</style>

Spectrum figure

Figure drawn live on canvas: a dark panel where rows of short red bars enter on top and step down, laid out as stations across a band with a ruler on the left, long sweeps and the odd solid row. Caption with a running line counter and a small double-ruled link.

Code React For Figma
<figure class="waterfall">
  <div class="waterfall__panel">
    <canvas class="waterfall__canvas" role="img" aria-label="A band of radio spectrum drawn as rows of short red bars on black, newest row on top"></canvas>
  </div>
  <figcaption class="waterfall__caption">
    <span class="waterfall__readout" aria-hidden="true">Line <span class="waterfall__line">0000</span></span>
    <span class="waterfall__note">Forty minutes around 6,925 kHz, newest line on top. Drawn in your browser, not recorded. Method in <a class="waterfall__link" href="#">the keepers' notes</a>.</span>
  </figcaption>
</figure>

<style>
  .waterfall {
    position: relative;
    margin: 0;
    padding: var(--space-m) var(--gutter) var(--space-l) var(--edge);
    background: var(--red);
    color: var(--dark);
  }

  /* Registration blocks on both page edges. */
  .waterfall::before,
  .waterfall::after {
    content: "";
    position: absolute;
    inset-block: 0;
    width: var(--tick-w);
    background:
      linear-gradient(var(--dark), var(--dark)) 0 12% / 100% var(--tick-1) no-repeat,
      linear-gradient(var(--dark), var(--dark)) 0 38% / 100% var(--tick-2) no-repeat,
      linear-gradient(var(--dark), var(--dark)) 0 78% / 100% var(--tick-3) no-repeat;
    pointer-events: none;
  }
  .waterfall::before {
    left: 0;
  }
  .waterfall::after {
    right: 0;
  }

  /* The panel carries two thin step blocks in the margin, like every block on the page. */
  .waterfall__panel {
    position: relative;
    max-width: var(--measure);
    padding-block: calc(var(--tick-1) + var(--space-s));
  }
  .waterfall__panel::before,
  .waterfall__panel::after {
    content: "";
    position: absolute;
    left: calc(-1 * var(--step-offset));
    width: var(--tick-w);
    height: var(--tick-1);
    background: var(--dark);
  }
  .waterfall__panel::before {
    top: 0;
  }
  .waterfall__panel::after {
    bottom: 0;
  }

  .waterfall__canvas {
    display: block;
    width: 100%;
    aspect-ratio: 16 / 9;
    background: var(--dark);
    image-rendering: pixelated;
  }

  .waterfall__caption {
    display: flex;
    flex-wrap: wrap;
    align-items: baseline;
    gap: var(--space-xs) var(--space-s);
    max-width: var(--measure);
    font-size: var(--text-xs);
    font-weight: 400;
    line-height: 1.5;
  }
  .waterfall__readout {
    font-weight: 700;
    text-transform: uppercase;
    white-space: nowrap;
  }
  .waterfall__line {
    display: inline-block;
    padding-inline: 0.35em;
    background: var(--dark);
    color: var(--red);
    font-variant-numeric: tabular-nums;
  }
  .waterfall__note {
    flex: 1 1 16em;
  }
  /* The link is small print: the padding makes its tap area taller without moving the lines. */
  .waterfall__link {
    padding-block: max(0px, (var(--tap) - 1em) / 2);
    background-clip: content-box;
    color: inherit;
    font-style: italic;
    text-decoration: underline double calc(var(--rule-double) / 3);
    text-underline-offset: 0.16em;
  }
  .waterfall__link:hover,
  .waterfall__link:focus-visible {
    background-color: var(--dark);
    color: var(--red);
    outline: none;
  }
</style>

<script>
  (() => {
    /* The picture is a grid of cells. A row is a list of runs; a new row enters on top and the rest step down. */
    const COLUMNS_WIDE = 80;
    const MIN_CELL_PX = 5;
    const BAR_SHARE = 0.66;
    const STEP_MS = 130;
    const FIRST_LINE = 412;

    /* Lanes are stations: where they sit across the band (0 to 1), how often they are on, how long a burst lasts. */
    const LANES = [
      { from: 0.04, to: 0.13, duty: 0.4, burst: [1, 3], steady: true },
      { from: 0.16, to: 0.25, duty: 0.34, burst: [2, 6], steady: false },
      { from: 0.27, to: 0.52, duty: 0.6, burst: [4, 12], steady: false, wanders: true },
      { from: 0.3, to: 0.48, duty: 0.3, burst: [2, 5], steady: false, wanders: true },
      { from: 0.59, to: 0.68, duty: 0.45, burst: [1, 4], steady: true },
      { from: 0.7, to: 0.715, duty: 0.45, burst: [1, 2], steady: true },
      { from: 0.74, to: 0.8, duty: 0.45, burst: [1, 5], steady: false },
      { from: 0.82, to: 0.9, duty: 0.36, burst: [1, 4], steady: false },
      { from: 0.925, to: 0.975, duty: 0.5, burst: [1, 3], steady: true },
    ];
    const BAND_END = 0.975;
    const SWEEP_CHANCE = 0.07;
    const HEAVY_CHANCE = 0.08;
    const RULER_EVERY = 2;
    const RULER_LONG_EVERY = 8;
    const WANDER_STEP = 0.35;

    const between = ([low, high]) => low + Math.random() * (high - low);
    const whole = (range) => Math.round(between(range));

    const newStation = (lane) => ({ lane, on: false, rowsLeft: 0, drift: 0.5 });

    const retune = (station) => {
      station.rowsLeft -= 1;
      if (station.rowsLeft > 0) return;
      station.on = Math.random() < station.lane.duty;
      station.rowsLeft = whole(station.lane.burst);
    };

    const wander = (station) => {
      station.drift = Math.min(1, Math.max(0, station.drift + (Math.random() - 0.5) * WANDER_STEP));
    };

    const runOfStation = (station, columns) => {
      const { lane } = station;
      const laneStart = Math.round(lane.from * columns);
      const laneWidth = Math.max(1, Math.round((lane.to - lane.from) * columns));
      if (lane.steady) return [laneStart, laneStart + laneWidth];
      const width = Math.max(1, Math.round(laneWidth * between([0.25, 0.7])));
      const offset = Math.round((laneWidth - width) * (lane.wanders ? station.drift : Math.random()));
      return [laneStart + offset, laneStart + offset + width];
    };

    const rulerRun = (lineNumber) => {
      if (lineNumber % RULER_LONG_EVERY === 0) return [[1, 3]];
      return lineNumber % RULER_EVERY === 0 ? [[1, 2]] : [];
    };

    const sweepRun = (columns) => {
      const start = Math.round(columns * LANES[whole([0, LANES.length - 1])].from);
      return Math.random() < SWEEP_CHANCE ? [[start, Math.round(columns * BAND_END)]] : [];
    };

    const nextRow = (stations, columns, lineNumber) => {
      stations.forEach(retune);
      stations.filter((station) => station.lane.wanders).forEach(wander);
      const stationRuns = stations.filter((station) => station.on).map((station) => runOfStation(station, columns));
      return {
        heavy: Math.random() < HEAVY_CHANCE,
        runs: [...rulerRun(lineNumber), ...stationRuns, ...sweepRun(columns)],
      };
    };

    const setUpWaterfall = (root) => {
      const canvas = root.querySelector(".waterfall__canvas");
      const readout = root.querySelector(".waterfall__line");
      const context = canvas.getContext("2d");
      const tokens = getComputedStyle(root);
      const bar = tokens.getPropertyValue("--red").trim();
      const ground = tokens.getPropertyValue("--dark").trim();
      const reducedMotion = matchMedia("(prefers-reduced-motion: reduce)");
      const stations = LANES.map(newStation);

      let cell = MIN_CELL_PX;
      let columns = COLUMNS_WIDE;
      let rowCount = 0;
      let rows = [];
      let lineNumber = FIRST_LINE;
      let lastStepAt = 0;
      let frameRequest = 0;
      let onScreen = false;

      const addRow = () => {
        lineNumber += 1;
        rows.unshift(nextRow(stations, columns, lineNumber));
        rows.length = Math.min(rows.length, rowCount);
      };

      const measure = () => {
        const pixelRatio = Math.min(window.devicePixelRatio || 1, 2);
        cell = Math.max(MIN_CELL_PX, Math.round(canvas.clientWidth / COLUMNS_WIDE));
        columns = Math.ceil(canvas.clientWidth / cell);
        rowCount = Math.ceil(canvas.clientHeight / cell);
        canvas.width = Math.round(canvas.clientWidth * pixelRatio);
        canvas.height = Math.round(canvas.clientHeight * pixelRatio);
        context.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
        while (rows.length < rowCount) addRow();
      };

      const paint = () => {
        const barHeight = Math.max(2, Math.round(cell * BAR_SHARE));
        const rowGap = cell - barHeight;
        context.fillStyle = ground;
        context.fillRect(0, 0, canvas.clientWidth, canvas.clientHeight);
        context.fillStyle = bar;
        rows.forEach((row, index) => {
          row.runs.forEach(([from, to]) => {
            context.fillRect(from * cell, index * cell + rowGap, (to - from) * cell, row.heavy ? cell : barHeight);
          });
        });
        readout.textContent = String(lineNumber % 10000).padStart(4, "0");
      };

      const tick = (now) => {
        frameRequest = requestAnimationFrame(tick);
        if (now - lastStepAt < STEP_MS) return;
        lastStepAt = now;
        addRow();
        paint();
      };

      const stop = () => {
        cancelAnimationFrame(frameRequest);
        frameRequest = 0;
      };

      const run = () => {
        stop();
        if (reducedMotion.matches || !onScreen) return;
        frameRequest = requestAnimationFrame(tick);
      };

      new ResizeObserver(() => {
        measure();
        paint();
      }).observe(canvas);
      new IntersectionObserver(([entry]) => {
        onScreen = entry.isIntersecting;
        run();
      }).observe(root);
      reducedMotion.addEventListener("change", run);
    };

    document.querySelectorAll(".waterfall").forEach(setUpWaterfall);
  })();
</script>

Colophon

Dark footer: next pieces in bold narrow capitals with a bar arrow that steps in on hover, a pixel-face wordmark between two red step blocks whose scan rows breathe while it is on screen, credits and a copyright line in small print.

Code React For Figma
<footer class="colophon">
  <nav class="colophon__next" aria-label="Keep reading">
    <a class="colophon__jump" href="#">
      Time signals
      <svg class="colophon__arrow" viewBox="0 0 48 30" aria-hidden="true">
        <path d="M2 15h44M33 11h9M29 7h8M25 3h7M33 19h9M29 23h8M25 27h7" />
      </svg>
    </a>
    <a class="colophon__jump" href="#">
      Weather by fax
      <svg class="colophon__arrow" viewBox="0 0 48 30" aria-hidden="true">
        <path d="M2 15h44M33 11h9M29 7h8M25 3h7M33 19h9M29 23h8M25 27h7" />
      </svg>
    </a>
  </nav>

  <p class="colophon__mark">Static Almanac</p>

  <div class="colophon__small">
    <p class="colophon__line">Set in Workbench, Sixtyfour and Archivo Narrow.</p>
    <p class="colophon__line">Logged, written and drawn by the keepers of the north attic post. Nothing on these pages is a recording.</p>
  </div>

  <p class="colophon__rights">© 2027 Static Almanac</p>
</footer>

<style>
  .colophon {
    padding: var(--space-m) var(--gutter) var(--space-m) var(--edge);
    background: var(--dark);
    color: var(--red);
  }

  .colophon__next {
    display: grid;
    justify-items: start;
    margin-bottom: var(--space-m);
  }
  .colophon__jump {
    display: inline-flex;
    align-items: center;
    column-gap: 0.5em;
    min-height: var(--tap);
    color: inherit;
    font-size: var(--text-l);
    line-height: 1.2;
    text-decoration: none;
    text-shadow: 0 0 0.08rem var(--glow), 0 0 0.08rem var(--glow);
    text-transform: uppercase;
  }
  .colophon__arrow {
    flex: none;
    width: 0.9em;
    height: 0.56em;
    overflow: visible;
    fill: none;
    stroke: currentColor;
    stroke-linecap: round;
    stroke-width: 0.16rem;
    opacity: 0;
    translate: -0.4em 0;
    transition: opacity var(--time-snap) var(--ease-snap), translate var(--time-snap) var(--ease-snap);
  }
  .colophon__jump:hover,
  .colophon__jump:focus-visible {
    text-shadow: none;
  }
  .colophon__jump:hover .colophon__arrow,
  .colophon__jump:focus-visible .colophon__arrow {
    opacity: 1;
    translate: 0 0;
  }
  .colophon__jump:focus-visible {
    outline: var(--rule-double) solid var(--red);
    outline-offset: 0.15em;
  }

  /* The wordmark breathes like the canvas lettering: its scan rows swell and thin out again. Bracketed by two red steps. */
  .colophon__mark {
    position: relative;
    margin: 0;
    padding-block: calc(var(--tick-2) + var(--space-s));
    font-family: var(--font-pixel);
    font-size: clamp(1.2rem, 6.2vw, 2.6rem);
    font-weight: 400;
    font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--scan-hover);
    line-height: 1.3;
    letter-spacing: 0;
    text-shadow: 0 0 0.1rem var(--glow), 0 0 0.1rem var(--glow);
    text-transform: uppercase;
    animation: colophon-breathe var(--cycle) linear calc(var(--cycle) * -0.3) infinite paused;
  }
  .colophon.is-live .colophon__mark {
    animation-play-state: running;
  }
  .colophon__mark::before,
  .colophon__mark::after {
    content: "";
    position: absolute;
    left: calc(-1 * var(--step-offset));
    width: var(--tick-w);
    height: var(--tick-2);
    background: var(--red);
  }
  .colophon__mark::before {
    top: 0;
  }
  .colophon__mark::after {
    bottom: 0;
  }
  @keyframes colophon-breathe {
    0%,
    100% {
      font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--scan-thin);
    }
    50% {
      font-variation-settings: "BLED" var(--bleed-off), "SCAN" var(--scan-heavy);
    }
  }

  .colophon__small {
    max-width: var(--measure);
    padding-block: var(--space-xs);
    font-size: var(--text-xs);
    font-weight: 400;
    line-height: 1.5;
  }
  .colophon__line {
    margin: 0;
  }
  .colophon__rights {
    margin: var(--space-xs) 0 0;
    font-size: var(--text-xs);
    font-weight: 400;
    line-height: 2;
    text-transform: uppercase;
  }

  @media (prefers-reduced-motion: reduce) {
    .colophon__mark {
      animation: none;
    }
    .colophon__arrow {
      transition-duration: 0s;
    }
  }
</style>

<script>
  (() => {
    /* The wordmark only animates while the footer is on screen. */
    const setUpColophon = (root) => {
      new IntersectionObserver(([entry]) => {
        root.classList.toggle("is-live", entry.isIntersecting);
      }).observe(root);
    };

    document.querySelectorAll(".colophon").forEach(setUpColophon);
  })();
</script>

Style

  • --red #ff1a14
  • --dark #1a0202
  • --glow rgba(255, 26, 20, 0.95)

Type

  • no font: a seven-row bar alphabet drawn on canvas by the pack's own script for hero lettering, stands in for a wide pixel variable face whose scan rows are animated from hairlines to swollen bars
  • Workbench (variable, BLED and SCAN axes) for big links, echoed article title, quote kicker, stands in for the same open-licence Google face the site sets its big links in, at three scan settings
  • Sixtyfour (variable, BLED and SCAN axes) for wordmark, bar label, stands in for the same open-licence Google pixel face the site uses for its small wordmark
  • Archivo Narrow 400 to 700 for statements in capitals, headings, body, small print, stands in for a system narrow grotesk in bold and regular

Motion

  • The hero lettering is redrawn on canvas about 30 times a second: the front word's bars swell from hairlines to nearly touching and thin out again over 24s, linear, while the word sinks about two rows into the word behind it and climbs back.
  • Every 1.3 to 4.2s a band of one to three scan rows slips sideways by up to four cells: short slips flicker for 0.1 to 0.3s, long ones hold for about a second and snap back. A counter under the lettering counts them.
  • Dragging the pointer across the lettering smears the rows under it sideways; they spring back in about half a second.
  • The spectrum figure adds a new row of bars on top every 130ms and steps the rest down, never scrolling smoothly.
  • Both canvases stop drawing when they leave the viewport, and draw a single still frame under reduced motion.
  • Big links snap to a thin scan setting on hover in four hard steps over 0.24s, lose their glow, and their bar arrow jumps a third of an em forward.
  • The solid article title slides down through its three scanline echoes and back, 11s each way, linear.
  • The footer wordmark breathes like the hero, scan rows thin to heavy over 24s, only while the footer is on screen.
  • Text links do not fade: they flip at once to a dark chip with red text.

Rules

  • Two colours only, pure red and a near-black with a drop of red in it. Sections alternate between them; there are no greys, tints or images.
  • Red text on dark always carries a faint red glow; dark text on red never does.
  • Everything is left aligned to one column that starts a sixth of the way across a wide page and stops at 45rem, leaving the right third empty.
  • Black blocks of four heights (0.56, 1.1, 1.7, 2.25rem) sit on both page edges like registration marks, and a pair of the same blocks steps above and below each text block in the left margin.
  • Display type is made of horizontal rows: hairlines, beads or swollen bars. The weight of a link is its scan setting, not a bolder font.
  • Arrows are drawn from the same bars: one long shaft and six short ones stepping back from the tip, with the stroke as heavy as the lettering beside it.
  • Statements and summaries are bold narrow capitals; running copy is the same narrow face at medium weight in sentence case.
  • Section headings are dark bands with red text that are slightly wider than the column and stick to the top while the section is read.
  • Emphasis keeps the page colour: a square bullet and a solid rule under the passage, a double rule under links, a dark chip for footnote numbers.
  • Corners are square and nothing has a soft shadow; the one shadow is a second dark slab knocked down and right behind a quote.
  • Small print is 0.8rem, regular weight, and capitals only for the copyright line.
base.css
@import url("https://fonts.googleapis.com/css2?family=Archivo+Narrow:ital,wght@0,400..700;1,400..700&family=Sixtyfour:BLED,SCAN@0..100,-53..100&family=Workbench:BLED,SCAN@0..100,-53..100&display=swap");

:root {
  --red: #ff1a14; /* page background; text, blocks and bars on dark bands */
  --dark: #1a0202; /* near-black: text on red, dark bands, registration blocks, canvas bars */
  --glow: rgba(255, 26, 20, 0.95); /* halo around red text on dark and around the canvas lettering */

  --font-text: "Archivo Narrow", "Arial Narrow", "Helvetica Neue", Arial, sans-serif; /* narrow grotesk for everything that is read */
  --font-scan: "Workbench", "Courier New", monospace; /* scanline display face for big links and titles */
  --font-pixel: "Sixtyfour", "Courier New", monospace; /* wide pixel face for the wordmark and the bar label */
  --scan-thin: -53; /* scan axis: rows as hairlines */
  --scan-dots: -20; /* scan axis: rows as beads */
  --scan-heavy: 10; /* scan axis: rows swollen until they nearly touch */
  --scan-hover: -40; /* scan axis: what every big link snaps to on hover */
  --bleed-off: 0; /* bleed axis: crisp row ends */
  --bleed-soft: 10; /* bleed axis: slightly inked row ends, for titles */

  --text-xs: 0.8rem; /* colophon, captions, citations */
  --text-s: 1rem; /* bylines, meta rows */
  --text-m: clamp(1.15rem, 0.98rem + 0.5vw, 1.4rem); /* body copy and capital statements */
  --text-l: clamp(1.55rem, 1.2rem + 1.3vw, 2.5rem); /* section headings, opening statements, footer directory */
  --display-link: clamp(2.3rem, 1.7rem + 2.3vw, 3.4rem); /* big scan-face links */
  --display-echo: clamp(4.2rem, 22vw, 8rem); /* echoed article title */
  --tracking: 0.008em; /* letter spacing on all narrow text */
  --leading: 1.4; /* running copy */
  --leading-tight: 1.15; /* headings and statements */

  --edge: clamp(1.25rem, 33.33vw - 15rem, 15rem); /* left offset of the text column: a sixth of a wide page, a thin margin on a phone */
  --gutter: clamp(1.25rem, 5vw, 4.5rem); /* right padding of the page */
  --measure: 45rem; /* widest the text column gets */
  --tick-w: min(clamp(1.125rem, 5vw, 2.8rem), var(--edge) - 0.4rem); /* width of every registration block: a twentieth of the page, never wide enough to touch the text */
  --tick-1: 0.56rem; /* thinnest registration block */
  --tick-2: 1.1rem; /* second registration block */
  --tick-3: 1.7rem; /* third registration block */
  --tick-4: 2.25rem; /* tallest registration block */
  --step-offset: min(var(--edge), max(var(--tick-w) + 1.7rem, (8.5rem - var(--edge)) * 999)); /* how far left of the column the step blocks sit: just beside it on a wide page, flush with the page edge once the margin is too thin for both them and the edge blocks */
  --space-xs: 0.5rem; /* between lines of one block */
  --space-s: 1rem; /* inside dark blocks, between small items */
  --space-m: 2rem; /* between paragraphs and blocks */
  --space-l: 4rem; /* above and below a section */
  --tap: 2.75rem; /* smallest height of anything tappable */
  --bar-height: 3.9rem; /* dark label bar on top of an article */
  --rule-double: 0.14rem; /* double underline of text links (two lines and the gap between), focus outlines */
  --rule-mark: 0.16em; /* solid underline of a marked passage */
  --shadow-offset: clamp(0.5rem, 1.6vw, 1.4rem); /* hard offset of the block behind a quote */

  --cycle: 24s; /* one breath of the canvas lettering and the wordmark: thin rows to swollen rows and back */
  --drift: 11s; /* the solid title sliding through its echoes, one way */
  --time-snap: 0.24s; /* hover changes */
  --ease-snap: steps(4, end); /* hovers move in four hard steps, never a smooth fade */
}

*,
*::before,
*::after {
  box-sizing: border-box;
}

body {
  margin: 0;
  background: var(--red);
  color: var(--dark);
  font-family: var(--font-text);
  font-size: var(--text-m);
  font-weight: 700;
  line-height: var(--leading);
  letter-spacing: var(--tracking);
  -webkit-font-smoothing: antialiased;
  text-rendering: optimizeLegibility;
}

For your agent

Use the kitbash MCP server at https://kitbash.me/mcp. Call get_pack("scanline-red"), then get_component for the parts you need, and build my site in that style: keep its tokens and rules, replace the placeholder copy with mine.
How to connect