kitbash Sign in Connect agent

Aperture Film Ribbon

Experimental · 6 parts · photography · portfolio · film strip

A portrait darkroom on screen: a camera iris opens on faces in a black field, then a curling strip of film carries grey frames across a pale light table and colours them under the pointer. Spaced mono readouts and tight bold caps do all the talking; it suits photographers, casting studios and any portfolio of faces.

Get pack Remix

Whole page

Parts

Top bar with round menu

Wordmark at the left, a centred frame readout, a round dark button that opens a black panel of spaced mono links over a blurred page.

Code React For Figma
<header class="nav">
  <a class="nav__mark" href="#">Pellicle</a>
  <p class="nav__readout" aria-label="Current frame">
    <span class="nav__count">03 / 08</span>
    <span class="nav__dot" aria-hidden="true">·</span>
    <span class="nav__frame">North window</span>
  </p>
  <button class="nav__button" type="button" aria-expanded="false" aria-controls="nav-panel" aria-label="Open menu">
    <span class="nav__bar" aria-hidden="true"></span>
    <span class="nav__bar" aria-hidden="true"></span>
  </button>
  <div class="nav__veil" aria-hidden="true"></div>
  <nav class="nav__panel" id="nav-panel" aria-label="Main">
    <ul class="nav__links">
      <li><a class="nav__link is-current" href="#" aria-current="page">Work</a></li>
      <li><a class="nav__link" href="#">Index</a></li>
      <li><a class="nav__link" href="#">Darkroom notes</a></li>
      <li><a class="nav__link" href="#">Book a sitting</a></li>
    </ul>
    <div class="nav__fine">
      <a class="nav__small" href="#">Privacy</a>
      <a class="nav__small" href="#">Imprint</a>
      <span class="nav__credit">Silver prints since 2019 ↗</span>
    </div>
  </nav>
</header>

<style>
  .nav {
    position: relative;
    z-index: 20;
    display: grid;
    grid-template-columns: 1fr auto 1fr;
    align-items: center;
    gap: var(--gap);
    padding: var(--space-m) var(--edge);
    color: var(--ink);
  }
  .nav__mark {
    justify-self: start;
    display: inline-flex;
    align-items: center;
    min-height: 44px;
    font: 700 var(--text-m)/1 var(--font-display);
    letter-spacing: var(--track-tight);
    text-transform: uppercase;
    color: inherit;
    text-decoration: none;
    transition: opacity var(--fade) var(--ease);
  }
  .nav__mark:hover { opacity: 0.55; }
  .nav__readout {
    margin: 0;
    display: flex;
    gap: var(--space-s);
    font-size: var(--text-mono);
    letter-spacing: var(--track-mono);
    text-transform: uppercase;
    white-space: nowrap;
  }
  .nav__dot { color: var(--ash); }
  .nav__button {
    position: relative;
    z-index: 2;
    justify-self: end;
    display: grid;
    place-content: center;
    gap: 5px;
    width: var(--button);
    height: var(--button);
    padding: 0;
    border: 0;
    border-radius: var(--radius-round);
    background: var(--ink);
    cursor: pointer;
    transition: transform var(--snap) var(--ease-snap), background-color var(--sweep) var(--ease);
  }
  .nav__button:hover { transform: scale(1.08); }
  .nav__button:focus-visible { outline: var(--line) solid var(--ink); outline-offset: 4px; }
  .nav__bar {
    display: block;
    width: 14px;
    height: 1.5px;
    background: var(--chalk);
    transition: transform var(--sweep) var(--ease-sweep);
  }
  .nav.is-open .nav__bar:first-child { transform: translateY(3.25px) rotate(45deg); }
  .nav.is-open .nav__bar:last-child { transform: translateY(-3.25px) rotate(-45deg); }

  .nav__veil {
    position: fixed;
    inset: 0;
    z-index: 0;
    background: var(--veil);
    backdrop-filter: blur(14px);
    -webkit-backdrop-filter: blur(14px);
    opacity: 0;
    pointer-events: none;
    transition: opacity var(--fade) var(--ease);
  }
  .nav.is-open .nav__veil { opacity: 1; pointer-events: auto; }

  .nav__panel {
    position: absolute;
    z-index: 1;
    top: calc(var(--space-m) + var(--button) + var(--space-s));
    right: var(--edge);
    width: min(300px, calc(100% - 2 * var(--edge)));
    padding: var(--space-l) var(--space-l) var(--space-m);
    border-radius: var(--radius-panel);
    background: var(--panel);
    color: var(--chalk);
    opacity: 0;
    visibility: hidden;
    transform: translateY(-10px);
    transform-origin: top right;
    transition: opacity var(--fade) var(--ease), transform var(--sweep) var(--ease-sweep), visibility 0s linear var(--sweep);
  }
  .nav.is-open .nav__panel {
    opacity: 1;
    visibility: visible;
    transform: none;
    transition-delay: 0s;
  }
  .nav__links { margin: 0; padding: 0; list-style: none; }
  .nav__link {
    position: relative;
    display: flex;
    align-items: center;
    min-height: 44px;
    padding-left: 18px;
    font-size: var(--text-s);
    letter-spacing: var(--track-mono);
    text-transform: uppercase;
    color: inherit;
    text-decoration: none;
    transition: transform var(--snap) var(--ease-snap), color var(--tint) var(--ease);
  }
  .nav__link::before {
    content: "▸";
    position: absolute;
    left: 0;
    opacity: 0;
    transition: opacity var(--snap) var(--ease);
  }
  .nav__link:hover { transform: translateX(4px); }
  .nav__link:hover::before,
  .nav__link.is-current::before { opacity: 1; }
  .nav__link:focus-visible { outline: var(--line) solid var(--chalk); outline-offset: 2px; }
  .nav__fine {
    display: flex;
    flex-wrap: wrap;
    align-items: center;
    column-gap: var(--space-m);
    margin-top: var(--space-m);
    padding-top: var(--space-s);
    border-top: var(--line) solid var(--rule-dark);
    font-size: 10px;
    letter-spacing: var(--track-mono);
    text-transform: uppercase;
    color: var(--ash);
  }
  .nav__small {
    display: inline-flex;
    align-items: center;
    min-height: 44px;
    color: inherit;
    text-decoration: none;
  }
  .nav__small:hover { color: var(--chalk); }
  .nav__credit { flex-basis: 100%; padding-bottom: var(--space-s); }

  @media (max-width: 600px) {
    .nav { grid-template-columns: 1fr auto; }
    .nav__readout { display: none; }
  }
</style>

<script>
  (() => {
    document.querySelectorAll('.nav').forEach((root) => {
      const button = root.querySelector('.nav__button');
      const veil = root.querySelector('.nav__veil');
      const set = (open) => {
        root.classList.toggle('is-open', open);
        button.setAttribute('aria-expanded', String(open));
        button.setAttribute('aria-label', open ? 'Close menu' : 'Open menu');
      };
      button.addEventListener('click', () => set(!root.classList.contains('is-open')));
      veil.addEventListener('click', () => set(false));
      root.addEventListener('keydown', (event) => {
        if (event.key === 'Escape' && root.classList.contains('is-open')) { set(false); button.focus(); }
      });
    });
  })();
</script>

Iris lens opener

A black field with one round lens of camera blades that follows the pointer and closes and reopens on the next portrait.

Code React For Figma
<section class="iris" aria-label="Portraits">
  <p class="iris__spaced iris__spaced--left" aria-hidden="true">Pellicle studio</p>
  <p class="iris__spaced iris__spaced--right" aria-hidden="true">Silver gelatin · 35 mm</p>

  <div class="iris__lens">
    <figure class="iris__shot is-current">
      <img class="iris__img" src="assets/frame-01.jpg" alt="Portrait of a woman with long loose hair looking straight ahead" width="714" height="900">
      <figcaption class="iris__caption"><span class="iris__title">Long light</span><span class="iris__exif">ISO 400 · F/2.8 · 1/125</span></figcaption>
    </figure>
    <figure class="iris__shot">
      <img class="iris__img" src="assets/frame-03.jpg" alt="Portrait of a young woman in a pale headscarf looking over her shoulder" width="708" height="900">
      <figcaption class="iris__caption"><span class="iris__title">Turban study</span><span class="iris__exif">ISO 200 · F/4 · 1/60</span></figcaption>
    </figure>
    <figure class="iris__shot">
      <img class="iris__img" src="assets/frame-06.jpg" alt="Painted portrait of an old man in a fur cap with his hands on a book" width="682" height="900">
      <figcaption class="iris__caption"><span class="iris__title">Fur cap</span><span class="iris__exif">ISO 100 · F/5.6 · 1/30</span></figcaption>
    </figure>
    <figure class="iris__shot">
      <img class="iris__img" src="assets/frame-05.jpg" alt="Portrait of a girl in a white drape with her arms over her head" width="631" height="900">
      <figcaption class="iris__caption"><span class="iris__title">Arms up</span><span class="iris__exif">ISO 400 · F/2 · 1/250</span></figcaption>
    </figure>
    <svg class="iris__blades" viewBox="-100 -100 200 200" aria-hidden="true">
      <path class="iris__leaves" fill-rule="evenodd" d=""></path>
      <path class="iris__seams" d=""></path>
      <circle class="iris__rim" r="97"></circle>
    </svg>
    <button class="iris__skip" type="button" aria-label="Next portrait"></button>
  </div>

  <p class="iris__readout iris__readout--left" aria-live="polite">
    <span class="iris__count">01 / 04</span> · <span class="iris__name">Long light</span>
  </p>
  <p class="iris__readout iris__readout--right"><span class="iris__setting">ISO 400 · F/2.8 · 1/125</span></p>
</section>

<style>
  .iris {
    position: relative;
    height: clamp(480px, 56vw, 820px);
    overflow: hidden;
    background: var(--night);
    color: var(--chalk);
  }
  .iris__spaced {
    position: absolute;
    top: var(--space-l);
    margin: 0;
    font-size: var(--text-mono);
    letter-spacing: var(--track-wide);
    text-transform: uppercase;
    color: var(--smoke);
  }
  .iris__spaced--left { left: var(--edge); }
  .iris__spaced--right { right: var(--edge); text-align: right; }

  .iris__lens {
    --x: 50%;
    --y: 48%;
    position: absolute;
    left: var(--x);
    top: var(--y);
    width: clamp(220px, 28vw, 400px);
    aspect-ratio: 1;
    border-radius: var(--radius-round);
    overflow: hidden;
    transform: translate(-50%, -50%);
    background: var(--blade);
  }
  .iris__shot {
    position: absolute;
    inset: 0;
    margin: 0;
    opacity: 0;
  }
  .iris__shot.is-current { opacity: 1; }
  .iris__img {
    width: 100%;
    height: 100%;
    object-fit: cover;
    object-position: 50% 22%;
    filter: grayscale(1) contrast(1.18) brightness(1.04);
    transform: scale(1.08);
  }
  .iris__caption {
    position: absolute;
    width: 1px;
    height: 1px;
    overflow: hidden;
    clip-path: inset(50%);
  }
  .iris__blades {
    position: absolute;
    inset: 0;
    width: 100%;
    height: 100%;
    pointer-events: none;
  }
  .iris__leaves { fill: var(--blade); }
  .iris__seams { fill: none; stroke: var(--seam); stroke-width: 0.8; }
  .iris__rim { fill: none; stroke: var(--film); stroke-width: 6; }
  .iris__skip {
    position: absolute;
    inset: 0;
    width: 100%;
    border: 0;
    border-radius: var(--radius-round);
    background: transparent;
    cursor: pointer;
  }
  .iris__skip:focus-visible { outline: var(--line) solid var(--chalk); outline-offset: 6px; }

  .iris__readout {
    position: absolute;
    bottom: var(--space-l);
    margin: 0;
    font-size: var(--text-mono);
    letter-spacing: var(--track-mono);
    text-transform: uppercase;
    color: var(--ash);
  }
  .iris__readout--left { left: var(--edge); }
  .iris__readout--right { right: var(--edge); text-align: right; }

  @media (max-width: 600px) {
    .iris { height: clamp(520px, 150vw, 720px); }
    .iris__lens { width: min(76vw, 340px); }
    .iris__spaced--right { display: none; }
    .iris__readout--right { bottom: calc(var(--space-l) + 22px); left: var(--edge); right: auto; text-align: left; }
  }
</style>

<script>
  (() => {
    const still = matchMedia('(prefers-reduced-motion: reduce)');
    const fine = matchMedia('(hover: hover) and (pointer: fine)');
    const BLADES = 9;
    const RIM = 97;

    // The hole is a polygon of blade edges; each edge runs on to the rim as a seam.
    function draw(leaves, seams, open) {
      const r = Math.max(0.5, open * 96);
      const turn = (1 - open) * 0.9;
      const points = [];
      for (let i = 0; i < BLADES; i++) {
        const a = turn + (i / BLADES) * Math.PI * 2;
        points.push([Math.cos(a) * r, Math.sin(a) * r]);
      }
      let hole = `M${points[0][0]},${points[0][1]}`;
      for (let i = 1; i < BLADES; i++) hole += `L${points[i][0]},${points[i][1]}`;
      leaves.setAttribute('d', `M-100,-100H100V100H-100Z ${hole}Z`);
      let lines = '';
      for (let i = 0; i < BLADES; i++) {
        const [px, py] = points[(i + BLADES - 1) % BLADES];
        const [vx, vy] = points[i];
        let dx = vx - px, dy = vy - py;
        const len = Math.hypot(dx, dy) || 1;
        dx /= len; dy /= len;
        const b = vx * dx + vy * dy;
        const t = -b + Math.sqrt(Math.max(0, b * b - (vx * vx + vy * vy - RIM * RIM)));
        lines += `M${vx},${vy}L${vx + dx * t},${vy + dy * t}`;
      }
      seams.setAttribute('d', lines);
    }

    const ease = (t) => 1 - Math.pow(1 - t, 3);

    document.querySelectorAll('.iris').forEach((root) => {
      const lens = root.querySelector('.iris__lens');
      const leaves = root.querySelector('.iris__leaves');
      const seams = root.querySelector('.iris__seams');
      const shots = [...root.querySelectorAll('.iris__shot')];
      const count = root.querySelector('.iris__count');
      const name = root.querySelector('.iris__name');
      const setting = root.querySelector('.iris__setting');
      const pad = (n) => String(n).padStart(2, '0');
      let index = 0;
      let open = 1;
      let swap = null; // { start }
      let last = performance.now();
      let frame = 0;
      let visible = false;
      const pos = { x: 50, y: 48 };
      const goal = { x: 50, y: 48 };

      const show = (i) => {
        shots[index].classList.remove('is-current');
        index = (i + shots.length) % shots.length;
        const shot = shots[index];
        shot.classList.add('is-current');
        count.textContent = `${pad(index + 1)} / ${pad(shots.length)}`;
        name.textContent = shot.querySelector('.iris__title').textContent;
        setting.textContent = shot.querySelector('.iris__exif').textContent;
      };

      const next = () => {
        if (still.matches) { show(index + 1); return; }
        if (!swap) swap = { start: performance.now(), swapped: false };
      };

      root.querySelector('.iris__skip').addEventListener('click', () => { next(); last = performance.now(); });

      root.addEventListener('pointermove', (event) => {
        if (!fine.matches || still.matches) return;
        const box = root.getBoundingClientRect();
        goal.x = 50 + (((event.clientX - box.left) / box.width) * 100 - 50) * 0.55;
        goal.y = 48 + (((event.clientY - box.top) / box.height) * 100 - 48) * 0.45;
      });
      root.addEventListener('pointerleave', () => { goal.x = 50; goal.y = 48; });

      const tick = (now) => {
        if (now - last > 2400 && !swap) { next(); last = now; }
        if (swap) {
          const t = (now - swap.start) / 450;
          if (t < 1) open = 1 - ease(t);
          else if (t < 2) {
            if (!swap.swapped) { show(index + 1); swap.swapped = true; }
            open = ease(t - 1);
          } else { open = 1; swap = null; last = now; }
        }
        draw(leaves, seams, 0.05 + open * 0.83);
        pos.x += (goal.x - pos.x) * 0.08;
        pos.y += (goal.y - pos.y) * 0.08;
        lens.style.setProperty('--x', `${pos.x}%`);
        lens.style.setProperty('--y', `${pos.y}%`);
        frame = requestAnimationFrame(tick);
      };

      draw(leaves, seams, 0.88);
      new IntersectionObserver(([entry]) => {
        visible = entry.isIntersecting;
        cancelAnimationFrame(frame);
        if (visible && !still.matches) { last = performance.now(); frame = requestAnimationFrame(tick); }
      }).observe(root);
    });
  })();
</script>

Curling film ribbon

A canvas strip of film with sprocket holes and edge numbers that waves and drifts across the light table; drag it, and the frame under the pointer turns to colour.

Code React For Figma
<section class="ribbon" tabindex="0" aria-label="Film strip of portraits. Drag, or use the arrow keys, to move it.">
  <canvas class="ribbon__canvas" role="img" aria-label="A curling strip of black and white film frames"></canvas>

  <p class="ribbon__hint" aria-hidden="true">Drag the film ↔</p>
  <span class="ribbon__stock" hidden>Pellicle 400</span>

  <ol class="ribbon__frames">
    <li class="ribbon__frame">
      <img class="ribbon__img" src="assets/frame-02.jpg" alt="A seated woman in a lace dress seen in profile" width="742" height="900">
      <span class="ribbon__title">Profile in lace</span><span class="ribbon__exif">ISO 100 · F/8 · 1/15</span>
    </li>
    <li class="ribbon__frame">
      <img class="ribbon__img" src="assets/frame-07.jpg" alt="Painted head of a woman with a red fringe and a long neck" width="723" height="900">
      <span class="ribbon__title">Red fringe</span><span class="ribbon__exif">ISO 400 · F/2.8 · 1/125</span>
    </li>
    <li class="ribbon__frame">
      <img class="ribbon__img" src="assets/frame-04.jpg" alt="A dark room with a striped wall, a lamp and a person reading at a table" width="673" height="900">
      <span class="ribbon__title">Lamp room</span><span class="ribbon__exif">ISO 800 · F/2 · 1/30</span>
    </li>
    <li class="ribbon__frame">
      <img class="ribbon__img" src="assets/frame-08.jpg" alt="Woodcut head of a bearded old man on a red ground" width="600" height="900">
      <span class="ribbon__title">Cut beard</span><span class="ribbon__exif">ISO 200 · F/5.6 · 1/60</span>
    </li>
    <li class="ribbon__frame">
      <img class="ribbon__img" src="assets/frame-05.jpg" alt="A girl in a white drape with her arms raised over her head" width="631" height="900">
      <span class="ribbon__title">Arms up</span><span class="ribbon__exif">ISO 400 · F/2 · 1/250</span>
    </li>
    <li class="ribbon__frame">
      <img class="ribbon__img" src="assets/frame-01.jpg" alt="A woman with long loose hair looking straight into the lens" width="714" height="900">
      <span class="ribbon__title">Long light</span><span class="ribbon__exif">ISO 400 · F/2.8 · 1/125</span>
    </li>
  </ol>

  <p class="ribbon__readout ribbon__readout--left" aria-live="polite">
    <span class="ribbon__count">01 / 06</span> · <span class="ribbon__name">Profile in lace</span>
  </p>
  <p class="ribbon__readout ribbon__readout--right"><span class="ribbon__setting">ISO 100 · F/8 · 1/15</span></p>
</section>

<style>
  .ribbon {
    position: relative;
    height: clamp(440px, 50vw, 760px);
    overflow: hidden;
    background: var(--paper);
    color: var(--ink);
    touch-action: pan-y;
    cursor: grab;
    outline: none;
  }
  .ribbon.is-dragging { cursor: grabbing; }
  .ribbon.is-pointing { cursor: pointer; }
  .ribbon:focus-visible { box-shadow: inset 0 0 0 var(--line) var(--ink); }
  .ribbon__canvas {
    position: absolute;
    inset: 0;
    width: 100%;
    height: 100%;
    color: var(--film);
  }
  .ribbon__frames {
    position: absolute;
    width: 1px;
    height: 1px;
    margin: 0;
    padding: 0;
    overflow: hidden;
    clip-path: inset(50%);
    list-style: none;
  }
  .ribbon__img { width: 1px; height: 1px; object-fit: cover; }
  .ribbon__hint,
  .ribbon__readout {
    position: absolute;
    margin: 0;
    font-size: var(--text-mono);
    letter-spacing: var(--track-mono);
    text-transform: uppercase;
    pointer-events: none;
  }
  .ribbon__hint { top: var(--space-l); right: var(--edge); color: var(--ash); }
  .ribbon__readout { bottom: var(--space-l); }
  .ribbon__readout--left { left: var(--edge); }
  .ribbon__readout--right { right: var(--edge); text-align: right; }

  @media (max-width: 600px) {
    .ribbon__readout--right { bottom: calc(var(--space-l) + 22px); left: var(--edge); right: auto; text-align: left; }
  }
</style>

<script>
  (() => {
    const still = matchMedia('(prefers-reduced-motion: reduce)');

    function setup(root) {
      const canvas = root.querySelector('.ribbon__canvas');
      const ctx = canvas.getContext('2d');
      const frames = [...root.querySelectorAll('.ribbon__frame')];
      const imgs = frames.map((f) => f.querySelector('.ribbon__img'));
      const stock = root.querySelector('.ribbon__stock').textContent.trim().toUpperCase();
      const count = root.querySelector('.ribbon__count');
      const name = root.querySelector('.ribbon__name');
      const setting = root.querySelector('.ribbon__setting');
      const css = getComputedStyle(root);
      const colour = {
        film: css.getPropertyValue('--film').trim(),
        paper: css.getPropertyValue('--paper').trim(),
        chalk: css.getPropertyValue('--chalk').trim(),
        edge: css.getPropertyValue('--smoke').trim(),
        night: css.getPropertyValue('--night').trim(),
      };
      const mono = css.getPropertyValue('--font-body').trim();
      const pad = (n) => String(n).padStart(2, '0');

      let W = 0, H = 0, dpr = 1, strip = 0, P = 0, L = 0;
      let grey = null, full = null;
      let offset = 0, velocity = 0, time = 0, last = performance.now();
      let pointer = null, drag = null, centre = -1, frame = 0, ready = false;
      const mix = frames.map(() => 0);

      function layout() {
        strip = Math.round(Math.min(H * 0.56, W * 0.62, 420));
        const band = strip * 0.15;
        const picture = strip - band * 2;
        const width = Math.round(picture * 1.32);
        const gap = Math.round(strip * 0.05);
        P = width + gap;
        L = P * frames.length;
        return { band, picture, width, gap };
      }

      function texture(geo, greyed) {
        const t = document.createElement('canvas');
        t.width = Math.ceil(L * dpr);
        t.height = Math.ceil(strip * dpr);
        const c = t.getContext('2d');
        c.scale(dpr, dpr);
        c.fillStyle = colour.film;
        c.fillRect(0, 0, L, strip);
        const { band, picture, width, gap } = geo;
        // sprocket holes, in the outer part of each band
        const pitch = band * 0.9;
        const hw = pitch * 0.52, hh = band * 0.36;
        c.fillStyle = colour.paper;
        for (let x = pitch * 0.25; x < L - hw; x += pitch) {
          for (const y of [band * 0.14, strip - band * 0.14 - hh]) {
            c.beginPath();
            c.roundRect(x, y, hw, hh, Math.min(3, hh / 3));
            c.fill();
          }
        }
        const size = Math.max(8, Math.round(band * 0.3));
        c.font = `600 ${size}px ${mono}`;
        c.textBaseline = 'middle';
        frames.forEach((_, i) => {
          const x0 = i * P + gap / 2;
          const img = imgs[i];
          // cover crop, faces sit high
          const ratio = width / picture;
          let sw = img.naturalWidth, sh = sw / ratio;
          if (sh > img.naturalHeight) { sh = img.naturalHeight; sw = sh * ratio; }
          const sx = (img.naturalWidth - sw) / 2;
          const sy = (img.naturalHeight - sh) * 0.28;
          c.save();
          if (greyed) c.filter = 'grayscale(1) contrast(1.15) brightness(1.05)';
          c.drawImage(img, sx, sy, sw, sh, x0, band, width, picture);
          c.restore();
          c.strokeStyle = colour.edge;
          c.lineWidth = 1;
          c.strokeRect(x0 + 0.5, band + 0.5, width - 1, picture - 1);
          // edge print
          c.fillStyle = colour.chalk;
          const n = 12 + i;
          c.textAlign = 'left';
          c.fillText(stock, x0 + width * 0.08, band * 0.78);
          c.fillText(String(n), x0 + width * 0.12, strip - band * 0.78);
          c.textAlign = 'right';
          c.fillText(`PC-35`, x0 + width * 0.94, band * 0.78);
          c.fillText(`▸ ${n}A`, x0 + width * 0.94, strip - band * 0.78);
        });
        return t;
      }

      function fit() {
        dpr = Math.min(2, devicePixelRatio || 1);
        W = canvas.clientWidth; H = canvas.clientHeight;
        canvas.width = Math.round(W * dpr);
        canvas.height = Math.round(H * dpr);
        ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
        if (!ready) return;
        const geo = layout();
        grey = texture(geo, true);
        full = texture(geo, false);
        paint();
      }

      const wrap = (u) => ((u % L) + L) % L;
      const wave = (x) => {
        const k = (Math.PI * 2) / Math.max(700, W * 1.1);
        const phase = x * k - time * 0.5;
        const y = H * 0.48 + Math.sin(phase) * strip * 0.2;
        const turn = 0.84 + 0.16 * Math.cos(x * k * 1.7 + time * 0.35 + 1.2);
        return { y, turn };
      };

      function frameAt(x, y) {
        if (!L) return -1;
        const { y: cy, turn } = wave(x);
        if (Math.abs(y - cy) > (strip * turn) / 2) return -1;
        const u = wrap(x + offset);
        return Math.floor(u / P) % frames.length;
      }

      function paint() {
        ctx.clearRect(0, 0, W, H);
        if (!grey) return;
        const step = 2;
        for (let x = 0; x < W; x += step) {
          const u = wrap(x + offset);
          const { y, turn } = wave(x);
          const h = strip * turn;
          const top = y - h / 2;
          const sx = Math.min(u * dpr, grey.width - step * dpr);
          ctx.drawImage(grey, sx, 0, step * dpr, grey.height, x, top, step + 0.6, h);
          const i = Math.floor(u / P) % frames.length;
          if (mix[i] > 0.01) {
            ctx.globalAlpha = mix[i];
            ctx.drawImage(full, sx, 0, step * dpr, full.height, x, top, step + 0.6, h);
            ctx.globalAlpha = 1;
          }
          const shade = (1 - turn) * 2.2;
          if (shade > 0.02) {
            ctx.globalAlpha = shade;
            ctx.fillStyle = colour.night;
            ctx.fillRect(x, top, step + 0.6, h);
            ctx.globalAlpha = 1;
          }
        }
        const c = Math.floor(wrap(W / 2 + offset) / P) % frames.length;
        if (c !== centre) {
          centre = c;
          count.textContent = `${pad(c + 1)} / ${pad(frames.length)}`;
          name.textContent = frames[c].querySelector('.ribbon__title').textContent;
          setting.textContent = frames[c].querySelector('.ribbon__exif').textContent;
        }
      }

      function tick(now) {
        const dt = Math.min(0.05, (now - last) / 1000);
        last = now;
        if (!still.matches) {
          time += dt;
          if (!drag) offset += 24 * dt + velocity * dt;
        } else if (!drag) {
          offset += velocity * dt;
        }
        velocity *= Math.pow(0.04, dt);
        const hover = pointer && !drag ? frameAt(pointer.x, pointer.y) : -1;
        root.classList.toggle('is-pointing', hover >= 0);
        mix.forEach((m, i) => {
          const goal = i === hover ? 1 : 0;
          mix[i] = m + (goal - m) * Math.min(1, dt / 0.5 * 3);
        });
        paint();
        frame = requestAnimationFrame(tick);
      }

      const local = (event) => {
        const box = canvas.getBoundingClientRect();
        return { x: event.clientX - box.left, y: event.clientY - box.top };
      };
      root.addEventListener('pointermove', (event) => {
        pointer = local(event);
        if (drag) {
          const dx = pointer.x - drag.x;
          offset -= dx;
          velocity = -dx / Math.max(0.016, (event.timeStamp - drag.t) / 1000);
          drag = { x: pointer.x, t: event.timeStamp };
        }
      });
      root.addEventListener('pointerleave', () => { pointer = null; });
      root.addEventListener('pointerdown', (event) => {
        pointer = local(event);
        drag = { x: pointer.x, t: event.timeStamp };
        velocity = 0;
        root.setPointerCapture(event.pointerId);
        root.classList.add('is-dragging');
      });
      const release = () => {
        drag = null;
        velocity = Math.max(-1600, Math.min(1600, velocity));
        root.classList.remove('is-dragging');
      };
      root.addEventListener('pointerup', release);
      root.addEventListener('pointercancel', release);
      root.addEventListener('keydown', (event) => {
        if (event.key === 'ArrowRight') { velocity += P * 2.2; event.preventDefault(); }
        if (event.key === 'ArrowLeft') { velocity -= P * 2.2; event.preventDefault(); }
      });

      new ResizeObserver(fit).observe(canvas);
      Promise.all(imgs.map((img) => (img.complete ? Promise.resolve() : img.decode().catch(() => {})))).then(() => {
        ready = true;
        fit();
      });
      new IntersectionObserver(([entry]) => {
        cancelAnimationFrame(frame);
        if (entry.isIntersecting) { last = performance.now(); frame = requestAnimationFrame(tick); }
      }).observe(root);
    }

    document.querySelectorAll('.ribbon').forEach(setup);
  })();
</script>

Sittings index

Ruled rows of numbered sittings in bold caps with place and exposure; on hover a round portrait grows under the pointer.

Code React For Figma
<section class="index">
  <div class="index__head">
    <h2 class="index__heading">Sittings</h2>
    <p class="index__meta">06 rolls · 2019 – 2026 · silver gelatin</p>
  </div>
  <ol class="index__list">
    <li class="index__row">
      <a class="index__link" href="#">
        <span class="index__thumb"><img class="index__img" src="assets/frame-01.jpg" alt="Woman with long loose hair" width="714" height="900" loading="lazy"></span>
        <span class="index__num">01</span>
        <span class="index__title">Long light</span>
        <span class="index__place">Freshwater</span>
        <span class="index__exif">ISO 400 · F/2.8 · 1/125</span>
      </a>
    </li>
    <li class="index__row">
      <a class="index__link" href="#">
        <span class="index__thumb"><img class="index__img" src="assets/frame-03.jpg" alt="Young woman in a pale headscarf" width="708" height="900" loading="lazy"></span>
        <span class="index__num">02</span>
        <span class="index__title">Turban study</span>
        <span class="index__place">Dundee</span>
        <span class="index__exif">ISO 200 · F/4 · 1/60</span>
      </a>
    </li>
    <li class="index__row">
      <a class="index__link" href="#">
        <span class="index__thumb"><img class="index__img" src="assets/frame-06.jpg" alt="Old man in a fur cap" width="682" height="900" loading="lazy"></span>
        <span class="index__num">03</span>
        <span class="index__title">Fur cap</span>
        <span class="index__place">Leiden</span>
        <span class="index__exif">ISO 100 · F/5.6 · 1/30</span>
      </a>
    </li>
    <li class="index__row">
      <a class="index__link" href="#">
        <span class="index__thumb"><img class="index__img" src="assets/frame-07.jpg" alt="Painted woman with a red fringe" width="723" height="900" loading="lazy"></span>
        <span class="index__num">04</span>
        <span class="index__title">Red fringe</span>
        <span class="index__place">Livorno</span>
        <span class="index__exif">ISO 400 · F/2 · 1/250</span>
      </a>
    </li>
    <li class="index__row">
      <a class="index__link" href="#">
        <span class="index__thumb"><img class="index__img" src="assets/frame-08.jpg" alt="Woodcut head of a bearded man" width="600" height="900" loading="lazy"></span>
        <span class="index__num">05</span>
        <span class="index__title">Cut beard</span>
        <span class="index__place">Kristiania</span>
        <span class="index__exif">ISO 200 · F/8 · 1/15</span>
      </a>
    </li>
  </ol>
</section>

<style>
  .index {
    position: relative;
    padding: var(--section-space) var(--edge);
    background: var(--paper);
    color: var(--ink);
  }
  .index__head {
    display: flex;
    flex-wrap: wrap;
    align-items: baseline;
    justify-content: space-between;
    gap: var(--space-s) var(--gap);
    margin-bottom: var(--space-l);
  }
  .index__heading {
    margin: 0;
    font: 700 var(--text-m)/1 var(--font-display);
    letter-spacing: var(--track-tight);
    text-transform: uppercase;
  }
  .index__meta,
  .index__num,
  .index__place,
  .index__exif {
    margin: 0;
    font-size: var(--text-mono);
    letter-spacing: var(--track-mono);
    text-transform: uppercase;
  }
  .index__meta { color: var(--ash); }
  .index__list {
    --x: 0px;
    --y: 0px;
    position: relative;
    margin: 0;
    padding: 0;
    list-style: none;
    border-top: var(--line) solid var(--ink);
  }
  .index__row { border-bottom: var(--line) solid var(--rule); }
  .index__link {
    display: grid;
    grid-template-columns: 3.5em minmax(0, 1fr) 10em 19em;
    align-items: baseline;
    gap: var(--gap);
    padding: var(--space-m) 0;
    color: inherit;
    text-decoration: none;
  }
  .index__link:focus-visible { outline: var(--line) solid var(--ink); outline-offset: 2px; }
  .index__num { color: var(--ash); }
  .index__title {
    font: 800 var(--display-m)/0.95 var(--font-display);
    letter-spacing: var(--track-tight);
    text-transform: uppercase;
    transition: transform var(--snap) var(--ease-snap), color var(--tint) var(--ease);
  }
  .index__exif { text-align: right; color: var(--ash); transition: color var(--tint) var(--ease); }
  .index__link:hover .index__title,
  .index__link:focus-visible .index__title { transform: translateX(12px); }
  .index__link:hover .index__exif { color: var(--ink); }

  /* The round thumbnail: grows under the pointer on wide screens, sits in the row on small ones. */
  .index__thumb {
    position: absolute;
    z-index: 2;
    left: var(--x);
    top: var(--y);
    width: 0;
    height: 0;
    border-radius: var(--radius-round);
    overflow: hidden;
    transform: translate(-50%, -50%);
    pointer-events: none;
    box-shadow: 0 0 0 6px var(--film);
    opacity: 0;
    transition: width var(--grow) var(--ease), height var(--grow) var(--ease), opacity var(--grow) var(--ease);
  }
  .index__link:hover .index__thumb { width: 180px; height: 180px; opacity: 1; }
  .index__img {
    width: 100%;
    height: 100%;
    object-fit: cover;
    object-position: 50% 22%;
    filter: grayscale(1) contrast(1.15);
  }

  @media (max-width: 900px) {
    .index__link { grid-template-columns: 3em minmax(0, 1fr) auto; }
    .index__exif { display: none; }
  }
  @media (max-width: 600px), (hover: none) {
    .index__link {
      grid-template-columns: 48px minmax(0, 1fr);
      grid-template-areas: "thumb title" "thumb meta";
      align-items: center;
      row-gap: var(--space-xs);
    }
    .index__thumb {
      grid-area: thumb;
      position: static;
      width: 48px;
      height: 48px;
      opacity: 1;
      transform: none;
      box-shadow: 0 0 0 3px var(--film);
    }
    .index__link:hover .index__thumb { width: 48px; height: 48px; }
    .index__num { display: none; }
    .index__title { grid-area: title; }
    .index__place { grid-area: meta; }
  }
</style>

<script>
  (() => {
    document.querySelectorAll('.index__list').forEach((list) => {
      list.addEventListener('pointermove', (event) => {
        const box = list.getBoundingClientRect();
        list.style.setProperty('--x', `${event.clientX - box.left}px`);
        list.style.setProperty('--y', `${event.clientY - box.top}px`);
      });
    });
  })();
</script>

Exposure dial

A portrait behind an iris with f-stop, shutter and film speed controls that open the blades, brighten the picture and add grain.

Code React For Figma
<section class="dial">
  <div class="dial__finder">
    <div class="dial__lens">
      <img class="dial__img" src="assets/frame-03.jpg" alt="Portrait of a young woman in a pale headscarf looking over her shoulder" width="708" height="900">
      <svg class="dial__grain" aria-hidden="true">
        <filter id="dial-grain-filter"><feTurbulence type="fractalNoise" baseFrequency="0.9" numOctaves="2" stitchTiles="stitch"/><feColorMatrix type="saturate" values="0"/></filter>
        <rect width="100%" height="100%" filter="url(#dial-grain-filter)"/>
      </svg>
      <svg class="dial__blades" viewBox="-100 -100 200 200" aria-hidden="true">
        <path class="dial__leaves" fill-rule="evenodd" d=""></path>
        <path class="dial__seams" d=""></path>
        <circle class="dial__rim" r="97"></circle>
      </svg>
    </div>
    <p class="dial__ev" aria-live="polite">EV <span class="dial__ev-value">0.0</span></p>
  </div>

  <div class="dial__controls">
    <h2 class="dial__heading">Set the exposure</h2>
    <p class="dial__lede">Every sitting is made on one roll with one lens. Try the light we use.</p>

    <fieldset class="dial__group">
      <legend class="dial__label">Aperture <span class="dial__value dial__value--f">F/2.8</span></legend>
      <div class="dial__chips">
        <button class="dial__chip" type="button" data-stop="1.4" aria-pressed="false">1.4</button>
        <button class="dial__chip" type="button" data-stop="2" aria-pressed="false">2</button>
        <button class="dial__chip" type="button" data-stop="2.8" aria-pressed="true">2.8</button>
        <button class="dial__chip" type="button" data-stop="4" aria-pressed="false">4</button>
        <button class="dial__chip" type="button" data-stop="5.6" aria-pressed="false">5.6</button>
        <button class="dial__chip" type="button" data-stop="8" aria-pressed="false">8</button>
        <button class="dial__chip" type="button" data-stop="11" aria-pressed="false">11</button>
        <button class="dial__chip" type="button" data-stop="16" aria-pressed="false">16</button>
      </div>
    </fieldset>

    <label class="dial__group dial__group--slider">
      <span class="dial__label">Shutter <span class="dial__value dial__value--s">1/125</span></span>
      <input class="dial__range" type="range" min="0" max="6" step="1" value="3" aria-label="Shutter speed">
      <span class="dial__ticks" aria-hidden="true"><span>1/15</span><span>1/1000</span></span>
    </label>

    <fieldset class="dial__group">
      <legend class="dial__label">Film speed <span class="dial__value dial__value--iso">ISO 400</span></legend>
      <div class="dial__chips">
        <button class="dial__chip" type="button" data-iso="100" aria-pressed="false">100</button>
        <button class="dial__chip" type="button" data-iso="200" aria-pressed="false">200</button>
        <button class="dial__chip" type="button" data-iso="400" aria-pressed="true">400</button>
        <button class="dial__chip" type="button" data-iso="800" aria-pressed="false">800</button>
        <button class="dial__chip" type="button" data-iso="1600" aria-pressed="false">1600</button>
      </div>
    </fieldset>
  </div>
</section>

<style>
  .dial {
    display: grid;
    grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
    gap: var(--space-xl);
    align-items: center;
    padding: var(--section-space) var(--edge);
    background: var(--paper);
    color: var(--ink);
  }
  .dial__finder {
    position: relative;
    display: grid;
    place-items: center;
    aspect-ratio: 1;
    max-height: 560px;
    border-radius: var(--radius-panel);
    background: var(--night);
  }
  .dial__lens {
    --bright: 1;
    --grain: 0.18;
    position: relative;
    width: 72%;
    aspect-ratio: 1;
    border-radius: var(--radius-round);
    overflow: hidden;
    background: var(--blade);
  }
  .dial__img {
    width: 100%;
    height: 100%;
    object-fit: cover;
    object-position: 50% 22%;
    filter: grayscale(1) contrast(1.15) brightness(var(--bright));
    transform: scale(1.08);
    transition: filter var(--sweep) var(--ease-sweep);
  }
  .dial__grain {
    position: absolute;
    inset: 0;
    width: 100%;
    height: 100%;
    opacity: var(--grain);
    mix-blend-mode: overlay;
    transition: opacity var(--sweep) var(--ease);
  }
  .dial__blades { position: absolute; inset: 0; width: 100%; height: 100%; }
  .dial__leaves { fill: var(--blade); }
  .dial__seams { fill: none; stroke: var(--seam); stroke-width: 0.8; }
  .dial__rim { fill: none; stroke: var(--film); stroke-width: 6; }
  .dial__ev {
    position: absolute;
    left: var(--space-m);
    bottom: var(--space-s);
    margin: 0;
    font-size: var(--text-mono);
    letter-spacing: var(--track-mono);
    color: var(--ash);
  }

  .dial__controls { display: grid; gap: var(--space-l); max-width: 520px; }
  .dial__heading {
    margin: 0;
    font: 800 var(--display-m)/0.95 var(--font-display);
    letter-spacing: var(--track-tight);
    text-transform: uppercase;
  }
  .dial__lede { margin: 0; max-width: 34ch; font-size: var(--text-s); line-height: 1.6; color: var(--ash); }
  .dial__group { display: grid; gap: var(--space-s); margin: 0; padding: 0; border: 0; min-width: 0; }
  .dial__label {
    display: flex;
    justify-content: space-between;
    width: 100%;
    padding: 0 0 var(--space-s);
    border-bottom: var(--line) solid var(--rule);
    font-size: var(--text-mono);
    letter-spacing: var(--track-mono);
    text-transform: uppercase;
  }
  .dial__value { color: var(--ash); }
  .dial__chips { display: flex; flex-wrap: wrap; gap: var(--space-xs); }
  .dial__chip {
    min-width: 44px;
    height: 44px;
    padding: 0 var(--space-s);
    border: var(--line) solid var(--rule);
    border-radius: var(--radius-round);
    background: transparent;
    color: var(--ink);
    font: 500 var(--text-mono)/1 var(--font-body);
    letter-spacing: 0.04em;
    cursor: pointer;
    transition: background-color var(--sweep) var(--ease), color var(--tint) var(--ease), transform var(--snap) var(--ease-snap);
  }
  .dial__chip:hover { transform: translateY(-2px); border-color: var(--ink); }
  .dial__chip:focus-visible { outline: var(--line) solid var(--ink); outline-offset: 2px; }
  .dial__chip[aria-pressed="true"] { background: var(--ink); border-color: var(--ink); color: var(--chalk); }
  .dial__range {
    width: 100%;
    height: 44px;
    margin: 0;
    accent-color: var(--ink);
    cursor: pointer;
  }
  .dial__ticks {
    display: flex;
    justify-content: space-between;
    font-size: 10px;
    letter-spacing: var(--track-mono);
    color: var(--ash);
  }

  @media (max-width: 800px) {
    .dial { grid-template-columns: 1fr; gap: var(--space-l); }
  }
</style>

<script>
  (() => {
    const still = matchMedia('(prefers-reduced-motion: reduce)');
    const BLADES = 9;
    const RIM = 97;
    const SHUTTER = ['1/15', '1/30', '1/60', '1/125', '1/250', '1/500', '1/1000'];

    function draw(leaves, seams, open) {
      const r = Math.max(0.5, open * 96);
      const turn = (1 - open) * 0.9;
      const points = [];
      for (let i = 0; i < BLADES; i++) {
        const a = turn + (i / BLADES) * Math.PI * 2;
        points.push([Math.cos(a) * r, Math.sin(a) * r]);
      }
      leaves.setAttribute('d', `M-100,-100H100V100H-100Z M${points.map((p) => p.join(',')).join('L')}Z`);
      let lines = '';
      for (let i = 0; i < BLADES; i++) {
        const [px, py] = points[(i + BLADES - 1) % BLADES];
        const [vx, vy] = points[i];
        let dx = vx - px, dy = vy - py;
        const len = Math.hypot(dx, dy) || 1;
        dx /= len; dy /= len;
        const b = vx * dx + vy * dy;
        const t = -b + Math.sqrt(Math.max(0, b * b - (vx * vx + vy * vy - RIM * RIM)));
        lines += `M${vx},${vy}L${vx + dx * t},${vy + dy * t}`;
      }
      seams.setAttribute('d', lines);
    }

    document.querySelectorAll('.dial').forEach((root) => {
      const lens = root.querySelector('.dial__lens');
      const leaves = root.querySelector('.dial__leaves');
      const seams = root.querySelector('.dial__seams');
      const range = root.querySelector('.dial__range');
      const ev = root.querySelector('.dial__ev-value');
      const out = {
        f: root.querySelector('.dial__value--f'),
        s: root.querySelector('.dial__value--s'),
        iso: root.querySelector('.dial__value--iso'),
      };
      const state = { stop: 2.8, shutter: 3, iso: 400 };
      let open = 0.8;
      let frame = 0;

      const target = () => 0.92 - (Math.log2(state.stop / 1.4) / Math.log2(16 / 1.4)) * 0.62;

      const tween = (from, to) => {
        cancelAnimationFrame(frame);
        if (still.matches) { open = to; draw(leaves, seams, open); return; }
        const start = performance.now();
        const step = (now) => {
          const t = Math.min(1, (now - start) / 450);
          const k = t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
          open = from + (to - from) * k;
          draw(leaves, seams, open);
          if (t < 1) frame = requestAnimationFrame(step);
        };
        frame = requestAnimationFrame(step);
      };

      const update = () => {
        const stops = Math.log2(state.iso / 400) - 2 * Math.log2(state.stop / 2.8) - (state.shutter - 3);
        lens.style.setProperty('--bright', Math.max(0.25, Math.min(2.2, Math.pow(2, stops * 0.45))).toFixed(3));
        lens.style.setProperty('--grain', (0.08 + Math.log2(state.iso / 100) * 0.12).toFixed(3));
        ev.textContent = `${stops >= 0 ? '+' : ''}${stops.toFixed(1)}`;
        out.f.textContent = `F/${state.stop}`;
        out.s.textContent = SHUTTER[state.shutter];
        out.iso.textContent = `ISO ${state.iso}`;
        tween(open, target());
      };

      root.querySelectorAll('.dial__chip').forEach((chip) => {
        chip.addEventListener('click', () => {
          const key = chip.dataset.stop ? 'stop' : 'iso';
          root.querySelectorAll(`.dial__chip[data-${key}]`).forEach((c) => c.setAttribute('aria-pressed', String(c === chip)));
          state[key] = Number(chip.dataset[key]);
          update();
        });
      });
      range.addEventListener('input', () => {
        state.shutter = Number(range.value);
        update();
      });

      open = target();
      draw(leaves, seams, open);
      update();
    });
  })();
</script>

Style

  • --paper #f6f6f6
  • --ink #191919
  • --night #000000
  • --panel #0d0d0d
  • --chalk #f2f2ef
  • --ash #8c8c88
  • --smoke #3a3a38
  • --film #262626
  • --blade #0b0b0b
  • --seam #2c2c2c
  • --rule #d6d6d3
  • --rule-dark #2a2a28
  • --veil rgba(246, 246, 246, 0.35)

Type

  • Inter Tight for headlines, stands in for Helvetica Neue Bold in tight uppercase, used for the wordmark and the few titles
  • IBM Plex Mono for text, stands in for the system ui-monospace face set at 11 to 12 px in widely spaced uppercase for every caption and readout

Motion

  • The lens follows the pointer with a soft lag, and every 2.4 s its blades close and reopen on the next face over 450 ms (cubic-bezier(0.6, 0.05, 0.2, 1)).
  • The film strip drifts left at about 24 px a second along a slow travelling wave, can be dragged, and the frame under the pointer warms from grey to its own colour over 500 ms.
  • Hover nudges move titles 12 px over 240 ms on cubic-bezier(0.35, 0.7, 0.25, 1); the round thumbnail grows from nothing in 280 ms.
  • The menu panel drops in with a 450 ms sweep while the page behind it blurs under a frosted veil in 400 ms.

Rules

  • Two grounds only: pure black for the lens and a pale grey light table for everything else; colour lives only inside the pictures, and mostly only on hover.
  • Pictures are cut round by a camera iris or laid on film with sprocket holes and edge numbers, never shown as plain rectangles.
  • All small text is mono uppercase at 11 to 12 px with wide tracking; exposure readouts (ISO, f-stop, shutter) stand in for decoration.
  • The one display voice is a tight bold grotesk in capitals; nothing in between.
  • Controls are a 46 px round dark button and a dark panel with 14 px corners; rules are 1 px hairlines.
base.css
/* Fonts: free Google Fonts that stand in for the site's faces. */
@import url("https://fonts.googleapis.com/css2?family=Inter+Tight:wght@500;700;800&family=IBM+Plex+Mono:wght@400;500;600&display=swap");

:root {
  /* Colour */
  --paper: #f6f6f6; /* page background, the light table */
  --ink: #191919; /* main text, the wordmark, the round buttons */
  --night: #000000; /* the black field behind the lens */
  --panel: #0d0d0d; /* menu panel and footer ground */
  --chalk: #f2f2ef; /* text on the dark panel and on the black field */
  --ash: #8c8c88; /* secondary mono captions, fine print */
  --smoke: #3a3a38; /* barely-there labels on the black field */
  --film: #262626; /* the film base of the strip */
  --blade: #0b0b0b; /* aperture blades */
  --seam: #2c2c2c; /* the lines between aperture blades */
  --rule: #d6d6d3; /* hairline rules on paper */
  --rule-dark: #2a2a28; /* hairline rules on the dark panel */
  --veil: rgba(246, 246, 246, 0.35); /* the frosted layer behind an open menu */

  /* Type */
  --font-display: "Inter Tight", "Helvetica Neue", Arial, sans-serif; /* wordmark and titles: tight bold grotesk caps */
  --font-body: "IBM Plex Mono", ui-monospace, monospace; /* every caption, readout and link: spaced mono caps */
  --text-mono: 11px; /* the captions and readouts */
  --text-s: 12px; /* links and buttons */
  --text-m: 15px; /* the wordmark, short reading lines */
  --text-l: clamp(20px, 2.2vw, 28px); /* sub-titles */
  --display-m: clamp(30px, 4.6vw, 64px); /* index titles */
  --display-l: clamp(44px, 9vw, 136px); /* the footer wordmark */
  --track-mono: 0.16em; /* letter spacing of mono caps */
  --track-wide: 0.5em; /* the spaced-out readout on the black field */
  --track-tight: -0.02em; /* bold grotesk caps */

  /* Space */
  --edge: clamp(18px, 2.4vw, 34px); /* side padding */
  --gap: 16px; /* gap between columns */
  --space-xs: 4px; /* inside a caption */
  --space-s: 8px; /* between a label and its value */
  --space-m: 16px; /* between lines of a block */
  --space-l: 28px; /* between blocks */
  --space-xl: 56px; /* around large groups */
  --section-space: clamp(64px, 8vw, 120px); /* air above and below a section */

  /* Shape */
  --radius-hair: 1px; /* picture frames on the strip, thumbnails in rows */
  --radius-panel: 14px; /* the dark menu panel */
  --radius-round: 50%; /* round buttons and the lens */
  --line: 1px; /* every rule */
  --button: 46px; /* the round icon button */

  /* Motion */
  --ease-snap: cubic-bezier(0.35, 0.7, 0.25, 1); /* small moves: hover nudges, blades */
  --ease-sweep: cubic-bezier(0.6, 0.05, 0.2, 1); /* panels opening, the lens swap */
  --ease: ease; /* fades and colour */
  --snap: 240ms; /* hover nudges */
  --grow: 280ms; /* a thumbnail opening */
  --sweep: 450ms; /* a panel or lens change */
  --fade: 400ms; /* fades */
  --tint: 500ms; /* grey to colour */
}

*, *::before, *::after { box-sizing: border-box; }
body { margin: 0; background: var(--paper); color: var(--ink); font: 400 var(--text-s)/1.5 var(--font-body); -webkit-font-smoothing: antialiased; }
img, svg, canvas { display: block; max-width: 100%; }

@media (prefers-reduced-motion: reduce) {
  *, *::before, *::after { animation-duration: 0.01ms !important; animation-iteration-count: 1 !important; transition-duration: 0.01ms !important; }
}

For your agent

Use the kitbash MCP server at https://kitbash.me/mcp. Call get_pack("aperture-film-ribbon"), 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