RationalTrack animates the entire exercise library from a small set of hand-drawn SVG poses and composable joint-rotation transitions — no per-exercise animation work, no motion-capture, anatomically faithful. It's the kind of thing that usually only exists inside high-budget 3D rigs in motion-capture studios.
View principlesWhat it is
Most exercise apps either show static photos or rely on stock 3D models that don't generalise. We built something different: every starting position is a hand-drawn SVG, and every motion is a named, reusable joint-rotation rule. Apply a "squat-deep" or "bicep-curl-top" or "bent-over hinge" verb to a pose, and the figure animates anatomically — feet planted, bone lengths preserved, joints connected.
The two ingredients
The library is two small artifacts: SVG files for body positions, and a JSON dictionary of named motions. Everything else composes.
Poses
Full-body SVGs, hand-drawn.
Each pose is one Adobe Illustrator file with named groups for every body part and every joint. The SVG is the only source of joint positions and bone lengths — no code synthesises them, ever. Standing, supine, plank, kneeling, seated: a small library covers most of the human movement vocabulary.
Transitions
Named motions you can stack.
Each transition is a JSON entry: how each joint rotates relative to its parent. Apply "hip-hinge-90" to any standing pose and the figure bends forward. Stack "arms-row-pulled" on top of that and you have a bent-over row. Constraints like "feet-planted" make the geometry self-correct: when knees bend, hips drop automatically.
Why it scales
Drawing one new pose unlocks dozens of exercises. Adding one new transition unlocks dozens more. The library grows multiplicatively against the exercise catalogue, not one-to-one.
10 poses
Cover ~95% of bodies in motion.
Standing, supine, plank, kneeling, seated, inclined, bent-over. Mirror for left/right when needed. That's the whole starting-position vocabulary.
~30 transitions
Cover ~95% of motions.
Squat, hinge, lunge, curl, press, row, pull, push, twist, lean, raise. Each one parameterised by depth or side or direction.
Thousands of exercises
Composed automatically.
A bent-over row is "erect-right-side + hinge-90 + arms-row-pulled". A squat-press is "erect + squat-deep + arms-overhead". Bicep curl, pulldown, deadlift — all composed, none custom-animated.
What's actually different
The bug everyone else makes is letting code invent body positions. Bones get stretched, joints float, knees bend backwards. Ours keeps the SVG as ground truth and refuses to deviate.
Anatomically faithful
Bone lengths come from the drawn figure and never change. Joints stay connected. Forward kinematics + a small set of physical constraints (feet planted, hips below shoulders) keeps every result anatomically valid.
No motion capture
No 3D rig, no actor in a suit. The art investment is one Illustrator file per body position — total maybe a day of drawing for the entire library. Updates roll out in minutes.
No per-exercise animation
A new exercise enters the library by referencing a pose and a transition combo — one row in a CSV or one GPT call. From thought to animation: seconds, not hours.
Style-consistent
Every figure shares the same hand-drawn aesthetic because they share the same source SVG. No mismatched art styles or sizes across the library.
Iterable in real time
Edit the SVG in Illustrator, save, regenerate — every exercise that uses that pose updates instantly. Adjust a transition's joint angles and watch hundreds of exercises change at once.
Pure SVG output
Each frame is a small SVG document. Sharp at any zoom, themeable via CSS, accessible to screen readers, tiny on the wire. Renders identically on every device.
The pipeline
A single Node script reads every pose SVG and emits a deterministic spec. A small PHP service applies transitions kinematically. GPT picks the right transitions per exercise. The DB stores the result as keyframes the renderer streams.
1. Draw
SVG in Illustrator.
Named groups for every body part and joint. Save with layer-name IDs.
2. Extract
Build script reads.
npm run gen:poses extracts every joint position and silhouette path into a single deterministic spec module.
3. Compose
Apply transitions.
For each exercise, GPT picks transitions; the server applies them via forward kinematics and writes the resulting keyframes.
4. Render
Tween in the browser.
A small JS runtime tweens between keyframes, applies pose-specific silhouettes, ships under 20 KB. Sharp on every screen.
What it enables
The exercise library isn't a finite set of pre-rendered videos that ship and freeze. It's a generative system: new exercises arrive as text descriptions, get classified against the pose library, get transition combos picked by an LLM, and animate within seconds. Edit any of the inputs (pose drawings, transition angles, classification rules) and every animation updates. The result is a corpus that's plain to maintain, cheap to grow, anatomically defensible, and visually consistent — properties that don't usually coexist.
Free to sign up, no credit card required. Tracking, challenges, activities are all free to use (without AI interaction).