Back to the library

Glyph — sync

Variant: Sync

The refresh arrows, turned a half step at a time instead of spun. Both arcs draw tail to head, clockwise, the way they are about to rotate, and each arrowhead grows out of the corner its arc arrives at. Then a 512ms half turn on an ease-in-out, a 384ms rest, and another. The glyph is symmetric under a half turn, so every rest frame is the icon exactly as drawn — never caught at an angle that reads as a different symbol — and that is what lets it stop at all. A continuous spin says "busy"; a turn and a rest says "one more pass", which is what a poll or a retry actually is. The strokes then erase in the direction they turned, fading over the last stretch so no shrinking dash leaves a cap dot behind. In product, draw once on mount and loop only the turn. Keep a plain spinner for work with no rounds in it.

svgline-drawingiconstatusloop

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>Glyph — sync</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)
        );

        /* Clock — 3.2s: draw 640ms, two half-turns of 512ms with a 384ms rest
           after each, erase 384ms. Geometry is lucide's refresh-cw (ISC). */
        --cycle: 3.2s;
        --t: calc(var(--cycle) / var(--speed));

        --ease-out: cubic-bezier(0.23, 1, 0.32, 1);
        --ease-in-out: cubic-bezier(0.77, 0, 0.175, 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);
      }

      .demo {
        display: grid;
        justify-items: center;
        gap: clamp(14px, 5vmin, 28px);
      }

      .glyph {
        display: block;
        fill: none;
        stroke: currentColor;
        stroke-linecap: round;
        stroke-linejoin: round;
        /* The head corners sit 12.7 units from the centre, so at 45° they
           pass the 24-unit box by about 1.5. Let them: the hero's margin and
           the button's padding both have the room. */
        overflow: visible;
      }

      /* The 16px copy takes a 2-unit stroke so it survives the pixel grid —
         at the hero's 1.5 it would render under a pixel wide. */
      .hero {
        width: clamp(72px, 30vmin, 128px);
        height: auto;
        stroke-width: 1.5;
      }

      .button {
        display: inline-flex;
        align-items: center;
        gap: 8px;
        padding: 8px 16px 8px 13px;
        border: 1px solid var(--oat);
        border-radius: 999px;
        background: var(--paper);
        color: inherit;
        font: inherit;
        font-size: 13px;
        font-weight: 500;
        line-height: 1;
        cursor: pointer;
      }

      .button .glyph {
        width: 16px;
        height: 16px;
        stroke-width: 2;
      }

      .arc,
      .head {
        stroke-dasharray: 100 200;
        stroke-dashoffset: 100;
      }

      /* Curves sit on the element: Chromium ignores a var() timing function
         inside keyframes and falls back to plain ease. */

      /* Each arc draws tail to head, clockwise — the direction it is about to
         turn — and each arrowhead grows out of the corner its arc arrives at.
         The erase runs the same way, and each stroke fades over the last
         stretch so a dash shrinking to nothing never leaves a cap dot. */
      .arc {
        animation: arc var(--t) var(--ease-in-out) infinite;
      }

      .head {
        animation: head var(--t) var(--ease-out) infinite;
      }

      /* The glyph is symmetric under a half turn, so every rest frame is the
         icon exactly as drawn: it is never caught at an angle that reads as a
         different symbol. That is what lets it stop at all — a continuous spin
         says "busy"; a half turn and a rest says "one more pass". */
      .rotor {
        transform-origin: 12px 12px;
        animation: rotor var(--t) var(--ease-in-out) infinite;
      }

      @keyframes arc {
        0%,
        4% {
          stroke-dashoffset: 100;
          opacity: 1;
        }
        20%,
        82% {
          stroke-dashoffset: 0;
          opacity: 1;
        }
        90% {
          opacity: 1;
        }
        94%,
        100% {
          stroke-dashoffset: -101;
          opacity: 0;
        }
      }

      @keyframes head {
        0%,
        15% {
          stroke-dashoffset: 100;
          opacity: 1;
        }
        24%,
        86% {
          stroke-dashoffset: 0;
          opacity: 1;
        }
        91% {
          opacity: 1;
        }
        94%,
        100% {
          stroke-dashoffset: -101;
          opacity: 0;
        }
      }

      /* ease-in-out: the glyph is already on screen and moving between two
         rests, so it leaves and arrives under control. */
      @keyframes rotor {
        0%,
        26% {
          transform: rotate(0deg);
        }
        42%,
        54% {
          transform: rotate(180deg);
        }
        70%,
        100% {
          transform: rotate(360deg);
        }
      }

      @media (prefers-reduced-motion: reduce) {
        /* The turn goes; the draw and erase stay, slowed, so the icon still
           cycles through "starting" and "done" without anything rotating. */
        .rotor {
          animation: none;
        }

        .arc,
        .head {
          animation-duration: calc(var(--t) * 2);
        }
      }
    </style>
  </head>
  <body>
    <div class="demo">
      <svg
        class="glyph hero"
        viewBox="0 0 24 24"
        role="img"
        aria-label="A sync icon: two arcs draw clockwise and grow arrowheads, then turn a half step at a time with a pause after each"
      >
        <g class="rotor">
          <path
            class="arc"
            pathLength="100"
            d="M3 12 a9 9 0 0 1 9 -9 a9.75 9.75 0 0 1 6.74 2.74 L21 8"
          />
          <path
            class="arc"
            pathLength="100"
            d="M21 12 a9 9 0 0 1 -9 9 a9.75 9.75 0 0 1 -6.74 -2.74 L3 16"
          />
          <path class="head" pathLength="100" d="M21 8 V3" />
          <path class="head" pathLength="100" d="M21 8 H16" />
          <path class="head" pathLength="100" d="M3 16 V21" />
          <path class="head" pathLength="100" d="M3 16 H8" />
        </g>
      </svg>

      <button class="button" type="button">
        <svg class="glyph" viewBox="0 0 24 24" aria-hidden="true">
          <g class="rotor">
            <path
              class="arc"
              pathLength="100"
              d="M3 12 a9 9 0 0 1 9 -9 a9.75 9.75 0 0 1 6.74 2.74 L21 8"
            />
            <path
              class="arc"
              pathLength="100"
              d="M21 12 a9 9 0 0 1 -9 9 a9.75 9.75 0 0 1 -6.74 -2.74 L3 16"
            />
            <path class="head" pathLength="100" d="M21 8 V3" />
            <path class="head" pathLength="100" d="M21 8 H16" />
            <path class="head" pathLength="100" d="M3 16 V21" />
            <path class="head" pathLength="100" d="M3 16 H8" />
          </g>
        </svg>
        Syncing
      </button>
    </div>
  </body>
</html>

The variant family

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