---
title: "rememberDeferredTransition"
description: "Creates and remembers a [DeferredTransition] for a given [DeferredTransitionState]."
type: "composable"
---
## API Reference

### rememberDeferredTransition

> Source set: Common

```kotlin
@Composable
public fun <T> rememberDeferredTransition(
    transitionState: DeferredTransitionState<T>,
    label: String? = null,
): DeferredTransition<T>
```

Creates and remembers a [DeferredTransition](/jetpack-compose/androidx.compose.animation/animation-core/classes/DeferredTransition/api) for a given [DeferredTransitionState](/jetpack-compose/androidx.compose.animation/animation-core/classes/DeferredTransitionState/api).

A [DeferredTransition](/jetpack-compose/androidx.compose.animation/animation-core/classes/DeferredTransition/api) allows for a two-stage state update:
1. **Deferred Phase:** Initiated by `DeferredTransitionState.defer`. The transition's
`targetState` remains unchanged, while the new target is exposed via `pendingTargetState`.
This allows higher-level components to implement custom behavior (e.g., manual gesture
tracking) while the automatic transition is "held".
2. **Automatic Phase:** Initiated by `DeferredTransitionState.animateTo`. The
`pendingTargetState` is cleared and `targetState` is updated, starting the automatic
transition animations.

#### Parameters

| | |
| --- | --- |
| transitionState | The [DeferredTransitionState](/jetpack-compose/androidx.compose.animation/animation-core/classes/DeferredTransitionState) that manages the current and target states. |
| label | An optional label for the transition to be displayed in Android Studio's Animation Preview. |

#### Return

A [DeferredTransition](/jetpack-compose/androidx.compose.animation/animation-core/classes/DeferredTransition) that will update whenever [transitionState](/jetpack-compose/androidx.compose.animation/animation-core/classes/TransitionState) changes.

## Code Examples

### DeferredTransitionSample

```kotlin
@OptIn(ExperimentalDeferredTransitionApi::class)
@Sampled
@Composable
fun DeferredTransitionSample() {
    var targetState by remember { mutableStateOf("Initial") }
    var isDeferred by remember { mutableStateOf(false) }

    // Create a DeferredTransitionState
    val transitionState = remember { DeferredTransitionState(targetState) }

    // Use LaunchedEffect to handle defer/animateTo logic based on some external signal
    // (e.g. gesture progress, predictive back events, etc).
    LaunchedEffect(targetState, isDeferred) {
        if (isDeferred) {
            // Enter deferred phase: targetState is updated as a pendingTargetState
            // but animations don't start yet.
            transitionState.defer(targetState)
        } else {
            // Start automatic transition: pendingTargetState is cleared and targetState is updated
            // to trigger animations.
            transitionState.animateTo(targetState)
        }
    }

    val transition = rememberDeferredTransition(transitionState)
    // Create animations as usual
    val alpha by transition.animateFloat { state -> if (state == "Initial") 0f else 1f }

    Box(Modifier.graphicsLayer { this.alpha = alpha }) {
        // Content
    }
}
```