thinking-orbs: The Spinner Library That Learned to Think
A tiny Canvas 2D engine turns AI status into semantic motion, with states for searching, solving, composing, and more.

Dotted thought-orb loading indicators for AI & agent UIs — six tuned states, two sizes, auto dark/light
- thinking-orbs matters because it turns AI status into a design language, not a generic waiting state.
- Its core trick is semantic motion, where different presets read as searching, solving, composing, listening, or shaping.
- The library gets its richness from plain Canvas 2D math, not WebGL or heavyweight filters.
- The polish is what makes it production-ready: tuned sizes, theme awareness, reduced motion, and off-screen pausing.
A spinner tells you time is passing. An AI interface needs to tell you what the system is doing. That is the real shift in thinking-orbs: it treats loading as a vocabulary of intent.
That sounds subtle until you build an agent UI. Then the distinction becomes obvious. A user can live with "waiting". They cannot live with ambiguity about whether the model is searching, composing, or just stuck.
Why AI UIs Need More Than Spinners
Traditional loaders are good at one job. They soften the awkwardness of latency. They do not explain process, confidence, or phase. In agentic products, that gap matters because the interface is no longer waiting for a page. It is narrating work.
That README line is the whole pitch. The project is not trying to out-spinner spinners. It is building a status language for systems that think in steps.
| Pattern | What it says | How it feels | Trade-off |
|---|---|---|---|
| Generic spinner | Wait | Neutral and vague | No semantic signal |
| Orbiting circles | Something is moving | Stylish but abstract | Often still just decoration |
| thinking-orbs | This agent is searching or solving | Specific and legible | Requires more design intent |
The Orb Is a Status Language, Not a Decoration
The clever part is that the library ships distinct states instead of one endlessly looping animation. working, searching, solving, listening, composing, and shaping are not palette swaps. They are behavioral cues.
That matters because users do not read motion as pure style. They read it as evidence. A calm, stable orbit suggests active scanning. A tightening form suggests convergence. A morphing shape suggests transformation, not delay.
<ThinkingOrb state="searching" size={64} />
<ThinkingOrb state="solving" size={20} />
<ThinkingOrb state="composing" dark />
The Math That Makes It Feel Physical
Under the hood, the project uses a plain 2D Canvas engine to fake a lot of depth. That choice keeps the implementation portable and predictable. It also means the visual system can run in small inline sizes without dragging in WebGL or filter-heavy SVG effects.
The geometry is deterministic. That matters more than it sounds. Stable dot placement means the orb does not flicker or reshuffle itself every time it mounts. The result feels designed, not generated.
The hidden mechanics
The engine sorts points by depth, projects 3D coordinates onto a 2D plane, and changes dot size and ink weight based on distance. In practical terms, that means the orb can read as a volume even though it is drawn with the simplest rendering primitive in the browser.
That same engine also supports morphing states. In shaping, the dots are redistributed along blended paths so the transition stays visually even. Nothing bunches up. Nothing stretches awkwardly. The motion stays coherent while the form changes.
Why 2D Canvas Was the Right Bet
This is where the project feels opinionated in a good way. A heavier stack might have made the same visuals possible, but not necessarily better. Canvas 2D gives the library a narrow footprint, consistent output, and fewer browser-specific surprises.
It also fits the use case. These orbs are not stage effects. They are interface elements. That means the rendering system has to respect layout, battery life, and the rest of the app around it.
| Implementation | Strength | Weakness | Where it fits |
|---|---|---|---|
| Canvas 2D | Lightweight and consistent | Less flashy than a full 3D stack | Inline AI status and small UI surfaces |
| SVG filters | Easy to compose with DOM | Can get expensive and browser-sensitive | Simple motion effects |
| WebGL | Deep visual control | Heavier and more complex | Large scenic animations |
The Hidden Polish That Makes It Feel Production-Ready
The boring details are the ones that make this library usable. It respects reduced motion. It detects theme context. It pauses when off-screen. It uses a shared clock so multiple orbs stay in sync. Those are not extras. They are the difference between a demo and a component you can ship.
The sizing strategy is especially telling. The 64px version and the 20px version are not just scaled copies. They are separate design targets. That is a product decision, not an implementation accident.

Six hand-tuned animated states, each shipped at two purpose-tuned sizes, rendered on a plain 2D canvas — no WebGL, no filters, works identically in Chrome, Safari and Firefox.
Why It Stands Out From Other Orb and Loader Libraries
Most alternatives win on versatility or sheer motion polish. Orbiting Circles gives you a clean pattern. Multi-step loaders explain progress. Siri-style orbs chase a familiar aesthetic. thinking-orbs narrows the goal: make AI status legible.
| Library type | Primary strength | What it lacks |
|---|---|---|
| Generic loaders | Simple and universal | No semantic depth |
| Orbiting-circle patterns | Visually attractive | Usually one motion language |
| Multi-step loaders | Clear progress narrative | Less fluid as a living status symbol |
| thinking-orbs | Semantic motion for agent states | Less useful for non-AI use cases |
That is why it feels interesting. It is not competing on novelty for its own sake. It is competing on meaning per pixel.
The New UI Primitive for Agentic Products
The larger lesson is bigger than one library. AI interfaces need more than spinners, skeletons, and progress bars. They need visual grammar for phase, intent, and confidence. thinking-orbs is one of the cleaner attempts to codify that grammar.
If the next wave of products keeps blurring the line between software and ongoing work, then status indicators will have to grow up too. This repo is a strong prototype for that future.





