← Case study

Detail 05 · Design system

How things move

The system's other half: 26 springs sorted into five named for their job, controls that answer alike, and nothing that pops. 7 minutes, 3 demos.

Try it: tap to sort 26 springs into five

01 · The idea

The other half of the system

The pencil language decides how the site looks: one ember, four typefaces, lines drawn by hand. It says nothing about how the site moves. How long a change takes, how much it bounces, what a button does under your finger, how something arrives and how it leaves: that’s half of what you feel on a page, and it needs rules as much as colour does.

Without rules, every new component gets tuned by feel, on the day it’s built. Each choice is fine on its own. Together they drift, and a page where every control has its own rhythm feels like parts from different kits.

This detail is this site’s own set. For the general idea, how a curve or a spring turns time into motion and when each one is right, there’s an article: A guide to easing and springs.

02 · The audit

Twenty-six springs, seventeen settings

Before writing this detail I counted. The site had 26 springs, written one at a time across 19 files, with 17 different settings between them. Six demos carried their own identical copy of the same spring. The music player’s buttons and the demos’ sliders were both “a control”, tuned a hair apart.

None of it was wrong, which is why it lasted. Here is every one of them, plotted by how long it takes to settle and how much it bounces.

Every spring on the site

26 springs, 17 settings

Sorted by the job each one was doing, they fall into five groups, and inside each group the differences were noise: nobody could feel 0.2 against 0.25 of bounce, but every one of them had to be chosen, and copied, and kept.

03 · The code

Five springs, named for their job

Now there are five, in one file, and every animated change picks one by what it’s doing.

The site's springs
export const SPRING = {
  // A control answering the hand: a press, a toggle, a slider, a pill or icon swelling on hover
  press: { type: "spring", visualDuration: 0.3, bounce: 0.2 },
  // Content changing in place: a label, a caption, a marker moving to the next row
  swap: { type: "spring", visualDuration: 0.35, bounce: 0.15 },
  // A shape becoming another, or travelling across the page: islands, the "you are here" box
  morph: { type: "spring", visualDuration: 0.55, bounce: 0.2 },
  // A small flourish meant to be noticed: the book's ribbon, a counter ticking up
  playful: { type: "spring", visualDuration: 0.35, bounce: 0.4 },
  // A value gliding to a new reading: bars, progress, a zoom
  glide: { type: "spring", visualDuration: 0.6, bounce: 0.1 },
};

The names are jobs, not feelings. A toggle is press wherever it lives, even inside a demo about islands; a label changing in place is swap, whether it’s in the page index or a demo’s tabs. The island’s spring is still exported as ISLAND_SPRING, but it’s now SPRING.morph a little quicker, so the dock and the sidebar’s “you are here” box move alike; an island is small and opened often, so it gets there sooner (its opening and closing take their own variations of it: Dynamic islands).

The same file holds the rest of the vocabulary. How deep a press sinks, by the size of what’s pressed. The book’s page turns, which are morph slowed to the weight of a page. And the curves for whatever is timed rather than sprung: a sequence, a sketch, a page change.

Presses, page turns and curves
export const PRESS = { icon: 0.9, wide: 0.96, card: 0.98 };

// A page turning over the spine: one leaf, the heavier cover, a quick riffle of several
export const TURN = {
  leaf: { ...SPRING.morph, visualDuration: 0.8 },
  cover: { ...SPRING.morph, visualDuration: 0.9 },
  riffle: { ...SPRING.morph, visualDuration: 0.6 },
};

// Curves for what's timed rather than sprung: a sequence, a sketch, a page change
export const EASE = {
  // Arriving or answering: quick away, soft landing
  out: [0.22, 1, 0.36, 1],
  // A long flight across the page: slow away, quick across, slow into place
  flight: [0.76, 0, 0.24, 1],
  // A shorter move on screen
  move: [0.65, 0, 0.35, 1],
  // The old page sinking away
  sink: [0.4, 0, 0.2, 1],
  // A blur that builds slowly, then deepens
  deepen: [0.5, 0, 0.75, 0],
};

Some springs stay where they are, on purpose. The ones that follow something (letters leaning toward the cursor, a reveal tied to the scroll) aren’t playing a change; they’re chasing a moving value, and each is tuned to what it chases. So are the per-letter springs that rewrite a word, where many small parts move at once.

04 · Controls

Three controls, one hand

Every control on the site answers in the same ways: it brightens or nudges under the pointer, does the same when the keyboard reaches it, pushes in when pressed, and turns ember when it’s on. The first three are plain CSS, alike everywhere: 150 milliseconds on the out curve, and a press that sinks to its PRESS depth. CSS keeps them the same even for visitors who switch animations off (Motion you can switch off). What the control then changes, a switch’s handle sliding or a chevron turning over, is a spring, and that’s where controls drift apart.

Press all three controls below at once. On one spring they come to rest together. Then give each the spring it might have got if it had been tuned alone.

Three controls, pressed at once

Press one, or all three.

Apart, nothing is broken. Each control is just a little too quick or too slow next to its neighbours, and the page stops feeling like one object.

05 · Nothing pops

In and out, never on and off

The other rule: anything a control adds or removes animates both ways. Add a note below, take one off, then switch the animation off and do it again.

Add a note, take one off

Without it, a note appears from nowhere and its neighbours jump to make room; take one off and the gap snaps shut. With it, the note blurs in on the swap spring and the others glide aside. The exit is the half that’s easy to forget: React removes an element at once, so it needs AnimatePresence to stay long enough to leave.

Leaving takes a wrapper
<AnimatePresence mode="popLayout">
  {notes.map((note) => (
    <motion.li key={note.id} layout transition={SPRING.swap}
      initial={{ opacity: 0, filter: "blur(4px)" }}
      animate={{ opacity: 1, filter: "blur(0px)" }}
      exit={{ opacity: 0, filter: "blur(4px)" }} />
  ))}
</AnimatePresence>

06 · Decisions

The rules of motion

Name it by its job

press, swap, morph, playful, glide. Choosing a spring is choosing what the change is, not how it should feel today.

Count before naming

The five came from the 26, not from a blank page. Tokens drawn from what’s already there fit what’s already there.

Followers stay local

A spring chasing the cursor or the scroll is tuned to its input. Sharing it would make it worse at its one job.

Exits count

Whatever arrives with motion leaves with it. A thing that fades in and blinks out feels half-built.

07 · Takeaways

What to keep

  • A design system covers motion too: how long, how bouncy, and what every control does under your hand.
  • Audit before you name: count the springs you have, sort them by job, and the tokens fall out.
  • Name springs by job, so picking one is a decision about what the change is, not a new round of tuning.
Five springs, everywhere→

The music island morphs open on morph, a touch quicker, its buttons sink to their PRESS depth, the track name changes on its letter springs, and the progress line draws back on glide when you skip.