kitbash Sign in Connect agent
Components

Ruled hero

The black pebble mark melting out of a box, name and role stacked in 90px lines either side of the column rule, meta lines with a rolling link, every line growing out of goo as it comes into view.

Part of the style

Ink Bloom Column

7 parts that belong together, with their tokens, type and rules.

Preview

Code
<style>
/* Goes after the pack's base.css */
:root {
  --paper: #37312b;
  --ink: #54daa9;
  --mist: #3e352d;
  --tint: rgba(84, 218, 169, 0.05);
  --hairline: rgba(84, 218, 169, 0.1);
  --ink-ghost: rgba(84, 218, 169, 0.1);
  --ink-soft: rgba(84, 218, 169, 0.5);
  --menu-1: #524333;
  --menu-2: #4b3e31;
  --menu-3: #44392f;
  --theme-slate: #584635;
  --on-ink: #37312b;
  --theme-ember: #44503a;
  --theme-oxblood: #435039;
  --theme-lichen: #20562b;
}
</style>

<section class="intro" aria-label="Introduction">
  <svg class="intro__defs" aria-hidden="true" focusable="false"><defs></defs></svg>
  <div class="intro__top">
    <svg class="intro__mark" viewBox="0 0 100 164" role="img" aria-label="nachklang mark: a black pebble sending out sound">
      <path class="intro__pebble" d="M6 82a44 76 0 1 0 88 0a44 76 0 1 0-88 0Z" />
      <g class="intro__face">
        <circle cx="40" cy="66" r="6" />
        <path d="M54 56a14 14 0 0 1 0 20" />
        <path d="M63 49a24 24 0 0 1 0 34" />
      </g>
    </svg>
    <p class="intro__label intro__block"><span class="intro__line">Sound Designer</span><span class="intro__line">&amp; Engineer</span></p>
    <span class="intro__rule" aria-hidden="true"></span>
    <p class="intro__meta intro__block">
      <span class="intro__line">Based in Leipzig</span>
      <span class="intro__line">Working w/ <a class="intro__link" href="#" data-roll>HALL9</a></span>
    </p>
    <h1 class="intro__name intro__block"><span class="intro__line">Runa</span><span class="intro__line">Vosskamp</span></h1>
  </div>
  <h2 class="intro__heading intro__block"><span class="intro__line">Sound for</span><span class="intro__line">Rooms, Films</span><span class="intro__line">&amp; Screens,</span></h2>
  <div class="intro__lower">
    <span class="intro__rule intro__rule--lower" aria-hidden="true"></span>
    <h2 class="intro__heading intro__heading--right intro__block"><span class="intro__line">Foley</span><span class="intro__line">&amp; Spat-</span><span class="intro__line">ial</span><span class="intro__line intro__line--offset">mix.</span></h2>
    <p class="intro__note intro__block"><span class="intro__line">Records, designs and mixes sound for films, rooms</span><span class="intro__line">and interfaces, with a focus on space, silence</span><span class="intro__line">and timing.</span></p>
  </div>
</section>

<style>
  .intro {
    --rows: max(360px, 40.7639vw);
    position: relative;
    display: grid;
    grid-template-columns: repeat(8, minmax(0, 1fr));
    column-gap: var(--gap);
    padding: var(--edge) var(--edge) var(--space-l);
    background: var(--paper);
  }
  .intro__defs { position: absolute; width: 0; height: 0; }
  .intro__line { display: block; }
  :where(.intro) :is(p, h1, h2) { margin: 0; font-weight: inherit; }

  .intro__top {
    position: relative;
    grid-column: 3 / -1;
    display: grid;
    grid-template-columns: subgrid;
    grid-template-rows: auto 1fr auto;
    height: var(--rows);
  }
  .intro__mark {
    grid-column: 1;
    grid-row: 1;
    width: 58.6%;
    height: auto;
    overflow: visible;
  }
  .intro__pebble { fill: var(--ink); }
  .intro__face {
    fill: var(--paper);
    stroke: var(--paper);
    stroke-width: 4;
    stroke-linecap: round;
    transition: opacity var(--dur-s) var(--ease-out);
  }
  .intro__face path { fill: none; }
  .is-boxed .intro__face { opacity: 0; }
  .intro__label {
    grid-column: 1;
    grid-row: 3;
    align-self: end;
  }
  .intro__rule {
    position: absolute;
    top: 0;
    bottom: 0;
    left: calc((100% - 5 * var(--gap)) / 6 + var(--gap) / 2);
    width: var(--stroke);
    background: var(--ink);
  }
  .intro__meta {
    grid-column: 2 / span 3;
    grid-row: 1;
  }
  .intro__name,
  .intro__heading {
    font-size: var(--text-xl);
    line-height: var(--leading-xl);
    letter-spacing: var(--tracking-xl);
  }
  .intro__name {
    grid-column: 2 / -1;
    grid-row: 3;
    align-self: end;
  }
  .intro__heading {
    grid-column: 3 / -1;
    margin-top: 0.28em;
  }
  .intro__lower {
    position: relative;
    grid-column: 3 / -1;
    display: grid;
    grid-template-columns: subgrid;
    padding-top: var(--space-m);
  }
  .intro__rule--lower { left: calc((100% - 5 * var(--gap)) / 6 + var(--gap) / 2); }
  .intro__heading--right {
    grid-column: 2 / -1;
    margin: 0 0 var(--space-l);
  }
  .intro__line--offset { padding-left: calc((100% - 4 * var(--gap)) / 5 * 0.74); }
  .intro__note {
    grid-column: 2 / span 2;
    max-width: 34ch;
  }
  .intro__note .intro__line { display: inline; }
  .intro__note .intro__line::after { content: " "; }

  /* Link roll, same as the menu: letters leave upward while a copy rises in. */
  .intro__link {
    display: inline-block;
    position: relative;
    color: inherit;
    text-decoration: none;
    vertical-align: top;
    padding: 15px 2px;
    margin: -15px -2px;
  }
  .intro__link:focus-visible { outline: var(--stroke) solid var(--ink); outline-offset: -13px; }
  .intro__roll { display: inline-grid; overflow: clip; vertical-align: top; white-space: pre; }
  .intro__copy { grid-area: 1 / 1; justify-self: start; }
  .intro__char {
    display: inline-block;
    transition: translate var(--dur-s) var(--ease-in-out);
    transition-delay: calc(var(--back) * var(--roll-spread));
  }
  .intro__copy + .intro__copy .intro__char { translate: 0 100%; }
  .intro__link:is(:hover, :focus-visible) .intro__char { translate: 0 -100%; transition-delay: calc(var(--fore) * var(--roll-spread)); }
  .intro__link:is(:hover, :focus-visible) .intro__copy + .intro__copy .intro__char { translate: 0 0; }
  .intro__spoken { position: absolute; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }

  @media (max-width: 47.99rem) {
    .intro {
      --rows: max(420px, 118vw);
      grid-template-columns: repeat(4, minmax(0, 1fr));
    }
    .intro__top,
    .intro__lower { grid-column: 1 / -1; }
    .intro__mark { width: 100%; }
    .intro__rule,
    .intro__rule--lower { left: calc((100% - 3 * var(--gap)) / 4 + var(--gap) / 2); }
    .intro__meta { grid-column: 2 / -1; }
    .intro__heading { grid-column: 1 / -1; }
    .intro__heading--right { grid-column: 2 / -1; }
    .intro__note { grid-column: 2 / -1; }
    .intro__line--offset { padding-left: 24%; }
  }

  @media (prefers-reduced-motion: reduce) {
    .intro__char, .intro__face { transition: none; }
  }
</style>

<script>
(() => {
  const still = matchMedia('(prefers-reduced-motion: reduce)');
  const POINTS = 48;
  let filters = 0;

  function token(root, name) { return getComputedStyle(root).getPropertyValue(name).trim(); }
  function ms(root, name) { return parseFloat(token(root, name)) * 1000; }

  function bezier(spec) {
    const [x1, y1, x2, y2] = spec.match(/-?[\d.]+/g).map(Number);
    const curve = (a, b, t) => 3 * a * t * (1 - t) ** 2 + 3 * b * t * t * (1 - t) + t ** 3;
    return (x) => {
      let low = 0, high = 1, t = x;
      for (let step = 0; step < 24; step += 1) {
        t = (low + high) / 2;
        if (curve(x1, x2, t) < x) low = t; else high = t;
      }
      return curve(y1, y2, t);
    };
  }
  const linear = (x) => x;

  function tween(duration, delay, ease, update) {
    return new Promise((done) => {
      const start = performance.now() + delay;
      const frame = (now) => {
        const progress = Math.min(1, Math.max(0, (now - start) / duration));
        if (now >= start) update(ease(progress));
        if (progress < 1) requestAnimationFrame(frame); else done();
      };
      requestAnimationFrame(frame);
    });
  }

  /* Goo: heavy blur through a hard alpha threshold, so each line grows out of ink blobs. */
  function gooFilter(root, line) {
    if (line._goo) return line._goo;
    const svg = 'http://www.w3.org/2000/svg';
    const filter = document.createElementNS(svg, 'filter');
    const blur = document.createElementNS(svg, 'feGaussianBlur');
    const matrix = document.createElementNS(svg, 'feColorMatrix');
    filters += 1;
    filter.id = `intro-goo-${filters}-${Math.random().toString(36).slice(2, 7)}`;
    Object.entries({ x: '-25%', y: '-25%', width: '150%', height: '150%', 'color-interpolation-filters': 'sRGB' }).forEach(([key, value]) => filter.setAttribute(key, value));
    blur.setAttribute('in', 'SourceGraphic');
    matrix.setAttribute('type', 'matrix');
    filter.append(blur, matrix);
    root.querySelector('.intro__defs defs').append(filter);
    const scale = Math.max(0.3, parseFloat(getComputedStyle(line).fontSize) / 90);
    line._goo = (deviation, amp, offset) => {
      blur.setAttribute('stdDeviation', (deviation * scale).toFixed(2));
      matrix.setAttribute('values', `1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 ${amp} ${offset}`);
      line.style.filter = `url(#${filter.id})`;
    };
    return line._goo;
  }

  function reveal(root, lines, delay) {
    const easeOut = bezier(token(root, '--ease-out'));
    const durL = ms(root, '--dur-l');
    const stagger = ms(root, '--stagger');
    const most = parseFloat(token(root, '--goo-blur'));
    lines.forEach((line, index) => {
      const goo = gooFilter(root, line);
      const state = { deviation: most, amp: 20, offset: -8 };
      const paint = () => goo(state.deviation, state.amp, state.offset);
      const start = delay + index * stagger;
      paint();
      Promise.all([
        tween(durL, start, easeOut, (eased) => { state.deviation = most * (1 - eased); paint(); }),
        tween(durL * 0.35, start + durL * 0.65, linear, (eased) => { state.amp = 20 - 19 * eased; state.offset = -8 + 8 * eased; paint(); }),
      ]).then(() => { line.style.filter = ''; });
    });
  }

  /* The mark is drawn as 48 points around its centre, so a box can melt into the pebble. */
  function outline(shape) {
    return Array.from({ length: POINTS }, (_, index) => {
      const angle = (index / POINTS) * Math.PI * 2;
      const cos = Math.cos(angle), sin = Math.sin(angle);
      if (shape === 'box') {
        const reach = Math.min(42 / Math.abs(cos || 1e-6), 74 / Math.abs(sin || 1e-6));
        return [50 + reach * cos, 82 + reach * sin];
      }
      const wobble = 1 + 0.07 * Math.sin(2 * angle + 0.6) + 0.045 * Math.sin(3 * angle + 1.9) + 0.025 * Math.sin(5 * angle + 0.4);
      return [50 + 44 * wobble * cos + 3 * sin, 82 + 76 * wobble * sin];
    });
  }

  function smoothPath(points, tension) {
    const n = points.length;
    const at = (index) => points[(index + n) % n];
    let d = `M${at(0)[0].toFixed(2)} ${at(0)[1].toFixed(2)}`;
    for (let index = 0; index < n; index += 1) {
      const [p0, p1, p2, p3] = [at(index - 1), at(index), at(index + 1), at(index + 2)];
      const c1 = [p1[0] + ((p2[0] - p0[0]) / 6) * tension, p1[1] + ((p2[1] - p0[1]) / 6) * tension];
      const c2 = [p2[0] - ((p3[0] - p1[0]) / 6) * tension, p2[1] - ((p3[1] - p1[1]) / 6) * tension];
      d += `C${c1[0].toFixed(2)} ${c1[1].toFixed(2)} ${c2[0].toFixed(2)} ${c2[1].toFixed(2)} ${p2[0].toFixed(2)} ${p2[1].toFixed(2)}`;
    }
    return `${d}Z`;
  }

  function morphMark(root, delay) {
    const pebble = root.querySelector('.intro__pebble');
    const box = outline('box');
    const stone = outline('pebble');
    const blend = (amount) => box.map((point, index) => [
      point[0] + (stone[index][0] - point[0]) * amount,
      point[1] + (stone[index][1] - point[1]) * amount,
    ]);
    if (still.matches) { pebble.setAttribute('d', smoothPath(stone, 1)); return; }
    root.classList.add('is-boxed');
    pebble.setAttribute('d', smoothPath(box, 0));
    tween(ms(root, '--dur-m'), delay, bezier(token(root, '--ease-in-out')), (eased) => {
      pebble.setAttribute('d', smoothPath(blend(eased), eased));
    }).then(() => root.classList.remove('is-boxed'));
  }

  function buildRoll(link) {
    const text = link.textContent.trim();
    const roll = document.createElement('span');
    roll.className = 'intro__roll';
    roll.setAttribute('aria-hidden', 'true');
    const last = Math.max(1, text.length - 1);
    for (let copy = 0; copy < 2; copy += 1) {
      const line = document.createElement('span');
      line.className = 'intro__copy';
      [...text].forEach((letter, index) => {
        const char = document.createElement('span');
        char.className = 'intro__char';
        char.textContent = letter;
        char.style.setProperty('--fore', index / last);
        char.style.setProperty('--back', (last - index) / last);
        line.append(char);
      });
      roll.append(line);
    }
    const spoken = document.createElement('span');
    spoken.className = 'intro__spoken';
    spoken.textContent = text;
    link.replaceChildren(roll, spoken);
  }

  function setUp(root) {
    root.querySelectorAll('[data-roll]').forEach(buildRoll);
    morphMark(root, 0);
    if (still.matches) return;
    const blocks = [...root.querySelectorAll('.intro__block')];
    blocks.forEach((block) => block.querySelectorAll('.intro__line').forEach((line) => gooFilter(root, line)(parseFloat(token(root, '--goo-blur')), 20, -8)));
    const stagger = ms(root, '--stagger');
    const seen = new IntersectionObserver((entries) => {
      const arriving = entries.filter((entry) => entry.isIntersecting).map((entry) => entry.target);
      arriving.forEach((block, order) => {
        seen.unobserve(block);
        reveal(root, [...block.querySelectorAll('.intro__line')], order * stagger);
      });
    }, { threshold: 0.1 });
    blocks.forEach((block) => seen.observe(block));
  }

  document.querySelectorAll('.intro').forEach(setUp);
})();
</script>

Similar components

Screensaver deck

Screensaver deck

Spring headline

Spring headline

Selection frame hero

Selection frame hero

Film reel

Film reel

Red clock field

Red clock field

Spread headline

Spread headline

HUD hero

HUD hero

Sticker headline hero

Sticker headline hero