Skip to content
Back

Verb cycler

The verb that says what the agent is doing, rotating through a verb pack while it works and settling into the past tense when it finishes.

oxyn add verb-cycler
MCP
Thinking
Dioxus
rsx! {
    VerbCycler {
        state: agent.state(),
        now: clock.now(),
        pack: "coder",
        seed: run_id_hash // same run, same verb order,
        size: 18.0,
    }
}

Rendered from Rust at build time · goes live when visible

When to use

  • During a long turn the status word is the only thing that changes.
  • If it never changes the app looks frozen; if it changes too often it is noise; if it changes to a cute word while a real tool is running it hides information.
  • Claude Code picks a random verb from a large list and ends with a past-tense line ("Cooked for 1m 23s"); Codex shows a model-written header instead of a fixed verb; Cursor shows "Planning next moves" and "Taking longer than expected"; Zed types its label in; Arc 12); Pitus rolls "Thinking 13s" to "Thought for 14s" [R021].
  • The cycler unifies these:

When not to use

  • A label with light passing over it while the agent works: use Text shimmer instead.
  • How long the agent has worked, without the time it spent waiting for you: use Elapsed timer instead.
  • An agent asks before it acts: use Approval Card instead.

Installation

Verb cycler is free and MIT. The oxyn CLI copies its code, and the components it needs, into src/oxyn/ of your Dioxus or GPUI project, so it is yours to change.

Terminal
cargo install --git https://github.com/ismailqureshi72/Oxyn oxyn-cli
oxyn init
oxyn add verb-cycler
Rust
use crate::oxyn::{VerbCycler, STATUS_TEXT_CSS};

Rather depend on the crate? cargo add oxyn-dioxus oxyn-core --git https://github.com/ismailqureshi72/Oxyn, then use oxyn_dioxus::{VerbCycler, STATUS_TEXT_CSS};

Usage

Dioxus · rust
rsx! {
    VerbCycler {
        state: agent.state(),
        now: clock.now(),
        pack: "coder",
        seed: run_id_hash // same run, same verb order,
        size: 18.0,
    }
}

Examples

Fade

Crossfade between verbs.

Thinking
Code
rsx! {
    VerbCycler {
        state: agent.state(),
        now: clock.now(),
        pack: "coder",
        seed: run_id_hash // same run, same verb order,
        size: 18.0,
    }
}

Slide

Verbs slide up.

Thinking
Code
rsx! {
    VerbCycler {
        state: agent.state(),
        now: clock.now(),
        variant: "slide",
        pack: "coder",
        seed: run_id_hash // same run, same verb order,
        size: 18.0,
    }
}

Blur swap

Blur out, blur in.

Thinking
Code
rsx! {
    VerbCycler {
        state: agent.state(),
        now: clock.now(),
        variant: "blur-swap",
        seed: run_id_hash // same run, same verb order,
        size: 18.0,
    }
}

Ellipsis

Terse with growing dots.

Think
Code
rsx! {
    VerbCycler {
        state: agent.state(),
        now: clock.now(),
        variant: "ellipsis",
        pack: "terse",
        seed: run_id_hash // same run, same verb order,
        size: 18.0,
    }
}

API reference

VerbCycler

PropTypeDefaultDescription
staterequiredAgentState—The agent state.
nowrequiredClockMs—Shared clock time.
variantString"fade"`fade` · `slide` · `blur-swap` · `ellipsis` · `static`.
packString"neutral"Built-in pack id.
seedu64Default::default()Shuffle seed (hash of the run id).
sizef3213.0Font size in px.
reducedboolDefault::default()Reduced motion: 80 ms crossfades, dwell ×2.

Read from the Rust signature and doc comments.

Keyboard interactions

KeyAction
—Not focusable

Accessibility

  • Flavour verbs are never announced; only activity changes reach the live region.
  • Noise glyphs and peeks are aria-hidden; reduced uses 80 ms crossfades and doubles the dwell.
From the spec
  • Accessible name = the incoming verb from the first frame of a swap; noise glyphs, peeks, flaps and dots are aria-hidden.
  • Flavour verbs are never announced. Only activity changes (pinned tool verbs lasting ≥ 2 s, "Waiting for you", completion, interruption, failure) reach the live region, at most one polite message per 10 s (family throttle, status-text.md §11). Waiting and failure are assertive.
  • Reduced motion: 80 ms crossfades, dwell × 2, no marquee, no glitch.
  • Flashing: glitch-rgb runs at most once per swap; swaps are ≥ 2.8 s apart, well under 3/s.
  • Contrast: every frame of a transition keeps ≥ 4.5:1 for the *settled* glyphs; in-flight glyphs may dip during ≤ 200 ms fades (they are not the readable state). stack-peek text is decorative.
  • Users can turn flavour cycling off (cycle = false), which apps should expose as "Show playful status words".

Motion & interaction

  • Swap. Outgoing and incoming verbs are measured before the swap; the slot width follows with spring.snap (status-text.md §2.2). Any shimmer drops out for the swap and restarts after its delay.
  • Pin. Pinning uses the same transition as cycling, but the *target* (file name, query) slides in 80 ms after the verb so the eye reads verb then object.
  • Re-pin to the same verb with a new target ("Reading a.rs" → "Reading b.rs") only swaps the target (fade 120 ms); the verb stays put.
  • Unpin. After pin_min, back to the flavour cycle with a fresh dwell; if the run is still in a tool chain, the next pin usually arrives first — no flavour verb is squeezed in under 1200 ms.
  • Past-tense completion. The present verb rolls to past using the variant's transition, capped at dur.tense.roll 240 ms (scramble / split-flap capped at 400 ms). Shared text (the target, "for") stays still; only the changed part moves (morph of the common suffix/prefix). Duration digits are frozen at the completion event, then appear with the elapsed-timer's summary style.
  • Failure. No playful transition: 120 ms crossfade to "Ran cargo test · 3 failed" in tone.danger.
  • Interrupt. The cycler stops mid-swap if needed (incoming text wins, 80 ms) and settles on "Interrupted after 42s"; the status strip owns the drop into the transcript.
  • Hover. Tooltip after 500 ms with full verb + target; hover never pauses cycling (it would make the tooltip lie a moment later — the tooltip updates live instead).

Responsive behaviour

  • Verb packs hold a fixed set of verbs per state, so the width it needs is predictable.
Edge cases (spec)
  • RTL. Vertical transitions unchanged; horizontal ones (kinetic-push, ticker-tape, scramble resolve order) follow reading direction. Arabic and other joining scripts: per-glyph transitions (scramble, split-flap, odometer, letter-shuffle, wave-in, cascade-drop) would break joining forms, so they fall back to blur-swap (proposed rule: per-glyph transitions require a non-joining script).
  • CJK. Scramble uses a script-matched noise set (kana for ja; for zh/ko fall back to fade, since random Hanzi/Hangul reads as real words — proposed). Dwell weighting ×1.6 per character.
  • Very long verbs / targets. Pack schema caps verbs at 24 chars; targets middle-truncate; with ReserveLongest the slot is the longest pack verb, and pinned text longer than the slot truncates rather than growing (tooltip has it all).
  • Screen width. Under 320 px or in 16–20 px rows: terse pack, fade only, no targets.
  • 0 s / very fast turns. A turn under 1 s shows only the activity verb and no past-tense line.
  • Tool storms (dozens of 50 ms tools): debounce means none are shown; after 3 s of continuous short tools the line pins "Running tools" (count shown when known) — proposed.
  • Very slow turns. Dwell grows; after 15 s of stall the cycler freezes (status-text decides text).
  • Header and tool at once. Tool pin wins; the header returns when the tool ends (if still current).
  • Pack swap mid-run. Takes effect at the next swap; never interrupts a pin.
  • Font fallback. Noise glyphs not present in the UI font fall back to fade (no tofu boxes).
  • Copy. Copying the line yields the current settled text, never noise characters.

Notes for AI

  • Import VerbCycler from oxyn_dioxus and include STATUS_TEXT_CSS plus the token stylesheet once.
  • A GPUI version exists: VerbCyclerEl in oxyn_gpui.
  • Props to set first: state, now.
  • It reads a clock (now) for live timers; pass one clock for the whole page rather than one per component.
  • Keep its states and timings as they ship; restyle it through the CSS variables rather than by hand.

Guides

Oxyn · 74 free components · 264 Pro components · 96 screens · 20 blocks · Dioxus and GPUI