1. Static links are the baseline
Most token systems already have the familiar split: raw values in
one place, semantic names in another. A small pool of source
values like values.gray800,
values.gray50, and values.blue500 is
enough.
Those inputs become useful once semantic tokens give them a job:
-
color.brand= — points atvalues.gray800 -
color.surface= — points atvalues.gray50 -
color.onSurface= — paired withcolor.surface; the text color that goes on it
Static links are good. They are direct, inspectable, and
predictable. I do not want to replace them. I want to stop using
them for relationships they are too simple to express. A pair like
surface / onSurface already hints at the
limit: two pinned choices are standing in for one design decision.
2. Some links are really formulas
Some semantic tokens are not really aliases. They are tiny
policies. color.buttonText is a good example. Writing
ref('values.white') stores an answer, but not the
reasoning behind it: white against what, chosen for what purpose,
valid for how long?
That is where the spreadsheet analogy helps. A token can behave like a cell with a fixed link, or like a cell with a simple formula. The fixed link remains the default. The point is simply to allow formulas when the relationship is the thing you actually care about.
The button label already works like that. The brittle version
would be color.buttonText = ref('values.white'). The
stronger version stores the rule instead of the answer:
color.buttonText =
bestContrastWith(, ramp)
Re-point the brand color and the label is picked again. The token keeps the logic that produced the outcome, so you can read why it is white.
3. Choose one of a set
One kind of dynamic connection looks at a pool of candidates and picks one. It is useful whenever the decision is comparative: the most readable foreground, or the faintest line that still clears a threshold.
The most readable foreground
color.onSurface starts as a plain ref to
values.gray900. That works for a light surface, and
fails the moment the surface stops being light.
color.onSurface =
bestContrastWith(color.surface, values)
Edit and the foreground is picked again. The pair surface / onSurface becomes one relationship the system can maintain, where before it was two separate pinned choices.
Paired treatment
surfaceTreatment.default = { surface, onSurface }
surface
onSurface
These are one named decision: edit the surface and the readable foreground is picked again, so the pair stays coherent.
The faintest line that still works
The same pattern can also pick the weakest option that still satisfies a condition.
color.line =
minContrastWith(, ramp, { minContrast: })
Where bestContrastWith picks the highest contrast available, minContrastWith picks the lowest step that still clears the threshold. Instead of "use this grey", the token says "pick the weakest boundary that still reads as a boundary".
One step up, one step down
The same "pick from a set" pattern works on dimensional scopes like spacing, type and motion. Given a scale and a starting member, nextLarger and nextSmaller return the adjacent step. The unit can be anything (px, rem, ms); members in a different unit from the starting one are skipped.
space.emphasis =
nextLarger(space.m, space)
Add a sixth spacing step and space.emphasis may move to it without any code change. Pass { minDistance: 6 } to skip neighbours that are too close, for scales with fine-grained steps where the derived token should still be a noticeable jump.
4. Extend a decision
A treatment rarely exists once. The card that holds the report needs an inverted version for a callout: the same decisions, made on a dark ground. Copying the scope copies every rule with it, and the two copies start to drift the first time one of them is fixed. Extending it keeps one set of rules and lets the variant say only what is different.
card.surface =
card.onSurface = bestContrastWith(ref('.surface'), values)
card.line = minContrastWith(ref('.surface'), ramp)
card-inverted extends card
card-inverted.surface =
The inverted card writes one line. Everything else it inherits, and the interesting question is what those inherited rules read.
Absolute or relative
A reference that names its key in full, ref('card.surface'),
points at that key wherever the rule ends up. Inherited by the
inverted card, onSurface keeps measuring the light
surface of the original, and the callout gets dark text on a dark
ground. Leave the scope off, ref('.surface'), and the
reference reads surface in whichever scope reads the
rule. The inverted card's inherited rules re-decide against its own
surface.
card
Revenue grew 12% over Q3.
card-inverted extends card
Revenue grew 12% over Q3.
Both are useful, and the choice is made per reference. An absolute reference pins a decision to one source: the brand color, whatever card this is. A relative one makes the decision part of the treatment: readable on my own surface. One variant can do both, following its own surface while still pointing at the one brand color everyone shares.
This is the inside-one-system version of a theme: variants that live side by side, a card and its callout, a button and its destructive twin. A theme that changes the roots everywhere at once, a dark mode or a second brand, is the same idea one level up, and it does not need a second copy of the rules either.
5. Do something to a value
The second kind of dynamic connection does not choose from a set. It takes an input and applies a small operation to it. This is where utility or transform tokens become useful: scale, mix, darken, lighten, offset.
Scale from a base
Every gap inside the example panel (title to paragraph, paragraph to chart, chart to button) is a multiple of . Pull the base and the whole rhythm scales together via spacingScale.
Edit the scale here
space.base
space.xs
spacingScale(base, { multiplier:
})
=
space.s
spacingScale(base, { multiplier:
})
=
space.m
spacingScale(base, { multiplier:
})
=
space.l
spacingScale(base, { multiplier:
})
=
space.xl
spacingScale(base, { multiplier:
})
=
Shift a value
The simplest version of this kind of rule takes one input and nudges it. The link's hover state in the example panel is one of those: a darker shade of color.interaction, computed on the fly instead of stored.
color.linkHover =
darken(color.interaction, )
Move the amount. Every link that uses the hover token shifts at once because there is only ever one decision to re-evaluate.
Blend two inputs
The seven bars in the chart are not seven hand-picked colors. They are seven steps of a ramp generated between two inputs:
ramp.sN =
colorMix(shade(, 10%), , ratio)
Drag either endpoint and the bars change together, because the connection stores the formula. A hover shade or a pressed state works the same way with a different scale.
6. Truly procedural design
For a long time, tokenising everything felt like the end of creative freedom to me. Every choice was locked in, and every relationship was buried in a dependency graph nobody wanted to climb. Once the system was set up, exploring happened somewhere else: in Figma, in a script, in ad-hoc decisions made outside the system and patched in later.
With procedural tokens the exploring can happen inside the system. Every value token in this article, every grey and every accent, is a point on a single color line. Drag any anchor and the whole system shifts together: the values move, the refs that point at them follow, the ramp is interpolated again and the contrast rules pick again.
Each dot on the wheel is an anchor; the line between them is the palette. Every values.* token is sampled somewhere on that line, even the ones named for greys.
The names values.gray800, values.red500 stay where they were, but their colors change. I like that: a token system you can explore and not only maintain. The structure keeps it coherent, and the inputs stay free to play with.
Each space.* token reads its multiplier from this curve. Drag the two handles to reshape the scale; the gap, the padding and the spacing between the chart bars in the panel all follow.
7. Better links
This is not an argument against static refs. Most links should stay static, because static is clear. The point is simply to stop forcing every relationship to pretend it is an alias.
When a connection is really a choice or a transformation, the token should be allowed to say so. That makes systems safer to change: change the brand color, the surface, the base spacing, or the threshold, and the dependent choices can be recalculated instead of fossilizing old assumptions.
Too often the workflow goes the other way around: generate a ramp, freeze it into tokens, then build the design around that frozen result. It works until dark mode arrives, or a second theme, or a broader brand shift. Then all the flexibility that should have been inside the system has to be retrofitted after the fact. When the relationships live inside the system, a dark theme is only the handful of roots that change, a dark surface and a light ink, and everything derived from them follows.
Once a token system can encode relationships and not only results, it becomes a way to find things. It keeps more complexity coherent than anyone wants to track by hand, and it turns up combinations I would not have picked manually.
That is the part I find exciting. Change the surface, shift the interaction color, alter the spacing base, and the system answers back. Sometimes the answer is simply robust, sometimes it is surprising. That is what I mean by emergence: the practical result of encoding relationships instead of pinning every outcome in advance.
So what I want are better links: static when that is enough, a formula when it is needed. Color and spacing make the pattern easy to see, but the same logic applies anywhere the relationship matters more than the stored result: type treatments, motion rules, icon choices, grouped decisions like a surface/on-surface pair. A text style is already one of those: size, weight and line height travel as one token, and a variant that changes only the weight keeps following the rest. At that point a token system is less a catalogue of frozen answers and more a design spreadsheet, or at its best a small design program, one where flexibility is part of the design from the start.