Back to the library

Bulletin — raised fast, lowered slow

Variant: Escalate

An alert level stepping Normal → Advisory → Watch and back, with the timing deliberately lopsided. Raising rolls the word through a one-line drum in 270ms on ease-out: a raised level is news, and it must already be on screen when someone looks. Lowering runs the same drum backwards over 720ms on a gentle symmetric curve that never bunches its travel into a blink, because calm should be announced, not blinked — a level that drops instantly reads as a glitch, and a reader glancing back mid-change still catches it moving. Direction is spatial: higher levels rise in from below, lower ones come down from above. The word is triple-coded — spelled out, coloured, and placed on a four-step ladder printed in full underneath — and never ships without a plain-language line saying what it means and what to do, so a reader who has never seen the scale does not have to remember one; that line fades out fully before its replacement fades in, so two meanings never ghost through each other. The Warning bar never fills; headroom above the current level is part of what the level means. The loop starts and ends on Normal, so it wraps without a reset. Reach for it for incident severity, risk levels and any graded status where going up and coming down are not the same news.

textstatusalertindicatortransitioneasingloop

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>Bulletin — level raised fast, lowered slow</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;
        --round: 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)
        );

        /* Clock — 9s, so 1% is 90ms. Raised at 14% and 32%, each roll 270ms;
           lowered at 58% and 80%, each roll 720ms. The loop starts and ends
           on Normal, so it wraps without a reset. */
        --cycle: 9s;
        --t: calc(var(--cycle) / var(--speed));

        --ease-out: cubic-bezier(0.23, 1, 0.32, 1);
        --ease-accent: cubic-bezier(0.45, 0, 0.55, 1); /* lowering: gentle, still moving mid-roll */

        --_muted: color-mix(in srgb, var(--slate) 56%, transparent);
        --_track: color-mix(in srgb, var(--oat) 70%, var(--paper));
      }

      * {
        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);
      }

      .card {
        width: min(300px, calc(100vw - 32px));
        padding: 14px 16px 15px;
        display: grid;
        gap: 10px;
        border-radius: calc(12px * var(--round));
        background: var(--paper);
        border: 1px solid var(--oat);
      }

      .k {
        display: flex;
        justify-content: space-between;
        font-size: 11px;
        font-weight: 700;
        letter-spacing: 0.12em;
        text-transform: uppercase;
        color: var(--_muted);
      }

      /* One line tall and clipped: the words roll through it like a drum,
         so a change always has a direction. */
      .slot {
        display: grid;
        height: 38px;
        overflow: hidden;
        font-size: clamp(26px, 8.4vw, 31px);
        line-height: 38px;
        font-weight: 750;
        letter-spacing: 0.01em;
        text-transform: uppercase;
      }

      .slot span,
      .means span {
        grid-area: 1 / 1;
      }

      .w1 {
        color: var(--olive);
        animation: w1 var(--t) infinite;
      }
      .w2 {
        color: var(--clay-d);
        transform: translateY(100%);
        animation: w2 var(--t) infinite;
      }
      .w3 {
        color: var(--rust);
        transform: translateY(100%);
        animation: w3 var(--t) infinite;
      }

      /* Raising: the lower word leaves upward and the higher one rises in
         from below — 270ms on ease-out, because a raised level is news and
         must be on screen before anyone has to look for it. */
      /* Lowering: the strip runs back down over 720ms on a gentle
         symmetric curve that never bunches its travel into a blink. Calm is
         announced deliberately; a level that drops in a blink reads as a
         glitch, and a reader who glanced away needs it to still be moving. */
      @keyframes w1 {
        0%,
        14% {
          transform: translateY(0);
          animation-timing-function: var(--ease-out);
        }
        17%,
        80% {
          transform: translateY(-100%);
          animation-timing-function: var(--ease-accent);
        }
        88%,
        100% {
          transform: translateY(0);
        }
      }

      @keyframes w2 {
        0%,
        14% {
          transform: translateY(100%);
          animation-timing-function: var(--ease-out);
        }
        17%,
        32% {
          transform: translateY(0);
          animation-timing-function: var(--ease-out);
        }
        35%,
        58% {
          transform: translateY(-100%);
          animation-timing-function: var(--ease-accent);
        }
        66%,
        80% {
          transform: translateY(0);
          animation-timing-function: var(--ease-accent);
        }
        88%,
        100% {
          transform: translateY(100%);
        }
      }

      @keyframes w3 {
        0%,
        32% {
          transform: translateY(100%);
          animation-timing-function: var(--ease-out);
        }
        35%,
        58% {
          transform: translateY(0);
          animation-timing-function: var(--ease-accent);
        }
        66%,
        100% {
          transform: translateY(100%);
        }
      }

      /* The whole scale is always printed, so the word never depends on the
         reader remembering how many levels there are or which is worst. */
      .ladder {
        display: grid;
        grid-template-columns: repeat(4, 1fr);
        gap: 4px;
      }

      .seg {
        display: grid;
        gap: 5px;
        font-size: 11px;
        color: var(--_muted);
        white-space: nowrap;
      }

      .bar {
        height: 5px;
        border-radius: calc(2px * var(--round));
        background: var(--_track);
        overflow: hidden;
      }

      .bar i {
        display: block;
        height: 100%;
        transform-origin: left;
      }

      .s1 i {
        background: var(--olive);
      }
      .s2 i {
        background: var(--clay);
        transform: scaleX(0);
        animation: s2 var(--t) infinite;
      }
      .s3 i {
        background: var(--rust);
        transform: scaleX(0);
        animation: s3 var(--t) infinite;
      }

      /* The Warning bar never fills: headroom above the current level is
         part of what the level means. */
      @keyframes s2 {
        0%,
        14% {
          transform: scaleX(0);
          animation-timing-function: var(--ease-out);
        }
        17%,
        80% {
          transform: scaleX(1);
          animation-timing-function: var(--ease-accent);
        }
        88%,
        100% {
          transform: scaleX(0);
        }
      }

      @keyframes s3 {
        0%,
        32% {
          transform: scaleX(0);
          animation-timing-function: var(--ease-out);
        }
        35%,
        58% {
          transform: scaleX(1);
          animation-timing-function: var(--ease-accent);
        }
        66%,
        100% {
          transform: scaleX(0);
        }
      }

      /* The word is never shipped without its meaning in plain words. */
      .means {
        display: grid;
        min-height: 36px;
        font-size: 13px;
        line-height: 18px;
        text-wrap: balance;
      }

      .m1 {
        animation: m1 var(--t) infinite;
      }
      .m2 {
        opacity: 0;
        animation: m2 var(--t) infinite;
      }
      .m3 {
        opacity: 0;
        animation: m3 var(--t) infinite;
      }

      /* Sequential, never crossed: the old meaning is gone before the new
         one starts, so two sentences never ghost through each other. */
      @keyframes m1 {
        0%,
        14% {
          opacity: 1;
          animation-timing-function: var(--ease-out);
        }
        15.5%,
        83% {
          opacity: 0;
          animation-timing-function: var(--ease-accent);
        }
        88%,
        100% {
          opacity: 1;
        }
      }

      @keyframes m2 {
        0%,
        15.5% {
          opacity: 0;
          animation-timing-function: var(--ease-out);
        }
        17.5%,
        32% {
          opacity: 1;
          animation-timing-function: var(--ease-out);
        }
        33.5%,
        61% {
          opacity: 0;
          animation-timing-function: var(--ease-accent);
        }
        66%,
        80% {
          opacity: 1;
          animation-timing-function: var(--ease-accent);
        }
        83%,
        100% {
          opacity: 0;
        }
      }

      @keyframes m3 {
        0%,
        33.5% {
          opacity: 0;
          animation-timing-function: var(--ease-out);
        }
        35.5%,
        58% {
          opacity: 1;
          animation-timing-function: var(--ease-accent);
        }
        61%,
        100% {
          opacity: 0;
        }
      }

      @media (prefers-reduced-motion: reduce) {
        :root {
          --t: calc(var(--cycle) * 1.5 / var(--speed));
        }

        /* The asymmetry survives as a crossfade: words swap in place, quick
           going up and slow coming down, with no travel. */
        .slot span {
          transform: none;
        }
        .w1 {
          animation-name: m1;
        }
        .w2 {
          opacity: 0;
          animation-name: m2;
        }
        .w3 {
          opacity: 0;
          animation-name: m3;
        }
      }
    </style>
  </head>
  <body>
    <div
      class="card"
      role="img"
      aria-label="An alert level raised quickly from Normal to Advisory to Watch, then lowered slowly back to Normal, with the full four-step scale and a plain-language meaning shown at every level"
    >
      <p class="k"><span>Summit vent</span><span>Alert level</span></p>
      <div class="slot" aria-hidden="true">
        <span class="w1">Normal</span>
        <span class="w2">Advisory</span>
        <span class="w3">Watch</span>
      </div>
      <div class="ladder" aria-hidden="true">
        <div class="seg s1">
          <span class="bar"><i></i></span>Normal
        </div>
        <div class="seg s2">
          <span class="bar"><i></i></span>Advisory
        </div>
        <div class="seg s3">
          <span class="bar"><i></i></span>Watch
        </div>
        <div class="seg s4">
          <span class="bar"><i></i></span>Warning
        </div>
      </div>
      <div class="means" aria-hidden="true">
        <span class="m1">Background activity only. Nothing to do.</span>
        <span class="m2">Unrest above background. Stay informed.</span>
        <span class="m3">Eruption possible. Be ready to leave.</span>
      </div>
    </div>
  </body>
</html>

The variant family

Same idea, one axis moved. Compare them side by side before you commit.