© 2026 Loop · Operator desk for agent skills

SkillsSandboxSettingsFAQPrivacyTerms
LoopLoopLoooop
GitHub

© 2026 Loop · Operator desk for agent skills

SkillsSandboxSettingsFAQPrivacyTerms
LoopLoopLoooop
GitHub
← Back to skills
FrontendUserv14FreePublic

Framer Motion

v17v16v15v14v13

Operational guide for Motion (formerly Framer Motion). Clarifies March 2026 patch releases (12.35–12.38), confirms animateView() is Motion+-gated alpha, and reinforces View Transitions guidance.

LoopLoopVerified8 sources · Updated Apr 19, 2026
Run in sandbox
AutomationActiveDailyNext in 1h8 sources1d ago · v17

Content

Motion (formerly Framer Motion)

Production-ready animation library for React. Motion (published as the motion package) is the default choice for component-level animation: enter/exit transitions, layout shifts, gesture responses, spring physics, and scroll-linked effects. It integrates deeply with React's component model and handles the hard parts — interrupted animations, layout measurement, exit choreography — so you can focus on feel.

Note: The project publishes as Motion (npm package name: motion, docs: motion.dev). The legacy framer-motion package remains available for migration, but prefer the newer motion packages and docs on motion.dev. Import React bindings from motion/react.

When to use

  • Component mount/unmount transitions (modals, toasts, dropdowns, page transitions)
  • Layout animations when elements reorder, resize, or move across containers
  • Hover, tap, drag, and focus micro-interactions
  • Shared element transitions across routes (with layoutId)
  • Spring-based physics for interactive feel (sliders, toggles, cards)
  • Scroll-linked opacity or parallax on individual elements

When NOT to use

  • Scroll-driven pinning, scrubbing, or multi-section choreography — use GSAP + ScrollTrigger
  • Complex multi-surface orchestration (DOM + Canvas + WebGL simultaneously) — use GSAP timelines
  • Non-React projects — Motion is React-first; use Motion's vanilla API or other libraries for other frameworks

© 2026 Loop · Operator desk for agent skills

SkillsSandboxSettingsFAQPrivacyTerms
  • CSS-only hover states where a 2-line transition suffices — do not over-engineer
  • Performance-critical loops rendering thousands of animated items — profile first
  • Core concepts

    motion components

    Wrap any HTML or SVG element with animation superpowers:

    import { motion } from "motion/react";
    
    <motion.div
      initial={{ opacity: 0 }}
      animate={{ opacity: 1 }}
      exit={{ opacity: 0 }}
    />
    

    (Install: npm install motion. Import React bindings from motion/react.)

    Variants

    Named animation states that propagate through component trees — use them for staggered entrances and shared state.

    AnimatePresence

    Animate components as they unmount:

    import { AnimatePresence } from "motion/react";
    
    <AnimatePresence mode="wait">
      {isOpen && (
        <motion.div
          key="modal"
          initial={{ opacity: 0, scale: 0.95 }}
          animate={{ opacity: 1, scale: 1 }}
          exit={{ opacity: 0, scale: 0.95 }}
          transition={{ duration: 0.2 }}
        />
      )}
    </AnimatePresence>
    

    Remember: every direct child of AnimatePresence needs a stable key for exit animations to run.

    Layout animations

    Automatic interpolation when elements change position or size:

    <motion.div layout className={isExpanded ? "w-full" : "w-48"}>
      <motion.p layout="position">Content stays in place</motion.p>
    </motion.div>
    

    Recent March 2026 patch series added controls and fixes for layout projection, color spaces, and scroll-linked timelines. See the Motion changelog (https://motion.dev/changelog) for exact release notes.

    Shared layout with layoutId

    Seamless element transitions across different components:

    {items.map((item) => (
      <motion.div key={item.id} layoutId={item.id} onClick={() => setSelected(item)}>
        {item.title}
      </motion.div>
    ))}
    
    {selected && (
      <motion.div layoutId={selected.id} className="expanded-card">
        {selected.details}
      </motion.div>
    )}
    

    Spring configuration

    Presets are a starting point — tune stiffness, damping, and mass for the interaction.

    <motion.div
      animate={{ x: 100 }}
      transition={{ type: "spring", stiffness: 300, damping: 25, mass: 0.5 }}
    />
    

    Workflow

    1. Identify the animation type: enter/exit, layout shift, gesture response, or scroll-linked. This determines the Motion API to use.
    2. Define variants for reusable states; extract to shared files when repeated.
    3. Wrap conditional unmounts with <AnimatePresence> and ensure children have stable keys.
    4. Tune springs on real devices. Use skipInitialAnimation (added in 12.36.0) for cases where you don't want the initial mount to animate.
    5. Add reduced-motion fallbacks (useReducedMotion).

    Changelog highlights (selected March 2026 patches)

    (Authoritative source: Motion changelog — https://motion.dev/changelog)

    • Motion 12.35.0 — 2026-03-03: Added ViewTimeline support for scroll and useScroll.
    • Motion 12.35.1 / 12.35.2 — 2026-03-06 to 2026-03-09: Multiple fixes (Strict Mode, WAAPI final-style commits, percent-translate handling, layout rounding, reduced filesize fixes).
    • Motion 12.36.0 — 2026-03-09: Added axis-locked layout animations with layout="x" and layout="y", and added skipInitialAnimation to useSpring.
    • Motion 12.37.0 — 2026-03-16: Color-space support (oklch, oklab, lch, lab, color-mix, light/dark color types); memory and layout improvements; fixes for draggable elements and whileInView with client-side navigation.
    • Motion 12.38.0 — 2026-03-16: Added layoutAnchor for custom projection anchors; Reorder and AnimatePresence fixes for re-ordering/virtualized lists and exit clean-up.

    Upgrade guidance: If you depend on layout projection behavior, virtualized lists, or WAAPI final-style commits, upgrade to the March 2026 patch series. See https://motion.dev/changelog for full notes.

    View Transitions and animateView

    • Browser-native View Transitions (document.startViewTransition) continue to evolve. Chrome (developer blog) added element-scoped and nested view transitions in Chrome 147, improving nested/concurrent transitions.

    • Motion exposes animateView() — a convenience wrapper built on the View Transition API that adds spring easing, interruption handling, and shared-element helpers. Motion's docs state that animateView() is currently in alpha and gated to Motion+ members (early access). See https://motion.dev/docs/animate-view for details.

    Patterns and guidance:

    • Feature-detect: if (document.startViewTransition) { /* prefer native or animateView */ }
    • For large route-level transitions, prefer the native View Transition API where available — the browser can perform large layout swaps efficiently.
    • Use Motion's animateView() only if you have Motion+ access and need Motion's additional helpers; it is early-access and gated.
    • For component-level, gesture-driven, or highly interactive shared-element transitions, keep using layoutId and Motion's layout projection — the native API does not yet replace fine-grained interactive control.

    Example (native fallback):

    if (document.startViewTransition) {
      document.startViewTransition(() => {
        navigate('/photo/42');
      });
    } else {
      // Fall back to Motion-based route animation
    }
    

    Important: Motion's animateView() is an early-access API behind Motion+; gate usage on feature detection and project access.

    Decision tree

    • Component enter/exit? → AnimatePresence + initial/animate/exit
    • List with staggered items? → Variants with staggerChildren
    • Element changes position/size? → layout prop (use layout="x"/"y" to lock axis when appropriate)
    • Shared element across views? → layoutId
    • Hover/tap/drag interaction? → Gesture props (whileHover, whileTap, whileDrag)
    • Route or full-page transition and browser supports View Transitions? → Prefer native View Transitions or Motion's animateView() (Motion+ alpha); fallback to Motion when native support is absent or you need nested/interactive control
    • Scroll-driven pinning or scrubbing? → NOT Motion — use GSAP ScrollTrigger

    Edge cases and gotchas

    1. Import path — Motion is published as the motion package. Import React bindings from motion/react (recommended). The legacy framer-motion package remains available but is not the recommended entry point for new projects. (See README: https://github.com/motiondivision/motion)

    2. AnimatePresence requires keys — every direct child of AnimatePresence must have a unique key prop, or exit animations will not trigger.

    3. layout + border-radius — layout animation can distort border-radius during interpolation. Use layout="position" if only position should animate.

    4. Exit animations and React Strict Mode — Motion addressed many Strict Mode issues in the March 2026 patch series; test exit behavior in production builds and upgrade to the latest patch if you observe Strict Mode-only glitches (see changelog).

    5. Spring oscillation — low damping values cause visible oscillation. For UI elements that should land cleanly, keep damping above ~15.

    6. Server-side rendering — Motion components render their initial state on the server. Ensure initial values produce a usable static layout.

    7. animateView / View Transitions — native View Transitions can be more efficient for large route-level changes. Chrome 147 added element-scoped and nested view transitions which improve native capabilities. Motion's animateView() wraps the browser API and adds features, but it is alpha and Motion+-gated — don't assume it is available in all projects.

    8. Performance: The March 2026 patch series included memory, WAAPI, and layout improvements. If you rely heavily on layout animations, upgrade to the latest March 2026 patches (see https://motion.dev/changelog).

    Examples

    (Examples preserved — copy-pasteable code.)

    Example 1 — Staggered list entrance

    const listVariants = {
      hidden: {},
      visible: { transition: { staggerChildren: 0.06 } },
    };
    
    const itemVariants = {
      hidden: { opacity: 0, x: -12 },
      visible: { opacity: 1, x: 0, transition: { type: "spring", stiffness: 200, damping: 20 } },
    };
    
    function FeatureList({ features }: { features: string[] }) {
      return (
        <motion.ul variants={listVariants} initial="hidden" animate="visible">
          {features.map((f) => (
            <motion.li key={f} variants={itemVariants}>{f}</motion.li>
          ))}
        </motion.ul>
      );
    }
    

    Example 2 — Gesture-driven card

    <motion.div
      whileHover={{ scale: 1.02, boxShadow: "0 8px 24px rgba(0,0,0,0.12)" }}
      whileTap={{ scale: 0.98 }}
      transition={{ type: "spring", stiffness: 300, damping: 25 }}
      className="cursor-pointer rounded-card bg-surface-elevated p-space-lg"
    >
      <h3>Interactive card</h3>
    </motion.div>
    

    Example 3 — Page route transition

    When the browser supports the View Transitions API, prefer it for full route/page transitions because the browser can perform large, concurrent layout changes more cheaply. For component-level shared-element transitions or interactive gestures, keep using Motion's layoutId and layout projection.

    if (document.startViewTransition) {
      document.startViewTransition(() => {
        // perform navigation or DOM swap
        navigate('/photo/42');
      });
    } else {
      // fallback to Motion-based route animation
    }
    

    Evaluation checklist

    • Import from "motion/react" (recommended)
    • useReducedMotion() checked and fallbacks provided
    • Exit animations wrapped in <AnimatePresence> with keys
    • Spring configs are tuned to match the interaction feel
    • Enter animations are split into semantic chunks with stagger
    • Exit animations are subtler than enter animations
    • No competing animations on the same element
    • Layout animations use layout="position" when only position should change
    • Gesture interactions have visible hover/press feedback

    Research references

    • Motion docs (overview): https://motion.dev/docs — confirms install/import path and docs.
    • animateView() docs (alpha, Motion+): https://motion.dev/docs/animate-view — notes animateView() is alpha and exclusive to Motion+ members.
    • Motion changelog (Mar 3–Mar 16, 2026): https://motion.dev/changelog — authoritative list of 12.35.0 → 12.38.0 patch entries (ViewTimeline/useScroll, axis-locked layouts, skipInitialAnimation, color-space support, layoutAnchor, Strict Mode and memory fixes).
    • GitHub repository and README: https://github.com/motiondivision/motion — confirms package name and usage examples (npm install motion, import { motion } from "motion/react").
    • Chrome Developer Blog: Chrome 147 element-scoped view transitions (Mar 27, 2026): https://developer.chrome.com/blog/element-scoped-view-transitions

    Summary

    Practical, copy-pasteable guidance for Motion (formerly Framer Motion): install, import path, layout controls, March 2026 patch notes (12.35–12.38), and View Transitions / Motion+ animateView guidance.

    Activity

    ActiveDaily · 9:00 AM8 sources

    Automation & run history

    Automation status and run history. Only the owner can trigger runs or edit the schedule.

    View automation desk
    Next runin 1h
    ScheduleDaily · 9:00 AM
    Runs this month30
    Latest outcomev17
    April 2026
    SuMoTuWeThFrSa
    Framer Motion refresh
    Daily · 9:00 AM30 runsin 1h
    Automation brief

    Check Motion (Framer Motion) releases for new hooks, layout animation APIs, or performance fixes. Search GitHub discussions and the Vercel blog for migration guides. Update the skill if any API surface changed or a new best-practice pattern emerged.

    Latest refresh trace

    Reasoning steps, source results, and the diff that landed.

    Apr 26, 2026 · 9:42 AM
    triggerAutomation
    editoropenai/gpt-5-mini
    duration78.2s
    statussuccess
    Revision: v17

    Aligned the skill to Motion's March 2026 patch series (12.35.0–12.38.0), clarified that animateView() is alpha and Motion+ gated, and reinforced upgrade guidance for layout, virtualized lists, and WAAPI fixes.

    - Updated changelog section to precisely list 12.35.0 → 12.38.0 entries and their impacts (layoutAnchor, ViewTimeline, axis-locked layout, skipInitialAnimation, color-space support). - Clarified animateView() is an alpha API gated by Motion+. - Reworded import recommendations and preserved examples. - Added explicit upgrade guidance and references to motion.dev/changelog and motion.dev/docs.

    Agent steps
    Step 1Started scanning 8 sources.
    Step 2Motion Releases: No fresh signals found.
    Step 3Vercel Blog: No fresh signals found.
    Step 4React Blog: 12 fresh signals captured.
    Step 5Chrome Developer Blog: 10 fresh signals captured.
    Step 6Motion Changelog: 8 fresh signals captured.
    Step 7Motion GitHub: 12 fresh signals captured.
    Step 8Motion GitHub Releases: 12 fresh signals captured.
    Step 9Motion Docs: 7 fresh signals captured.
    Step 10Agent is rewriting the skill body from the fetched source deltas.
    Step 11v17 is live with body edits.
    Sources
    Motion Releasesdone

    No fresh signals found.

    Vercel Blogdone

    No fresh signals found.

    React Blogdone

    12 fresh signals captured.

    The React Foundation: A New Home for React Hosted by the Linux FoundationDenial of Service and Source Code Exposure in React Server ComponentsCritical Security Vulnerability in React Server Components
    Chrome Developer Blogdone

    10 fresh signals captured.

    Localization support for web app manifestsUnlock Structured Clone for Chrome Extension MessagingWhat's New in WebGPU (Chrome 147-148)
    Motion Changelogdone

    8 fresh signals captured.

    DocsAI KitLogin
    Motion GitHubdone

    12 fresh signals captured.

    Sign upmotiondivisionmotion
    Motion GitHub Releasesdone

    12 fresh signals captured.

    ReleasesSign inSign up
    Motion Docsdone

    7 fresh signals captured.

    DocsAI KitLogin
    Diff preview
    Latest skill diff
    +28−56
    Motion (formerly Framer Motion)
    −Production-ready animation library for React. Motion (published as the `motion` package) is the default choice for component-level animation: enter/exit transitions, layout shifts, gesture responses, spring physics, and scroll-linked effects. It integrates deeply with React's component model and handles the hard parts — interrupted animations, layout measurement, exit choreography — so you can focus on feel.
    +Production-ready animation library for React. Motion (npm package: `motion`) is the default choice for component-level animation: enter/exit transitions, layout shifts, gesture responses, spring physics, and scroll-linked effects. It integrates with React's component model and handles interrupted animations, layout measurement, and exit choreography so you can focus on feel.
    −> Note: The project publishes as Motion (npm package name: `motion`, docs: motion.dev). The legacy `framer-motion` package remains available for migration, but prefer the newer `motion` packages and docs on motion.dev. Import React bindings from `motion/react`.
    +Note: The project publishes as Motion (package name: `motion`). Import React bindings from `motion/react` (e.g. `import { motion, AnimatePresence } from 'motion/react'`). The legacy `framer-motion` package remains published for compatibility but prefer `motion` and the docs on motion.dev for new projects.
    −## When to use
    +When to use
    - Component mount/unmount transitions (modals, toasts, dropdowns, page transitions)
    - Layout animations when elements reorder, resize, or move across containers
    - Hover, tap, drag, and focus micro-interactions
    - Shared element transitions across routes (with `layoutId`)
    - Spring-based physics for interactive feel (sliders, toggles, cards)
    −- Scroll-linked opacity or parallax on individual elements
    +- Scroll-linked effects on individual elements (use `useScroll`, ViewTimeline)
    −## When NOT to use
    +When NOT to use
    +- Scroll-driven pinning/scrubbing or full-page scrollytelling — prefer GSAP + ScrollTrigger for high-control scrub timelines
    +- Complex multi-surface orchestration (DOM + Canvas + WebGL) — use a timeline-focused library (GSAP) or coordinate distinct render layers
    +- Non-React projects — Motion is React-first; use Motion’s vanilla APIs or other libraries for other frameworks
    +- CSS-only hover states where a 1–2 line CSS transition suffices
    −- Scroll-driven pinning, scrubbing, or multi-section choreography — use GSAP + ScrollTrigger
    +- Very large lists with thousands of concurrent animated targets — profile first and prefer virtualized approaches
    −- Complex multi-surface orchestration (DOM + Canvas + WebGL simultaneously) — use GSAP timelines
    −- Non-React projects — Motion is React-first; use Motion's vanilla API or other libraries for other frameworks
    −- CSS-only hover states where a 2-line transition suffices — do not over-engineer
    −- Performance-critical loops rendering thousands of animated items — profile first
    −## Core concepts
    +Core concepts
    −### motion components
    +motion components
    −Wrap any HTML or SVG element with animation superpowers:
    +Wrap HTML or SVG elements with animation capabilities:
    −```tsx
    +import { motion } from 'motion/react';
    −import { motion } from "motion/react";
    −<motion.div
    +<motion.div initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }} />
    − initial={{ opacity: 0 }}
    − animate={{ opacity: 1 }}
    − exit={{ opacity: 0 }}
    −/>
    −```
    −(Install: `npm install motion`. Import React bindings from `motion/react`.)
    +Variants
    −
    −### Variants
    Named animation states that propagate through component trees — use them for staggered entrances and shared state.
    −### AnimatePresence
    +AnimatePresence
    −Animate components as they unmount:
    +Wrap conditionally mounted children to run exit animations:
    −```tsx
    +import { AnimatePresence } from 'motion/react';
    −import { AnimatePresence } from "motion/react";
    −<AnimatePresence mode="wait">
    +<AnimatePresence mode="wait">{isOpen && <motion.div key="modal" initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }} />}</AnimatePresence>
    − {isOpen && (
    − <motion.div
    − key="modal"
    − initial={{ opacity: 0, scale: 0.95 }}
    − animate={{ opacity: 1, scale: 1 }}
    − exit={{ opacity: 0, scale: 0.95 }}
    − transition={{ duration: 0.2 }}
    − />
    − )}
    −</AnimatePresence>
    −```
    −Remember: every direct child of AnimatePresence needs a stable `key` for exit animations to run.
    +Each direct child of AnimatePresence must have a stable `key` for exit choreography to run.
    −### Layout animations
    +Layout animations
    Automatic interpolation when elements change position or size:
    −```tsx
    +<motion.div layout className={isExpanded ? 'w-full' : 'w-48'}>
    −<motion.div layout className={isExpanded ? "w-full" : "w-48"}>
    <motion.p layout="position">Content stays in place</motion.p>
    </motion.div>
    −```
    −Recent March 2026 patch series (Mar 3–16, 2026) delivered several important improvements to layout projection, color handling, and scroll-linked timelines. See the Motion changelog (https://motion.dev/changelog) for full release notes.
    +Use axis-locked layout (layout="x" / layout="y") when only one axis should animate.
    −### Shared layout with layoutId
    +Shared layout with layoutId
    −Seamless element transitions across different components:
    +Seamless transitions across different components using `layoutId` on both source and destination elements.
    −```tsx
    +Spring configuration
    −{items.map((item) => (
    − <motion.div key={item.id} layoutId={item.id} onClick={() => setSelected(item)}>
    − {item.title}
    − </motion.div>
    −))}
    −{selected && (
    +Tune stiffness, damping, and mass for desired feel. Example:
    − <motion.div layoutId={selected.id} className="expanded-card">

    Automations

    ActiveDaily · 9:00 AM8 sources

    Automation is managed by the skill owner.

    Next runin 1h
    ScheduleDaily · 9:00 AM
    Runs this month30
    Latest outcomev17
    statussuccess
    last run1d ago
    triggerScheduled
    editoropenai/gpt-5-mini
    Automation brief

    Check Motion (Framer Motion) releases for new hooks, layout animation APIs, or performance fixes. Search GitHub discussions and the Vercel blog for migration guides. Update the skill if any API surface changed or a new best-practice pattern emerged.

    Research engine

    Framer Motion now combines 4 tracked sources with 1 trusted upstream skill packs. Instead of waiting on a single fixed link, it tracks canonical feeds, discovers new docs from index-like surfaces, and folds those deltas into sandbox-usable guidance.

    8 sources4 Track4 Discover3 Official5 CommunityRank 9Quality 87
    Why this is featured

    Framer Motion has unusually strong source quality and broad utility, so it deserves prominent placement.

    Discovery process
    1. Track canonical signals

    Monitor 4 feed-like sources for release notes, changelog entries, and durable upstream deltas.

    2. Discover net-new docs and leads

    Scan 0 discovery-oriented sources such as docs indexes and sitemaps, then rank extracted links against explicit query hints instead of trusting nav order.

    3. Transplant from trusted upstreams

    Fold implementation patterns from Motion so the skill inherits a real operating model instead of boilerplate prose.

    4. Keep the sandbox honest

    Ship prompts, MCP recommendations, and automation language that can actually be executed in Loop's sandbox instead of abstract advice theater.

    Query hints
    motion releasesmotionanimationvercel blogvercelnext.jsfrontendreact blog
    Trusted upstreams
    Motion

    Production React animation guidance for variants, gestures, layout, and presence.

    FrontendAnimationReactMotion Framer Motion

    Sources

    8 tracked

    Motion Releases

    motion · animation

    Open ↗

    Vercel Blog

    vercel · next.js · frontend

    Open ↗

    React Blog

    react · frontend

    Open ↗

    Chrome Developer Blog

    chrome · web-platform

    Open ↗

    Motion Changelog

    motion · changelog · docs

    Open ↗

    Motion GitHub

    motion · github · releases

    Open ↗

    Motion GitHub Releases

    motion · releases · changelog

    Open ↗

    Motion Docs

    motion · docs · animation

    Open ↗

    Send this prompt to your agent to install the skill

    Agent prompt
    Use the skill at https://loooooop.vercel.app/api/skills/motion-framer/raw

    Versions

    v171d agov163d agov155d agov14Apr 19, 2026v13Apr 18, 2026v12Apr 16, 2026v11Apr 14, 2026v10Apr 12, 2026v9Apr 11, 2026v8Apr 9, 2026v7Apr 7, 2026v6Apr 6, 2026v5Apr 4, 2026v4Apr 2, 2026v3Apr 1, 2026v2Mar 30, 2026v1Mar 29, 2026
    Included files1
    SKILL.md
    Automation
    Active
    scheduleDaily · 9:00 AM
    sources8
    next runin 1h
    last run1d ago
    ·Details·Desk

    Latest refresh

    Apr 19, 2026

    Updated docs to clarify Motion package identity, consolidate March 2026 changelog entries (12.35–12.38), and confirm animateView() is an alpha Motion+ feature gated on the site. Corrected phrasing about preferred import path and included authoritative links.

    what changed

    - Title updated to emphasize Motion (formerly Framer Motion). - Consolidated and cited March 2026 changelog entries (12.35–12.38) with dates and short notes. - Reaffirmed package name/import path using GitHub README and docs. - Clarified animateView() is alpha and gated to Motion+ with link to docs. - Minor editorial fixes to wording around View Transitions and feature-detection.

    8 sources scanned61 signals found
    sections updated
    Title & OverviewChangelog & VersionsanimateView / View TransitionsCore concepts
    status
    success
    triggerAutomation
    editoropenai/gpt-5-mini
    duration78.2s
    Diff▶
    +11−7
    +Generated: 2026-04-19T09:41:18.102Z
    +Summary: Updated docs to clarify Motion package identity, consolidate March 2026 changelog entries (12.35–12.38), and confirm animateView() is an alpha Motion+ feature gated on the site. Corrected phrasing about preferred import path and included authoritative links.
    +What changed: - Title updated to emphasize Motion (formerly Framer Motion).
    +- Consolidated and cited March 2026 changelog entries (12.35–12.38) with dates and short notes.
    +- Reaffirmed package name/import path using GitHub README and docs.
    +- Clarified animateView() is alpha and gated to Motion+ with link to docs.
    −Generated: 2026-04-18T09:27:04.566Z
    +- Minor editorial fixes to wording around View Transitions and feature-detection.
    −Summary: Synchronized the skill with Motion's official docs and changelog: clarified March 2026 patch entries (12.35–12.38), confirmed animateView() is alpha and Motion+-gated, and anchored View Transitions guidance to Chrome 147.
    −What changed: - Rewrote the "Recent patch releases" and "Layout animations" sections to match the Motion changelog. - Expanded and clarified the "View Transitions and animateView" section to cite motion.dev and Chrome Dev blog. - Updated research references to point to motion.dev docs, animate-view docs, changelog, GitHub repo, and Chrome Dev blog.
    Body changed: yes
    Editor: openai/gpt-5-mini
    −Changed sections: Core concepts, Layout animations, View Transitions and animateView, Research references, Summary
    +Changed sections: Title & Overview, Changelog & Versions, animateView / View Transitions, Core concepts
    Experiments:
    +- Track Motion's Motion+ feature rollout and animateView API stability across next 3 releases.
    −- Monitor Motion changelog RSS for patch-level fixes to layout projection and color-space handling.
    +- Measure layout projection memory use in large lists (virtualized) with and without axis-locked layouts to determine default recommendations.
    −- Investigate animateView() usage patterns in open-source Motion+ examples (once public) to capture common migration patterns from layoutId to animateView.
    Signals:
    −- Sign up (Motion GitHub)
    - motiondivision (Motion GitHub)
    - motion (Motion GitHub)
    - .circleci (Motion GitHub)
    +- .devcontainer (Motion GitHub)
    Update history8▶
    Apr 19, 20264 sources

    Updated docs to clarify Motion package identity, consolidate March 2026 changelog entries (12.35–12.38), and confirm animateView() is an alpha Motion+ feature gated on the site. Corrected phrasing about preferred import path and included authoritative links.

    Apr 18, 20264 sources

    Synchronized the skill with Motion's official docs and changelog: clarified March 2026 patch entries (12.35–12.38), confirmed animateView() is alpha and Motion+-gated, and anchored View Transitions guidance to Chrome 147.

    Apr 16, 20264 sources

    This update aligns the skill with Motion's March 2026 patch series and official docs: it clarifies exact changelog entries (12.35–12.38), confirms animateView() is an alpha, Motion+-gated API (per motion.dev), and links the Chrome Dev blog for the browser View Transitions progress.

    Apr 14, 20264 sources

    Updated version and changelog details to reflect Motion 12.35–12.38 (Mar 2026); clarified animateView() is alpha and Motion+-gated; kept operational examples and guidance; preserved import/install instructions.

    Apr 12, 20264 sources

    Updated Motion guidance to reflect March–April 2026 patch releases (12.35–12.38), clarified animateView is alpha and Motion+-gated, and added concrete changelog references and tracking sources. Small wording changes to recommend import path `motion/react` and to surface new layout controls (`layout="x"/"y"`, `layoutAnchor`, `skipInitialAnimation`).

    Apr 11, 20264 sources

    This update aligns the skill with Motion's March 2026 patch series (12.35–12.38), confirms the new `motion` package and `motion/react` import, clarifies axis-locked layouts and `layoutAnchor`, and marks `animateView()` as Motion+ alpha. It also adds a GitHub releases source for ongoing tracking.

    Apr 9, 20264 sources

    Brought the skill up to date with Motion's March 2026 patch series (12.35.x–12.38.0) and Chrome 147 View Transitions advancements. Added concrete version numbers and dates, clarified import path, emphasized Motion+ gating for animateView, and tightened guidance for when to prefer native View Transitions vs Motion projection.

    Apr 7, 20264 sources

    Update the Framer Motion skill to reflect Motion's March 2026 releases and documentation: clarify import paths (`motion/react`), add details about new layout APIs (layout="x"/"y", layoutAnchor, per-axis drag snapping, skipInitialAnimation), surface the Motion `animateView()` alpha and Motion+ gating, and recommend when to prefer native View Transitions (Chrome 147) vs Motion APIs.

    Automations1
    1 activeOpen desk →
    Usage
    views0
    copies0
    refreshes15
    saves0
    api calls0