home / skills / dylantarre / animation-principles / data-visualization

This skill applies Disney's animation principles to data visualizations, improving clarity and engagement through motion across charts and dashboards.

npx playbooks add skill dylantarre/animation-principles --skill data-visualization

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
4.2 KB
---
name: data-visualization
description: Use when animating charts, graphs, dashboards, data transitions, or any information visualization work.
---

# Data Visualization Animation

Apply Disney's 12 animation principles to charts, graphs, dashboards, and information displays.

## Quick Reference

| Principle | Data Viz Implementation |
|-----------|------------------------|
| Squash & Stretch | Bar overshoot, elastic settling |
| Anticipation | Brief pause before data loads |
| Staging | Sequential reveal, focus hierarchy |
| Straight Ahead / Pose to Pose | Streaming vs snapshot data |
| Follow Through / Overlapping | Staggered element entry |
| Slow In / Slow Out | Smooth value interpolation |
| Arc | Pie chart sweeps, flow diagrams |
| Secondary Action | Labels following data points |
| Timing | Entry 300-500ms, updates 200-300ms |
| Exaggeration | Emphasize significant changes |
| Solid Drawing | Consistent scales, clear relationships |
| Appeal | Satisfying reveals, professional polish |

## Principle Applications

**Squash & Stretch**: Bars can overshoot target height then settle. Pie slices expand slightly on hover. Bubbles compress on collision. Keep total values accurate—animation is transitional.

**Anticipation**: Brief loading state before data appears. Slight shrink before expansion. Counter briefly pauses before rapid counting. Prepares user for incoming information.

**Staging**: Reveal data in meaningful sequence—most important first. Highlight active data series. Dim unrelated elements during focus. Guide the data story with motion.

**Straight Ahead vs Pose to Pose**: Real-time streaming data animates continuously (straight ahead). Dashboard snapshots transition between states (pose to pose). Match approach to data nature.

**Follow Through & Overlapping**: Data points enter with staggered timing. Labels settle after their data elements. Grid lines appear before data. Legends animate with slight delay.

**Slow In / Slow Out**: Value changes ease smoothly—no jarring jumps. Use `d3.easeCubicInOut` or equivalent. Counter animations accelerate then decelerate. Progress bars ease to completion.

**Arc**: Pie charts sweep clockwise from 12 o'clock. Sankey diagram flows follow curved paths. Network graphs use force-directed arcs. Radial charts expand from center.

**Secondary Action**: Tooltips follow data point movement. Value labels count up as bars grow. Axis tick marks respond to scale changes. Shadows indicate data depth.

**Timing**: Initial entry: 300-500ms staggered. Data updates: 200-300ms. Hover states: 100-150ms. Filter transitions: 400-600ms. Slower timing aids comprehension.

**Exaggeration**: Significant changes deserve attention—pulse or glow outliers. Threshold crossings trigger emphasis. Anomalies animate more dramatically. Don't exaggerate the data itself.

**Solid Drawing**: Maintain consistent scales during animation. Transitions shouldn't distort data relationships. Preserve axis alignment. Visual hierarchy must remain clear throughout motion.

**Appeal**: Data entry should feel satisfying. Professional, purposeful motion builds trust. Avoid gratuitous animation—every motion should aid understanding.

## Code Patterns

### D3.js
```javascript
// Staggered bar entry with easing
bars.transition()
    .duration(500)
    .delay((d, i) => i * 50)
    .ease(d3.easeCubicOut)
    .attr("height", d => yScale(d.value))
    .attr("y", d => height - yScale(d.value));

// Smooth data updates
bars.transition()
    .duration(300)
    .ease(d3.easeCubicInOut)
    .attr("height", d => yScale(d.value));
```

### Chart.js
```javascript
// Animation configuration
options: {
    animation: {
        duration: 500,
        easing: 'easeOutQuart',
        delay: (context) => context.dataIndex * 50
    }
}
```

## Data Type Timing

| Visualization | Entry | Update | Hover |
|--------------|-------|--------|-------|
| Bar chart | 400ms stagger | 300ms | 100ms |
| Line chart | 600ms draw | 400ms | 150ms |
| Pie chart | 500ms sweep | 300ms | 100ms |
| Scatter plot | 300ms stagger | 200ms | 100ms |
| Dashboard | 500-800ms cascade | 300ms | 150ms |

## Accessibility Note

Always respect `prefers-reduced-motion`. Data visualization animation should aid comprehension, not hinder it. Provide instant-state fallback for users who disable motion.

Overview

This skill teaches how to apply Disney’s 12 animation principles to charts, graphs, dashboards, and other information visualizations. It focuses on purposeful motion that improves comprehension, highlights change, and adds professional polish without distorting data. Use it to design timing, easing, and sequencing patterns that guide the viewer through a data story.

How this skill works

The skill maps each animation principle to concrete visualization techniques (for example, squash & stretch as bar overshoot, anticipation as brief load pauses, and arc for pie sweeps). It prescribes timing ranges, easing choices, stagger patterns, and accessibility fallbacks so transitions feel natural and informative. Code patterns for D3.js and Chart.js illustrate common implementations and timing guidelines for different chart types.

When to use it

  • Animating initial chart entry to create a clear data reveal
  • Smoothing live or streaming updates without losing context
  • Highlighting significant changes, outliers, or threshold crossings
  • Sequencing complex dashboards to direct user attention
  • Adding subtle motion for hover, tooltip, and label behaviors

Best practices

  • Respect prefers-reduced-motion and offer an instant-state fallback
  • Keep animations truthful: never change underlying data values with motion
  • Use staggered timing and easing (slow in / slow out) to aid comprehension
  • Limit exaggeration to emphasis only and preserve consistent scales
  • Design staging and hierarchy so the most important data appears first

Example use cases

  • Staggered bar chart entry with slight overshoot and settle to dramatize growth
  • Pie chart sweep from 12 o’clock with eased arc motion and hover expansion
  • Streaming line chart using continuous (straight-ahead) motion for live feeds
  • Dashboard cascade where filters and widgets animate in a controlled sequence
  • Tooltip and label follow-through so annotations track moving points smoothly

FAQ

How long should a typical update animation be?

Use 200–300ms for most data updates; initial entries can be 300–500ms with staggered delays.

What easing should I choose?

Prefer cubic easing (easeCubicInOut / easeCubicOut) for natural slow-in/slow-out motion; match easing to change magnitude.

How do I handle users who disable motion?

Detect prefers-reduced-motion and provide immediate state changes or very short transitions to preserve accessibility.