Field record — laid out from the datum
Variant: From the datum
A survey grid strung out from a single stake. The datum calls once — a ring that is gone before anything is laid — then the two baselines through it draw first and heavier, and every other string follows on a delay of 88ms per grid square of distance from the stake, each running away from it on a 560ms ease-out. Two rules from one source, so the cascade spreads out of a corner rather than wiping left to right, and the eye learns where zero is before it reads a label; the far corner’s coordinate arrives last, as the grid's extent. Butt caps on a 100/100 dash mean a waiting line is genuinely empty, with no parked cap to leak. Reach for it on chart gridlines, a canvas or map that opens on its origin, or any coordinate frame the user has to read positions off — stagger by distance from origin, not by DOM order. The exit, by contrast, runs on the master clock with no delay — the baselines everything was measured off must never leave before the strings that hang from them. Reduced motion keeps the grid laid and lets the outward order survive as a slow brightening.
The source
A complete HTML document. Paste it into an empty .html file and it plays — no stylesheet, script, font, or image to fetch.
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Field record — laid out from the datum</title>
<style>
:root {
/* Neutrals — fixed, never remixed. */
--ivory: #faf9f5;
--paper: #ffffff;
--oat: #e3dacc;
--slate: #141413;
/* Knobs — the remix API. A knob exists iff declared here and used below. */
--hue: 38.8;
--lift: 0;
--chroma: 1;
--speed: 1;
/* Accents — derived from the knobs with the family's offsets baked in,
so one hue roll moves them together. Defaults reproduce the original hex. */
--clay: oklch(calc(0.6724 + var(--lift)) calc(0.1308 * var(--chroma)) var(--hue));
--clay-d: oklch(calc(0.5797 + var(--lift)) calc(0.127 * var(--chroma)) var(--hue));
--olive: oklch(
calc(0.6118 + var(--lift)) calc(0.0713 * var(--chroma)) calc(var(--hue) + 88.3)
);
--rust: oklch(
calc(0.5408 + var(--lift)) calc(0.1357 * var(--chroma)) calc(var(--hue) - 10.3)
);
--_muted: color-mix(in srgb, var(--slate) 46%, transparent);
--_string: color-mix(in srgb, var(--slate) 26%, transparent);
/* Clock — 4s. The datum calls for 480ms, then every line leaves on a
delay of 88ms per grid square of distance from it and draws for
560ms. The far corner is closed 1.48s in; the rest is the grid
simply being there. */
--cycle: 4s;
--t: calc(var(--cycle) / var(--speed));
--_step: calc(88ms / var(--speed));
--ease-out: cubic-bezier(0.23, 1, 0.32, 1);
}
* {
box-sizing: border-box;
margin: 0;
padding: 0;
}
body {
min-height: 100vh;
display: grid;
place-items: center;
background: var(--ivory);
font-family:
system-ui,
-apple-system,
'Segoe UI',
Roboto,
sans-serif;
color: var(--slate);
}
.sheet {
width: min(300px, 86vw);
height: auto;
display: block;
}
/* Every string starts at its end nearest the datum and runs away from
it, and leaves after a delay proportional to that same distance. Two
rules, one source: the cascade is a wave out of one point rather than
a left-to-right wipe, so the eye learns where zero is before it has
read a single label. */
.string {
fill: none;
stroke: var(--_string);
stroke-width: 1;
stroke-dasharray: 100 100;
animation: lay var(--t) infinite both;
animation-delay: calc(var(--_d) * var(--_step));
}
/* The two baselines through the datum are the ones everything else is
measured off, so they carry more ink and leave first. */
.base {
stroke: var(--slate);
stroke-width: 1.5;
}
.datum-ring {
fill: none;
stroke: var(--clay);
stroke-width: 1.5;
transform-box: fill-box;
transform-origin: center;
animation: call var(--t) infinite;
}
.datum {
fill: var(--clay-d);
}
.label {
fill: var(--_muted);
font-family: inherit;
font-size: 11px;
font-weight: 600;
letter-spacing: 0.1em;
font-variant-numeric: tabular-nums;
}
.laid {
animation: laid var(--t) infinite;
}
.extent {
animation: extent var(--t) infinite;
}
/* Butt caps and a 100/100 dash: at an offset of 100 there is genuinely
nothing on the path, so a waiting string needs no parking trick. Each
line is an entrance, so ease-out — it leaves the baseline at speed and
slows as it reaches the far edge of the trench. */
@keyframes lay {
0%,
12% {
stroke-dashoffset: 100;
animation-timing-function: var(--ease-out);
}
26%,
84% {
stroke-dashoffset: 0;
animation-timing-function: steps(1, end);
}
85%,
100% {
stroke-dashoffset: 100;
}
}
/* The exit runs on the master clock, undelayed: the whole grid lifts
at once, so the baselines everything was measured off never leave
before the strings that hang from them. Every string is parked inside
the dark window, whatever its delay. */
@keyframes laid {
0%,
76% {
opacity: 1;
animation-timing-function: var(--ease-out);
}
82%,
97% {
opacity: 0;
}
100% {
opacity: 1;
}
}
/* One call from the datum before anything is laid: a ring that grows
out of the stake and is gone before the first string arrives. */
@keyframes call {
0% {
opacity: 0.8;
transform: scale(1);
animation-timing-function: var(--ease-out);
}
12%,
100% {
opacity: 0;
transform: scale(3.2);
}
}
@keyframes extent {
0%,
40% {
opacity: 0;
animation-timing-function: var(--ease-out);
}
46%,
76% {
opacity: 1;
animation-timing-function: var(--ease-out);
}
82%,
100% {
opacity: 0;
}
}
@media (prefers-reduced-motion: reduce) {
/* The grid stays laid and keeps its origin story in opacity alone:
the strings brighten outward from the datum on the same per-square
delay, slowly, and nothing draws or grows. */
.string {
stroke-dashoffset: 0;
animation: glow calc(var(--t) * 1.6) var(--ease-out) infinite both;
animation-delay: calc(var(--_d) * 160ms / var(--speed));
}
.laid,
.datum-ring {
animation: none;
opacity: 0;
}
.extent {
animation-duration: calc(var(--t) * 1.6);
}
@keyframes glow {
0%,
100% {
opacity: 0.6;
}
30%,
60% {
opacity: 1;
}
}
}
</style>
</head>
<body>
<svg
class="sheet"
viewBox="0 0 260 164"
role="img"
aria-label="A survey grid being laid out from a datum stake in the bottom left corner. The two baselines through the stake draw first, then every other line follows on a delay set by its distance from the stake, so the grid spreads outward from one point, and the far corner's coordinate appears last"
>
<!-- Verticals draw bottom to top; horizontals left to right. --_d is
each line's distance from the datum in grid squares. -->
<g class="laid">
<path class="string" style="--_d: 1" pathLength="100" d="M 76 128 V 20" />
<path class="string" style="--_d: 2" pathLength="100" d="M 112 128 V 20" />
<path class="string" style="--_d: 3" pathLength="100" d="M 148 128 V 20" />
<path class="string" style="--_d: 4" pathLength="100" d="M 184 128 V 20" />
<path class="string" style="--_d: 5" pathLength="100" d="M 220 128 V 20" />
<path class="string" style="--_d: 1" pathLength="100" d="M 40 92 H 220" />
<path class="string" style="--_d: 2" pathLength="100" d="M 40 56 H 220" />
<path class="string" style="--_d: 3" pathLength="100" d="M 40 20 H 220" />
<path class="string base" style="--_d: 0" pathLength="100" d="M 40 128 V 20" />
<path class="string base" style="--_d: 0" pathLength="100" d="M 40 128 H 220" />
</g>
<circle class="datum-ring" cx="40" cy="128" r="4.5" />
<circle class="datum" cx="40" cy="128" r="4.5" />
<text class="label" x="30" y="150">DATUM 0·0</text>
<text class="label extent" x="220" y="12" text-anchor="end">5·3</text>
</svg>
</body>
</html>
The variant family
Same idea, one axis moved. Compare them side by side before you commit.