Free & open source, built for every frontend stack. Star Exhuma on GitHub
ExhumaBeta
DocsComponentsBlog

Getting Started

  • Introduction
  • Installation
  • Theming & Dark Mode
  • CLI Reference

Architecture

  • Kinetic Methodology
  • Ecosystem Contracts
  • Lifecycle & Memory Safety

Components

  • All Components20
Cards8
  • Stacking Cards
  • Horizontal Scroller
  • Tilt Card
  • Spotlight Card
  • Border Beam
  • Card Swipe Stack
  • Comparison Slider
  • Expandable Card
Layouts6
  • CSS Masonry
  • Row Masonry
  • Auto Grid
  • Infinite Marquee
  • Bento Grid
  • Diamond Grid
Navigation2
  • Morphing Tabs
  • Floating Dock
Primitives4
  • Accordion
  • Number Ticker
  • Magnetic Button
  • Cursor Tooltip
// DOCS·Architecture

The Exhuma Kinetic Methodology (EKM)

Mathematical foundations, algorithmic complexity invariants, and Big-Omega (Ω) lower-bound guarantees across all Exhuma primitives.

  • Ω(120Hz) frame floor
  • O(1) dispatch
  • Ω(1) heap
// 01·Complexity Theory

The Big-Omega (Ω) Lower-Bound Invariant

In computational complexity theory, Ω(g(n)) defines the tight lower bound of a system. Most UI component libraries only describe their best-case scenarios (O), degrading rapidly under high-frequency inputs or on mobile devices.

Exhuma is engineered so that runtime performance, frame rates, memory stability, and state determinism are mathematically guaranteed never to drop below our established lower bounds.

Ω · Frames

Frame Rate Floor

Ω(0Hz)Ω(120Hz)
Frame computation budget ≤ 8.33ms. Never drops a single frame due to main-thread blockage.
Ω · Time

Time Complexity

Ω(1) = O(1)
Constant-time kinetic dispatch pipeline directly mutating CSS variables via rAF. Zero DOM tree traversals.
Ω · Memory

Memory Invariant

Ω(1) Heap
Zero dynamic allocations in motion loops. Static circular ring buffers eliminate Garbage Collection pauses.
// 02·Architecture

The 5 EKM Architectural Pillars

Every component in Exhuma adheres to these 5 architectural pillars, ensuring uniform developer experience and bulletproof quality across all 13 ecosystems.

Pillar 01

Decoupled Mathematical Kernels

All physics, coordinate normalization, and layout math are isolated into pure TypeScript functions with zero framework dependencies.
Pillar 02

Kinetic Compound Composition

Radix-style composable slots (Root, Trigger, Content) paired with independent hardware-accelerated Indicator primitives.
Pillar 03

Dual-Channel State Separation

High-frequency 120Hz continuous inputs bypass virtual DOM reconciliation entirely, writing directly to element style variables.
Pillar 04

Deterministic 5-State Gesture FSM

Formally complete automaton with slop-angle trajectory filtering to guarantee zero mobile page scroll hijacking.
Pillar 05

Universal Cross-Ecosystem Parity Contract

Zero external animation runtimes. Identical behavioral contracts compiled to React, Next.js 15, Vue 3 / Nuxt, Svelte 5 / SvelteKit, Angular 18+ Standalone, SolidJS, Astro, Laravel Blade, Vanilla JS & Scoped CSS, WordPress Gutenberg Block, Universal Web Component, React Native / Expo, and Flutter / Dart.
// 03·State

Dual-Channel State Pipeline

Why do standard React animation libraries stutter? Because they pass mouse coordinates through React state (setState), triggering 120 virtual DOM diffs per second. Exhuma strictly bifurcates state into two isolated channels:

DualChannelPipeline.tsx
tsx
// EXHUMA DUAL-CHANNEL STATE PATTERN
// Channel 1: Kinetic GPU Channel (Continuous 120Hz — Zero Re-renders)
const handlePointerMove = (e: React.PointerEvent) => {
  const coords = calculateSpotlightCoordinates(e.clientX, e.clientY, rect);
  targetX.current = coords.x;
  targetY.current = coords.y;

  // Directly writes to GPU custom properties on requestAnimationFrame
  el.style.setProperty('--exhuma-spotlight-x', `${coords.x}px`);
};

// Channel 2: Discrete Logical Channel (On Action Only)
const handleSelectTab = (tabId: string) => {
  setActiveTab(tabId); // Standard controlled/uncontrolled state
  onValueChange?.(tabId);
};
// 04·Gestures

Deterministic 5-State Gesture FSM

Mobile touch interactions fail when horizontal gestures fight native vertical page scroll. Exhuma implements a provably complete automaton with an angular slop filter:

gesture-fsm.ts
5 STATES
  1. IDLE──(PointerDown)──►TRACKING
  2. TRACKING──(Angle < 30° & Δ > 8px)──►CLAIMED (Capture Touch)
  3. TRACKING──(Angle ≥ 30°)──►IDLE (Yield to Page Scroll)
  4. CLAIMED──(PointerUp)──►DECELERATING
  5. DECELERATING──(v → 0)──►IDLE
// 05·Physics

Closed-Form Analytical Spring Physics

Euler numerical integration approximations accumulate floating-point error over time. Exhuma uses the exact closed-form solution to the second-order differential equation for critical damping (ζ = 1.0):

x(t) = xtarget + (x0 − xtarget) · e−ωnt · (1 + ωnt)
Critical damping · ζ = 1.0closed-form, no numerical integration

This provides instantaneous position calculation with provable asymptotic convergence, zero oscillation, and zero external physics libraries.

CLI ReferenceEcosystem Contracts
On This Page
The Big-Omega (Ω) InvariantThe 5 EKM Architectural PillarsDual-Channel State PipelineDeterministic 5-State Gesture FSMClosed-Form Analytical Springs