vercel-react-view-transitions
vercel-labs/agent-skills
Implement smooth native animations between UI states using React's View Transition API without third-party libraries.
What is vercel-react-view-transitions?
Guide for using React's View Transition API to animate page transitions, route changes, shared element animations, and component enter/exit states. Use this skill when you need to add smooth, native-feeling animations in React or Next.js apps, or when the user asks about animating between UI states without animation libraries.
- Animate page and route transitions with directional (forward/back) navigation support
- Create shared element animations that morph between identical elements across state changes
- Animate component enter/exit and list reordering with CSS view transition pseudo-elements
- Trigger animations via startTransition, useDeferredValue, or Suspense (not regular setState)
- Tag transitions with addTransitionType to apply different animations based on navigation context
- Gracefully degrade on unsupported browsers (Chromium 125+, Firefox 144+, Safari 18.2+)
How to install vercel-react-view-transitions
npx skills add https://github.com/vercel-labs/agent-skills --skill vercel-react-view-transitions- React canary (react@canary react-dom@canary) for non-Next.js apps; Next.js App Router already includes React canary
- Browser support: Chromium 125+, Firefox 144+, or Safari 18.2+
How to use vercel-react-view-transitions
- 1.Follow the implementation audit in references/implementation.md to identify which animation patterns fit your app
- 2.Wrap components with <ViewTransition> and set enter/exit/share props to "auto", "none", or a CSS class name
- 3.Use startTransition, useDeferredValue, or Suspense to trigger animations (regular setState does not animate)
- 4.Call addTransitionType() inside startTransition to tag transitions for type-specific CSS animations
- 5.Apply CSS animations using ::view-transition-old, ::view-transition-new, and ::view-transition-group pseudo-elements
- 6.Test on supported browsers; unsupported browsers skip animations and render content normally
Use cases
- Animate a list item expanding into a detail page with a morphing shared element
- Slide pages left/right on forward/back navigation to communicate spatial depth
- Fade in new content when data loads via Suspense without blocking the UI
- Reorder list items with smooth animations that preserve item identity
- Implement tab-to-tab navigation with fade transitions instead of directional slides
- React and Next.js developers building interactive UIs
- Product engineers implementing navigation patterns that need visual continuity
- Teams avoiding third-party animation libraries in favor of native browser APIs
vercel-react-view-transitions FAQ
No. Next.js App Router already bundles React canary internally; ViewTransition works out of the box. npm ls react may show a stable version, but this is expected.
Use directional slides (nav-forward/nav-back) only for hierarchical navigation (list → detail) or ordered sequences (carousel, paginated results) to communicate spatial depth. Use fade or no animation for lateral/unordered navigation (tab-to-tab).
ViewTransition only activates during Transitions triggered by startTransition, useDeferredValue, or Suspense. Regular setState does not animate; wrap state updates in startTransition.
Yes, use the shared element pattern with a `name` prop. Both old and new views must render in the same Transition for the morph to work; if incoming content suspends, only its fallback exists for pairing.
Animations gracefully degrade—content renders normally without visual transitions. No errors or broken layouts occur.
Full instructions (SKILL.md)
Source of truth, from vercel-labs/agent-skills.
name: vercel-react-view-transitions
description: Guide for implementing smooth, native-feeling animations using React's View Transition API (<ViewTransition> component, addTransitionType, and CSS view transition pseudo-elements). Use this skill whenever the user wants to add page transitions, animate route changes, create shared element animations, animate enter/exit of components, animate list reorder, implement directional (forward/back) navigation animations, or integrate view transitions in Next.js. Also use when the user mentions view transitions, startViewTransition, ViewTransition, transition types, or asks about animating between UI states in React without third-party animation libraries.
license: MIT
metadata:
author: vercel
version: "1.0.0"
React View Transitions
Animate between UI states using the browser's native document.startViewTransition. Declare what with <ViewTransition>, trigger when with startTransition / useDeferredValue / Suspense, control how with CSS classes. Unsupported browsers skip animations gracefully.
When to Animate
Every <ViewTransition> should communicate a spatial relationship or continuity. If you can't articulate what it communicates, don't add it.
Implement all applicable patterns from this list, in this order:
| Priority | Pattern | What it communicates |
|---|---|---|
| 1 | Shared element (name) | "Same thing — going deeper" |
| 2 | Suspense reveal | "Data loaded" |
| 3 | List identity (per-item key) | "Same items, new arrangement" |
| 4 | State change (enter/exit) | "Something appeared/disappeared" |
| 5 | Route change (page-level) | "Going to a new place" |
This is an implementation order, not a "pick one" list. Implement every pattern that fits the app. Only skip a pattern if the app has no use case for it.
Choosing Animation Style
| Context | Animation | Why |
|---|---|---|
| Hierarchical navigation (list → detail) | Type-keyed nav-forward / nav-back | Communicates spatial depth |
| Lateral navigation (tab-to-tab) | Bare <ViewTransition> (fade) or default="none" | No depth to communicate |
| Suspense reveal | enter/exit string props | Content arriving |
| Revalidation / background refresh | default="none" | Silent — no animation needed |
Reserve directional slides for hierarchical navigation (list → detail) and ordered sequences (prev/next photo, carousel, paginated results). For ordered sequences, the direction communicates position: "next" slides from right, "previous" from left. Lateral/unordered navigation (tab-to-tab) should not use directional slides — it falsely implies spatial depth.
Availability
- Next.js: Do not install
react@canary— the App Router already bundles React canary internally.ViewTransitionworks out of the box.npm ls reactmay show a stable-looking version; this is expected. - Without Next.js: Install
react@canary react-dom@canary(ViewTransitionis not in stable React). - Browser support: Chromium 125+ (React needs the v2 object form of
startViewTransition), Firefox 144+, Safari 18.2+. Graceful degradation on unsupported browsers.
Implementation Workflow
When adding view transitions to an existing app, follow references/implementation.md step by step. Start with the audit — do not skip it. Use references/css-recipes.md for the applicable CSS and adapt it to the app.
Core Concepts
The <ViewTransition> Component
import { ViewTransition } from 'react';
<ViewTransition>
<Component />
</ViewTransition>
React auto-assigns a unique view-transition-name and calls document.startViewTransition behind the scenes. Never call startViewTransition yourself.
Animation Triggers
| Trigger | When it fires |
|---|---|
| enter | <ViewTransition> first inserted during a Transition |
| exit | <ViewTransition> first removed during a Transition |
| update | DOM mutations inside a <ViewTransition>, or the boundary itself changing size/position due to an immediate sibling. With nested VTs, mutation applies to the innermost one |
| share | Named VT unmounts and another with same name mounts in the same Transition |
Only startTransition, useDeferredValue, or Suspense activate VTs. Regular setState does not animate.
Critical Placement Rule
<ViewTransition> only activates enter/exit if it appears before any DOM nodes:
// Works
<ViewTransition enter="auto" exit="auto">
<div>Content</div>
</ViewTransition>
// Broken — div wraps the VT, suppressing enter/exit
<div>
<ViewTransition enter="auto" exit="auto">
<div>Content</div>
</ViewTransition>
</div>
Styling with View Transition Classes
Props
Values: "auto" (browser cross-fade), "none" (disabled), "class-name" (custom CSS), or { [type]: value } for type-specific animations.
<ViewTransition default="none" enter="slide-in" exit="slide-out" share="morph" />
If default is "none", all triggers are off unless explicitly listed.
CSS Pseudo-Elements
::view-transition-old(.class)— outgoing snapshot::view-transition-new(.class)— incoming snapshot::view-transition-group(.class)— container::view-transition-image-pair(.class)— old + new pair
See references/css-recipes.md for ready-to-use animation recipes.
Transition Types
Tag transitions with addTransitionType so VTs can pick different animations based on context. Call it multiple times to stack types — different VTs in the tree react to different types:
startTransition(() => {
addTransitionType('nav-forward');
addTransitionType('select-item');
router.push('/detail/1');
});
Pass an object to map types to CSS classes. Works on enter, exit, and share:
<ViewTransition
enter={{ 'nav-forward': 'slide-from-right', 'nav-back': 'slide-from-left', default: 'none' }}
exit={{ 'nav-forward': 'slide-to-left', 'nav-back': 'slide-to-right', default: 'none' }}
share={{ 'nav-forward': 'morph-forward', 'nav-back': 'morph-back', default: 'morph' }}
default="none"
>
<Page />
</ViewTransition>
enter and exit don't have to be symmetric. For example, fade in but slide out directionally:
<ViewTransition
enter={{ 'nav-forward': 'fade-in', 'nav-back': 'fade-in', default: 'none' }}
exit={{ 'nav-forward': 'nav-forward', 'nav-back': 'nav-back', default: 'none' }}
default="none"
>
TypeScript: ViewTransitionClassPerType requires a default key in the object.
For apps with multiple pages, extract the type-keyed VT into a reusable wrapper:
export function DirectionalTransition({ children }: { children: React.ReactNode }) {
return (
<ViewTransition
enter={{ 'nav-forward': 'nav-forward', 'nav-back': 'nav-back', default: 'none' }}
exit={{ 'nav-forward': 'nav-forward', 'nav-back': 'nav-back', default: 'none' }}
default="none"
>
{children}
</ViewTransition>
);
}
router.back() and Browser Back Button
router.back() and the browser's back/forward buttons carry no transition types, so type-keyed animations (directional slides) resolve to their default and don't play — untyped shared-element morphs still apply. For typed animations, use router.push() with an explicit URL.
Types and Suspense
Types are available during navigation but not during subsequent Suspense reveals (separate transitions, no type). Use type maps for page-level enter/exit; use simple string props for Suspense reveals.
Shared Element Readiness
A shared element transition can pair elements only when both the old and new views are rendered in the same Transition. If incoming content suspends, only its fallback exists for that update; the resolved content appears in a later Suspense transition and can be animated separately.
Shared Element Transitions
Same name on two VTs — one unmounting, one mounting — creates a shared element morph:
<ViewTransition name="hero-image">
<img src="/thumb.jpg" onClick={() => startTransition(() => onSelect())} />
</ViewTransition>
// On the other view — same name
<ViewTransition name="hero-image">
<img src="/full.jpg" />
</ViewTransition>
- Only one VT with a given
namecan be mounted at a time — use unique names (photo-${id}). Watch for reusable components: if a component with a named VT is rendered in both a modal/popover and a page, both mount simultaneously and break the morph. Either make the name conditional (via a prop) or move the named VT out of the shared component into the specific consumer. sharetakes precedence overenter/exit. Think through each navigation path: when no matching pair forms (e.g., the target page doesn't have the same name),enter/exitfires instead. Consider whether the element needs a fallback animation for those paths.- Two ways a wired-up morph silently never fires: (1)
default="none"with no explicitshareprop — share resolves to none; (2) type-keyedsharewhere the navigation never adds the type — a plain link click resolves the map'sdefault. Every link that should morph must add the type (transitionTypesonnext/link, oraddTransitionType). - Never use a fade-out exit on pages with shared morphs — use a directional slide instead.
Common Patterns
Enter/Exit
{show && (
<ViewTransition enter="fade-in" exit="fade-out"><Panel /></ViewTransition>
)}
List Reorder
{items.map(item => (
<ViewTransition key={item.id}><ItemCard item={item} /></ViewTransition>
))}
Trigger inside startTransition. Avoid wrapper <div>s between list and VT.
Layout Displacement Morph
Only content inside an activated boundary animates position — everything else teleports to its new layout spot. Wrap the sibling content below a growing/shrinking list in a bare <ViewTransition> so it glides instead of jumping. See Layout Displacement Morph.
Composing Shared Elements with List Identity
Shared elements and list identity are independent concerns — don't confuse one for the other. When a list item contains a shared element (e.g., an image that morphs into a detail view), use two nested <ViewTransition> boundaries:
{items.map(item => (
<ViewTransition key={item.id}> {/* list identity */}
<Link href={`/items/${item.id}`}>
<ViewTransition name={`item-image-${item.id}`} share="morph"> {/* shared element */}
<Image src={item.image} />
</ViewTransition>
<p>{item.name}</p>
</Link>
</ViewTransition>
))}
The outer VT handles list reorder/enter animations. The inner VT handles the cross-route shared element morph. Missing either layer means that animation silently doesn't happen.
Force Re-Enter with key
<ViewTransition key={searchParams.toString()} enter="slide-up" default="none">
<ResultsGrid />
</ViewTransition>
Caution: If wrapping <Suspense>, changing key remounts the boundary and refetches.
Suspense Fallback to Content
Simple cross-fade:
<ViewTransition>
<Suspense fallback={<Skeleton />}><Content /></Suspense>
</ViewTransition>
Directional reveal:
<Suspense fallback={<ViewTransition exit="slide-down"><Skeleton /></ViewTransition>}>
<ViewTransition enter="slide-up" default="none"><Content /></ViewTransition>
</Suspense>
For more patterns, see references/patterns.md.
How Multiple VTs Interact
Every VT matching the trigger fires simultaneously in a single document.startViewTransition. VTs in different transitions (navigation vs later Suspense resolve) don't compete.
Use default="none" Deliberately
Without it, every VT fires the browser cross-fade on every transition — Suspense resolves, useDeferredValue updates, background revalidations. Use default="none" on named/shared elements and type-keyed page VTs.
But it also turns off update (layout/reflow morphs) and share (a named pair with no explicit share prop never morphs). Keyed list items and displaced siblings want update — leave them bare or set update="auto".
Two Patterns Coexist
Pattern A — Directional slides: Type-keyed VT on each page, fires during navigation. Pattern B — Suspense reveals: Simple string props, fires when data loads (no type).
They coexist because they fire at different moments. default="none" on both prevents cross-interference. Always pair enter with exit. Place directional VTs in page components, not layouts.
Nested VT Limitation
When a parent VT mounts/unmounts as one unit with nested VTs inside it, the nested ones do not fire their own enter/exit — only the outermost VT animates. (A child VT mounted inside a persistent parent VT fires enter/exit normally.) Per-item staggered animations during page navigation are not currently available in Next.js; see troubleshooting for the upstream experimental status.
Next.js Integration
For Next.js integration (transitionTypes on next/link and useRouter, App Router patterns, Server Components), see references/nextjs.md.
Accessibility
Always add the reduced motion CSS from references/css-recipes.md to your global stylesheet.
Reference Files
- references/implementation.md — Step-by-step implementation workflow.
- references/patterns.md — Patterns, animation timing, and events API.
- references/troubleshooting.md — Symptom-driven debugging and runtime limitations.
- references/css-recipes.md — Ready-to-use CSS animation recipes.
- references/nextjs.md — Next.js App Router patterns and Server Component details.
Full Compiled Document
For the complete guide with all reference files expanded: AGENTS.md
Related skills
More from vercel-labs/agent-skills and the wider catalog.
