Animation

A guide to animating Base UI components.

Base UI components can be animated using CSS transitions, CSS animations, or JavaScript animation libraries. Each component provides a number of data attributes to target its states, as well as a few attributes specifically for animation.

CSS transitions

Use the following Base UI attributes for creating transitions when a component becomes visible or hidden:

[data-starting-style] corresponds to the initial style to transition from.
[data-ending-style] corresponds to the final style to transition to.

Transitions are recommended over CSS animations, because a transition can be smoothly cancelled midway. For example, if the user closes a popup before it finishes opening, with CSS transitions it will smoothly animate to its closed state without any abrupt changes.

popover.css

.Popup {
  box-sizing: border-box;
  padding: 1rem 1.5rem;
  background-color: canvas;
  transform-origin: var(--transform-origin);
  transition:
    transform 150ms,
    opacity 150ms;

  &[data-starting-style],
  &[data-ending-style] {
    opacity: 0;
    transform: scale(0.9);
  }
}

CSS animations

Use the following Base UI attributes for creating CSS animations when a component becomes visible or hidden:

[data-open] corresponds to the style applied when a component becomes visible.
[data-closed] corresponds to the style applied before a component becomes hidden.

popover.css

@keyframes scaleIn {
  from {
    opacity: 0;
    transform: scale(0.9);
  }
  to {
    opacity: 1;
    transform: scale(1);
  }
}

@keyframes scaleOut {
  from {
    opacity: 1;
    transform: scale(1);
  }
  to {
    opacity: 0;
    transform: scale(0.9);
  }
}

.Popup[data-open] {
  animation: scaleIn 250ms ease-out;
}

.Popup[data-closed] {
  animation: scaleOut 250ms ease-in;
}

JavaScript animations

JavaScript animation libraries such as Motion require control of the mounting and unmounting lifecycle of components in order for exit animations to play.

Base UI relies on element.getAnimations() to detect if animations have finished on an element. When using Motion, opacity animations are reflected in element.getAnimations(), so Base UI automatically waits for the animation finish before unmounting the component. If opacity isn’t part of your animation (such as in a translating drawer component), you should still animate it using a value close to 1 (such as opacity: 0.9999), so that Base UI can detect the animation.

Animating components unmounted from DOM when closed with Motion

Most popup components like Popover, Dialog, Tooltip, and Menu are unmounted from the DOM when they are closed by default. To animate them with Motion:

Make the component controlled with the open prop so <AnimatePresence> can see the state as a child
Specify keepMounted on the <Portal> part
Use the render prop to compose the <Popup> with motion.div

index.tsx index.module.css

'use client';
import * as React from 'react';
import { Popover } from '@base-ui/react/popover';
import { AnimatePresence, motion } from 'motion/react';
import styles from './index.module.css';

export default function AnimatedPopoverMotionKeepMountedFalseDemo() {
  const [open, setOpen] = React.useState(false);

  return (
    <Popover.Root open={open} onOpenChange={setOpen}>
      <Popover.Trigger className={styles.Trigger}>Trigger</Popover.Trigger>
      <AnimatePresence>
        {open && (
          <Popover.Portal keepMounted>
            <Popover.Positioner className={styles.Positioner} sideOffset={8}>
              <Popover.Popup
                className={styles.Popup}
                render={
                  <motion.div
                    initial={{ opacity: 0, scale: 0.8 }}
                    animate={{ opacity: 1, scale: 1 }}
                    exit={{ opacity: 0, scale: 0.8 }}
                  />
                }
              >
                Popup
              </Popover.Popup>
            </Popover.Positioner>
          </Popover.Portal>
        )}
      </AnimatePresence>
    </Popover.Root>
  );
}

animated-popover.tsx

function App() {
  const [open, setOpen] = React.useState(false);

  return (
    <Popover.Root open={open} onOpenChange={setOpen}>
      <Popover.Trigger>Trigger</Popover.Trigger>
      <AnimatePresence>
        {open && (
          <Popover.Portal keepMounted>
            <Popover.Positioner>
              <Popover.Popup
                render={
                  <motion.div
                    initial={{ opacity: 0, scale: 0.8 }}
                    animate={{ opacity: 1, scale: 1 }}
                    exit={{ opacity: 0, scale: 0.8 }}
                  />
                }
              >
                Popup
              </Popover.Popup>
            </Popover.Positioner>
          </Popover.Portal>
        )}
      </AnimatePresence>
    </Popover.Root>
  );
}

Animating components kept in DOM when closed with Motion

Components that specify keepMounted remain rendered in the DOM when they are closed. These elements need a different approach to be animated with Motion:

Use the render prop to compose the <Popup> with motion.div
Animate the properties based on the open state, avoiding <AnimatePresence>

index.tsx index.module.css

'use client';
import * as React from 'react';
import { Popover } from '@base-ui/react/popover';
import { motion, type HTMLMotionProps } from 'motion/react';
import styles from './index.module.css';

export default function AnimatedPopoverMotionKeepMountedTrueDemo() {
  return (
    <Popover.Root>
      <Popover.Trigger className={styles.Trigger}>Trigger</Popover.Trigger>
      <Popover.Portal keepMounted>
        <Popover.Positioner className={styles.Positioner} sideOffset={8}>
          <Popover.Popup
            className={styles.Popup}
            render={(props, state) => (
              <motion.div
                {...(props as HTMLMotionProps<'div'>)}
                initial={false}
                animate={{
                  opacity: state.open ? 1 : 0,
                  scale: state.open ? 1 : 0.8,
                }}
              />
            )}
          >
            Popup
          </Popover.Popup>
        </Popover.Positioner>
      </Popover.Portal>
    </Popover.Root>
  );
}

animated-popover.tsx

function App() {
  return (
    <Popover.Root>
      <Popover.Trigger>Trigger</Popover.Trigger>
      <Popover.Portal keepMounted>
        <Popover.Positioner>
          <Popover.Popup
            render={(props, state) => (
              <motion.div
                {...(props as HTMLMotionProps<'div'>)}
                initial={false}
                animate={{
                  opacity: state.open ? 1 : 0,
                  scale: state.open ? 1 : 0.8,
                }}
              />
            )}
          >
            Popup
          </Popover.Popup>
        </Popover.Positioner>
      </Popover.Portal>
    </Popover.Root>
  );
}

Animating Select component with Motion

The Select component is initially unmounted but remains mounted after interaction. To animate it with Motion, a mix of the two previous approaches is needed.

index.tsx index.module.css

'use client';
import * as React from 'react';
import { Select } from '@base-ui/react/select';
import { AnimatePresence, motion } from 'motion/react';
import styles from './index.module.css';

const fonts = [
  { label: 'Select font', value: null },
  { label: 'Sans-serif', value: 'sans' },
  { label: 'Serif', value: 'serif' },
  { label: 'Monospace', value: 'mono' },
  { label: 'Cursive', value: 'cursive' },
];

export default function AnimatedSelectMotionDemo() {
  const [open, setOpen] = React.useState(false);
  const [mounted, setMounted] = React.useState(false);

  const positionerRef = React.useCallback(() => {
    setMounted(true);
  }, []);

  const portalMounted = open || mounted;

  // Once the trigger has been interacted with, the popup will always be
  // mounted in the DOM. We can use this to determine which animation variant
  // to use: if it's already mounted, we switch to use "keepMounted" animations.
  const motionElement = mounted ? (
    <motion.div
      initial={false}
      animate={{
        opacity: open ? 1 : 0,
        scale: open ? 1 : 0.8,
      }}
    />
  ) : (
    <motion.div
      initial={{ opacity: 0, scale: 0.8 }}
      animate={{ opacity: 1, scale: 1 }}
      exit={{ opacity: 0, scale: 0.8 }}
    />
  );

  return (
    <Select.Root items={fonts} open={open} onOpenChange={setOpen}>
      <Select.Trigger className={styles.Select}>
        <Select.Value className={styles.Value} />
        <Select.Icon>
          <CaretUpDownIcon />
        </Select.Icon>
      </Select.Trigger>
      <AnimatePresence>
        {portalMounted && (
          <Select.Portal>
            <Select.Positioner className={styles.Positioner} sideOffset={4} ref={positionerRef}>
              <Select.Popup className={styles.Popup} render={motionElement}>
                <Select.ScrollUpArrow className={styles.ScrollArrow} />
                <Select.List className={styles.List}>
                  {fonts.map(({ label, value }) => (
                    <Select.Item key={label} value={value} className={styles.Item}>
                      <Select.ItemIndicator className={styles.ItemIndicator}>
                        <CheckIcon />
                      </Select.ItemIndicator>
                      <Select.ItemText className={styles.ItemText}>{label}</Select.ItemText>
                    </Select.Item>
                  ))}
                </Select.List>
                <Select.ScrollDownArrow className={styles.ScrollArrow} />
              </Select.Popup>
            </Select.Positioner>
          </Select.Portal>
        )}
      </AnimatePresence>
    </Select.Root>
  );
}

function CaretUpDownIcon(props: React.ComponentProps<'svg'>) {
  return (
    <svg
      width="16"
      height="16"
      viewBox="0 0 16 16"
      fill="currentColor"
      {...props}
      style={{ display: 'block', ...props.style }}
    >
      <path d="M11 10H5l3 3.5zm0-4H5l3-3.5z" />
    </svg>
  );
}

function CheckIcon(props: React.ComponentProps<'svg'>) {
  return (
    <svg
      width="16"
      height="16"
      viewBox="0 0 16 16"
      fill="none"
      stroke="currentColor"
      {...props}
      style={{ display: 'block', ...props.style }}
    >
      <path d="m2.5 8.5 4 4 7-9" />
    </svg>
  );
}

Manual unmounting

For full control, you can manually unmount the component when it’s closed once animations have finished using an actionsRef passed to the <Root>:

manual-unmount.tsx

function App() {
  const [open, setOpen] = React.useState(false);
  const actionsRef = React.useRef(null);

  return (
    <Popover.Root open={open} onOpenChange={setOpen} actionsRef={actionsRef}>
      <Popover.Trigger>Trigger</Popover.Trigger>
      <AnimatePresence>
        {open && (
          <Popover.Portal keepMounted>
            <Popover.Positioner>
              <Popover.Popup
                render={
                  <motion.div
                    initial={{ scale: 0 }}
                    animate={{ scale: 1 }}
                    exit={{ scale: 0 }}
                    onAnimationComplete={() => {
                      if (!open) {
                        actionsRef.current.unmount();
                      }
                    }}
                  />
                }
              >
                Popup
              </Popover.Popup>
            </Popover.Positioner>
          </Popover.Portal>
        )}
      </AnimatePresence>
    </Popover.Root>
  );
}

View Transitions

React 19.3 ships the <ViewTransition> component, which animates DOM changes using the browser’s View Transition API. Base UI components work with it as long as two conditions are met:

The update that changes the UI runs inside a Transition. Base UI applies its own state changes as regular updates, so control the state yourself and wrap the update in startTransition.
React, not Base UI, removes the elements being animated. Components like <Tabs.Panel> stay mounted while their CSS exit animation plays and are removed a frame later, outside of the Transition, which makes the browser skip the view transition. Render such elements conditionally so they leave the tree within the Transition.

The ::view-transition-* pseudo-elements are rendered on the root element, so their styles must live in a global stylesheet rather than a CSS Module.

When a Transition only changes the elements inside <ViewTransition> boundaries, React excludes the root element from the view transition so the rest of the page stays interactive. Chrome doesn’t paint position: fixed elements during such a transition, so give fixed elements like headers and sidebars their own view-transition-name.

Animating Tabs panels with View Transitions

Render only the active panel inside a <ViewTransition> so React can play its enter and exit animations. Pass the activationDirection from the change event details to addTransitionType to slide the panels toward the newly active tab.

Workspace stats and activity.

index.tsx index.module.css index.css

'use client';
import * as React from 'react';
import { Tabs } from '@base-ui/react/tabs';
import styles from './index.module.css';
import './index.css';

const tabs = [
  { value: 'overview', label: 'Overview', description: 'Workspace stats and activity.' },
  { value: 'projects', label: 'Projects', description: 'Milestones and deadlines.' },
  { value: 'account', label: 'Account', description: 'Profile and preferences.' },
];

export default function ViewTransitionTabs() {
  const [value, setValue] = React.useState('overview');

  return (
    <Tabs.Root
      className={styles.Root}
      value={value}
      onValueChange={(nextValue, eventDetails) => {
        React.startTransition(() => {
          React.addTransitionType(eventDetails.activationDirection);
          setValue(nextValue);
        });
      }}
    >
      <Tabs.List className={styles.List}>
        {tabs.map((tab) => (
          <Tabs.Tab key={tab.value} className={styles.Tab} value={tab.value}>
            {tab.label}
          </Tabs.Tab>
        ))}
        <Tabs.Indicator className={styles.Indicator} />
      </Tabs.List>
      <div className={styles.PanelViewport}>
        {tabs.map(
          (tab) =>
            tab.value === value && (
              <React.ViewTransition
                key={tab.value}
                enter={{ right: 'slide-from-right', left: 'slide-from-left', default: 'auto' }}
                exit={{ right: 'slide-to-left', left: 'slide-to-right', default: 'auto' }}
              >
                <Tabs.Panel className={styles.Panel} value={tab.value}>
                  <p className={styles.Paragraph}>{tab.description}</p>
                </Tabs.Panel>
              </React.ViewTransition>
            ),
        )}
      </div>
    </Tabs.Root>
  );
}

Animating list changes with View Transitions

Wrap each list item in a <ViewTransition> so React assigns it a stable view-transition-name. When a control such as <ToggleGroup> changes the order of the list inside a Transition, the items animate to their new positions.

index.tsx12 KB
logo.svg30 KB
package.json2 KB
README.md4 KB
styles.css7 KB

index.tsx index.module.css index.css

'use client';
import * as React from 'react';
import { Toggle } from '@base-ui/react/toggle';
import { ToggleGroup } from '@base-ui/react/toggle-group';
import styles from './index.module.css';
import './index.css';

const files = [
  { id: 'readme', name: 'README.md', size: 4 },
  { id: 'package', name: 'package.json', size: 2 },
  { id: 'index', name: 'index.tsx', size: 12 },
  { id: 'styles', name: 'styles.css', size: 7 },
  { id: 'logo', name: 'logo.svg', size: 30 },
];

type SortKey = 'name' | 'size';

export default function ViewTransitionList() {
  const [sortKey, setSortKey] = React.useState<SortKey>('name');

  const sortedFiles = [...files].sort((a, b) =>
    sortKey === 'name' ? a.name.localeCompare(b.name) : a.size - b.size,
  );

  return (
    <div className={styles.Container}>
      <ToggleGroup
        aria-label="Sort files by"
        className={styles.Panel}
        value={[sortKey]}
        onValueChange={(groupValue: SortKey[]) => {
          const nextSortKey = groupValue[0];
          if (nextSortKey) {
            React.startTransition(() => {
              setSortKey(nextSortKey);
            });
          }
        }}
      >
        <Toggle value="name" className={styles.Button}>
          Name
        </Toggle>
        <Toggle value="size" className={styles.Button}>
          Size
        </Toggle>
      </ToggleGroup>
      <ul className={styles.List}>
        {sortedFiles.map((file) => (
          <React.ViewTransition key={file.id}>
            <li className={styles.Item}>
              {file.name}
              <span className={styles.Size}>{file.size} KB</span>
            </li>
          </React.ViewTransition>
        ))}
      </ul>
    </div>
  );
}

Popups

Dialog and Popover can animate with <ViewTransition> when open is controlled inside startTransition, the portal uses keepMounted, and the popup and its View Transition boundary are rendered conditionally from open. Keeping the portal mounted lets its DOM container exist before the opening Transition.

For Popover, place <Popover.Positioner> inside the <ViewTransition> boundary so the positioning element participates in the transition.