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.
Part of the style
Scanline Red
7 parts that belong together, with their tokens, type and rules.
https://kitbash.me/components/scanline-red/waterfall/figma.html?palette=ab5233fd274ce3d8
Use the Figma MCP server (https://mcp.figma.com/mcp). Download https://kitbash.me/components/scanline-red/waterfall/figma.html?palette=ab5233fd274ce3d8 and pass that whole HTML document to the html_to_figma tool, so the part "Spectrum figure" 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 {
--red: #c5e0db;
--dark: #1c0d06;
--glow: rgba(197, 224, 219, 0.95);
}
</style>
<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>