mobile-touch
dylantarre/animation-principles
Apply Disney's 12 animation principles to iOS/Android gestures, haptics, and native mobile motion.
What is mobile-touch?
Master mobile touch interactions by applying classic animation principles to gestures, haptic feedback, and native app transitions. Use this when designing iOS/Android animations, touch responses, and gesture-driven motion that feels natural and responsive.
- Map Disney's 12 animation principles to mobile gesture implementations (squash & stretch, anticipation, staging, follow-through, timing, arc, etc.)
- Implement platform-specific spring physics and easing curves for iOS and Android
- Pair haptic feedback with visual responses for secondary actions
- Apply timing guidelines: <100ms touch acknowledgment, 250-350ms transitions, 60fps minimum
- Design gesture-driven animations (drag, pinch, swipe) vs preset transitions (push, present)
- Respect safe areas, notches, and dynamic islands in motion paths
How to install mobile-touch
npx skills add https://github.com/dylantarre/animation-principles --skill mobile-touchHow to use mobile-touch
- 1.Review the 12 animation principles table to understand mobile implementations
- 2.Select the principle(s) relevant to your interaction (e.g., arc for swipe-to-dismiss)
- 3.Check platform patterns for iOS (UIView spring animations) or Android (SpringAnimation)
- 4.Apply timing guidelines: ensure touch response <100ms, transitions 250-350ms
- 5.Pair haptic feedback with visual feedback using the haptic guidelines table
- 6.Test at 60fps minimum (120fps on ProMotion displays) and ensure gesture continuity
Use cases
- Designing pull-to-refresh with rubber-banding and stretch feedback
- Creating swipe-to-dismiss animations with parabolic arcs and momentum
- Building long-press preview interactions with anticipation staging
- Implementing button compression and touch feedback with haptic pairing
- Designing modal sheet presentations that maintain context with hero transitions
- iOS/Android app developers
- Mobile UI/UX designers
- Animation engineers
- Native app developers implementing gesture interactions
- Teams building high-fidelity mobile experiences
mobile-touch FAQ
Gesture-driven animations (drag, pinch) follow touch input directly in real-time (straight ahead). Preset transitions (push, present) use predefined keyframes (pose to pose). Gesture animations must feel connected to the finger; preset transitions can use easing curves.
Touch acknowledgment should occur <100ms. Quick actions take 150-250ms. View transitions take 250-350ms. Complex animations take 350-500ms. Haptic feedback must sync precisely with visual feedback.
Spring physics work well for iOS and Android Material animations, but never use linear easing for user-initiated motion. iOS uses spring with configurable mass/stiffness/damping; Android uses FastOutSlowIn easing.
Haptics are secondary actions—always pair with visual confirmation. Use the haptic guidelines table to match action type (selection, success, warning, error) to the appropriate haptic style on each platform.
Minimum 60fps, but target 120fps on ProMotion displays. Gesture-driven animations must maintain high frame rates to feel responsive and connected to touch input.
Full instructions (SKILL.md)
Source of truth, from dylantarre/animation-principles.
name: mobile-touch description: Use when designing iOS/Android gestures, haptic feedback, touch interactions, or native mobile animations.
Mobile Touch Animation
Apply Disney's 12 animation principles to mobile gestures, haptics, and native app motion.
Quick Reference
| Principle | Mobile Implementation |
|---|---|
| Squash & Stretch | Rubber-banding, bounce on scroll limits |
| Anticipation | Peek before reveal, long-press preview |
| Staging | Sheet presentations, focus states |
| Straight Ahead / Pose to Pose | Gesture-driven vs preset transitions |
| Follow Through / Overlapping | Momentum scrolling, trailing elements |
| Slow In / Slow Out | iOS spring animations, Material easing |
| Arc | Swipe-to-dismiss curves, card throws |
| Secondary Action | Haptic pulse with visual feedback |
| Timing | Touch response <100ms, transitions 250-350ms |
| Exaggeration | Bounce amplitude, haptic intensity |
| Solid Drawing | Respect safe areas, consistent anchors |
| Appeal | 60fps minimum, gesture continuity |
Principle Applications
Squash & Stretch: Implement rubber-band effect at scroll boundaries. Pull-to-refresh should stretch content naturally. Buttons compress on touch.
Anticipation: Long-press shows preview before full action. Drag threshold provides visual hint before item lifts. Swipe shows edge of destination content.
Staging: Use sheet presentations to maintain context. Dim and scale background during modal focus. Hero transitions connect views meaningfully.
Straight Ahead vs Pose to Pose: Gesture-following animations (drag, pinch) are straight ahead—driven by touch input. System transitions (push, present) are pose to pose—predefined keyframes.
Follow Through & Overlapping: Content continues moving after finger lifts (momentum). Navigation bar elements animate slightly after main content. Lists items settle with stagger.
Slow In / Slow Out: iOS uses spring physics—configure mass, stiffness, damping. Android Material uses standard easing: FastOutSlowIn. Never use linear for user-initiated motion.
Arc: Thrown cards follow parabolic arcs. Swipe-to-dismiss curves based on velocity vector. FAB expand/collapse follows natural arc path.
Secondary Action: Pair haptic feedback with visual response. Button ripple accompanies press. Success checkmark triggers light haptic.
Timing: Touch acknowledgment: <100ms. Quick actions: 150-250ms. View transitions: 250-350ms. Complex animations: 350-500ms. Haptic should sync precisely with visual.
Exaggeration: Pull-to-refresh stretches beyond natural—makes feedback clear. Error shake is pronounced. Success animations celebrate appropriately.
Solid Drawing: Respect device safe areas during animation. Maintain consistent transform origins. Account for notch/dynamic island in motion paths.
Appeal: Minimum 60fps, target 120fps on ProMotion displays. Gesture-driven animation must feel connected to finger. Interruptible animations essential.
Platform Patterns
iOS
// Spring animation with follow-through
UIView.animate(withDuration: 0.5,
delay: 0,
usingSpringWithDamping: 0.7,
initialSpringVelocity: 0.5,
options: .curveEaseOut)
// Haptic pairing
let feedback = UIImpactFeedbackGenerator(style: .medium)
feedback.impactOccurred()
Android
// Material spring animation
SpringAnimation(view, DynamicAnimation.TRANSLATION_Y)
.setSpring(SpringForce()
.setStiffness(SpringForce.STIFFNESS_MEDIUM)
.setDampingRatio(SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY))
.start()
Haptic Guidelines
| Action | iOS | Android |
|---|---|---|
| Selection | .selection | EFFECT_TICK |
| Success | .success | EFFECT_CLICK |
| Warning | .warning | EFFECT_DOUBLE_CLICK |
| Error | .error | EFFECT_HEAVY_CLICK |
Haptics are secondary action—always pair with visual confirmation.
Related skills
More from dylantarre/animation-principles and the wider catalog.

motion-designer
Use when designing visual motion systems, creating animation specifications, or when a designer needs guidance on crafting beautiful, meaningful movement.

video-motion-graphics
Use when creating After Effects compositions, Premiere Pro motion, video titles, explainer videos, or broadcast motion graphics.

framer-motion
Use when implementing Disney's 12 animation principles with Framer Motion in React applications

micro-interactions
Use when designing small UI feedback moments like button states, toggles, form validation, loading indicators, or notification badges.

dt-app-dashboards
Work with Dynatrace dashboards - create, modify, query, and analyze dashboard JSON including tiles, layouts, DQL queries, variables, and visualizations.

dt-app-notebooks
Work with Dynatrace notebooks - create, modify, query, and analyze notebook JSON including sections, DQL queries, and visualizations.