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.
https://kitbash.me/components/ink-bloom-column/intro/figma.html?palette=dbd3d0f1dcf98bd1
Use the Figma MCP server (https://mcp.figma.com/mcp). Download https://kitbash.me/components/ink-bloom-column/intro/figma.html?palette=dbd3d0f1dcf98bd1 and pass that whole HTML document to the html_to_figma tool, so the part "Ruled hero" lands as editable layers in my open Figma file. Fonts come from Google Fonts: if a face is missing in Figma, pick the closest one.
Code
<style>
/* Goes after the pack's base.css */
:root {
--paper: #f2efe7;
--ink: #08150a;
--mist: #e8e5dd;
--tint: rgba(8, 21, 10, 0.05);
--hairline: rgba(8, 21, 10, 0.1);
--ink-ghost: rgba(8, 21, 10, 0.1);
--ink-soft: rgba(8, 21, 10, 0.5);
--menu-1: #cbc8be;
--menu-2: #d5d2c8;
--menu-3: #dfdcd3;
--theme-slate: #c3c0b5;
--on-ink: #f2efe7;
--theme-ember: #509058;
--theme-oxblood: #4e8f57;
--theme-lichen: #509058;
}
</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">& 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">& 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">& 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>