Question #384MediumNative Android

What is the difference between `remember` and `rememberSaveable` in Jetpack Compose?

#jetpack-compose#state#remember

Answer

Overview

text
remember
survives recomposition.
text
rememberSaveable
survives configuration changes.


Comparison

Feature
text
remember
text
rememberSaveable
Survives recomposition✅ Yes✅ Yes
Survives config changes❌ No✅ Yes
Survives process death❌ No✅ Yes
PerformanceFasterSlightly slower
Use CaseUI statePersistent state

remember

kotlin
@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    
    Button(onClick = { count++ }) {
        Text("Count: $count")
    }
}
// ❌ Lost on screen rotation

rememberSaveable

kotlin
@Composable
fun Counter() {
    var count by rememberSaveable { mutableStateOf(0) }
    
    Button(onClick = { count++ }) {
        Text("Count: $count")
    }
}
// ✅ Survives screen rotation

What Are Configuration Changes?

  • Screen rotation
  • Language change
  • Dark mode toggle
  • Font size change
  • Multi-window mode

Example: TextField

Without rememberSaveable

kotlin
@Composable
fun LoginForm() {
    var email by remember { mutableStateOf("") }
    
    TextField(
        value = email,
        onValueChange = { email = it }
    )
}
// ❌ Text lost on rotation

With rememberSaveable

kotlin
@Composable
fun LoginForm() {
    var email by rememberSaveable { mutableStateOf("") }
    
    TextField(
        value = email,
        onValueChange = { email = it }
    )
}
// ✅ Text preserved on rotation

Custom Objects

kotlin
data class User(
    val name: String,
    val age: Int
) : Parcelable

@Composable
fun UserForm() {
    var user by rememberSaveable {
        mutableStateOf(User("Alice", 25))
    }
}

When to Use Which?

Use
text
remember

  • Temporary UI state
  • Derived values
  • Scroll positions (handled by framework)
  • Animation states

Use
text
rememberSaveable

  • User input (TextField values)
  • Selection state
  • Expanded/collapsed states
  • Form data

Performance Note

kotlin
// Good
val expensiveComputation = remember {
    computeExpensive()
}

// Overkill
val expensiveComputation = rememberSaveable {
    computeExpensive()
}

Rule of Thumb: Use

text
rememberSaveable
for user-facing state. Use
text
remember
for everything else.