---
title: "produceState"
description: "Return an observable [snapshot][androidx.compose.runtime.snapshots.Snapshot] [State] that
produces values over time without a defined data source.

[producer] is launched when [produceState] enters the composition and is cancelled when
[produceState] leaves the composition. [producer] should use [ProduceStateScope.value] to set new
values on the returned [State].

The returned [State] conflates values; no change will be observable if [ProduceStateScope.value]
is used to set a value that is [equal][Any.equals] to its old value, and observers may only see
the latest value if several values are set in rapid succession.

[produceState] may be used to observe either suspending or non-suspending sources of external
data, for example:"
type: "composable"
---

<div class='type'>Composable Function</div>


<a id='references'></a>

<div class='sourceset sourceset-common'>Common</div>


```kotlin
@Composable
public fun <T> produceState(
    initialValue: T,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>
```


Return an observable `snapshot` `State` that
produces values over time without a defined data source.

`producer` is launched when `produceState` enters the composition and is cancelled when
`produceState` leaves the composition. `producer` should use `ProduceStateScope.value` to set new
values on the returned `State`.

The returned `State` conflates values; no change will be observable if `ProduceStateScope.value`
is used to set a value that is `equal` to its old value, and observers may only see
the latest value if several values are set in rapid succession.

`produceState` may be used to observe either suspending or non-suspending sources of external
data, for example:



<div class='sourceset sourceset-common'>Common</div>


```kotlin
@Composable
public fun <T> produceState(
    initialValue: T,
    key1: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>
```


Return an observable `snapshot` `State` that
produces values over time from `key1`.

`producer` is launched when `produceState` enters the composition and is cancelled when
`produceState` leaves the composition. If `key1` changes, a running `producer` will be cancelled
and re-launched for the new source. `producer` should use `ProduceStateScope.value` to set new
values on the returned `State`.

The returned `State` conflates values; no change will be observable if `ProduceStateScope.value`
is used to set a value that is `equal` to its old value, and observers may only see
the latest value if several values are set in rapid succession.

`produceState` may be used to observe either suspending or non-suspending sources of external
data, for example:



<div class='sourceset sourceset-common'>Common</div>


```kotlin
@Composable
public fun <T> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>
```


Return an observable `snapshot` `State` that
produces values over time from `key1` and `key2`.

`producer` is launched when `produceState` enters the composition and is cancelled when
`produceState` leaves the composition. If `key1` or `key2` change, a running `producer` will be
cancelled and re-launched for the new source. `producer` should use `ProduceStateScope.value` to
set new values on the returned `State`.

The returned `State` conflates values; no change will be observable if `ProduceStateScope.value`
is used to set a value that is `equal` to its old value, and observers may only see
the latest value if several values are set in rapid succession.

`produceState` may be used to observe either suspending or non-suspending sources of external
data, for example:



<div class='sourceset sourceset-common'>Common</div>


```kotlin
@Composable
public fun <T> produceState(
    initialValue: T,
    key1: Any?,
    key2: Any?,
    key3: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>
```


Return an observable `snapshot` `State` that
produces values over time from `key1`, `key2` and `key3`.

`producer` is launched when `produceState` enters the composition and is cancelled when
`produceState` leaves the composition. If `key1`, `key2` or `key3` change, a running `producer`
will be cancelled and re-launched for the new source.
`producer should use `ProduceStateScope.value` to set new values on the returned `State`.

The returned `State` conflates values; no change will be observable if `ProduceStateScope.value`
is used to set a value that is `equal` to its old value, and observers may only see
the latest value if several values are set in rapid succession.

`produceState` may be used to observe either suspending or non-suspending sources of external
data, for example:



<div class='sourceset sourceset-common'>Common</div>


```kotlin
@Composable
public fun <T> produceState(
    initialValue: T,
    vararg keys: Any?,
    producer: suspend ProduceStateScope<T>.() -> Unit,
): State<T>
```


Return an observable `snapshot` `State` that
produces values over time from `keys`.

`producer` is launched when `produceState` enters the composition and is cancelled when
`produceState` leaves the composition. If `keys` change, a running `producer` will be cancelled
and re-launched for the new source. `producer` should use `ProduceStateScope.value` to set new
values on the returned `State`.

The returned `State` conflates values; no change will be observable if `ProduceStateScope.value`
is used to set a value that is `equal` to its old value, and observers may only see
the latest value if several values are set in rapid succession.

`produceState` may be used to observe either suspending or non-suspending sources of external
data, for example:




## Code Examples
### ProduceState
```kotlin
@Composable
fun ProduceState(viewModel: ProduceStateSampleViewModel) {
    val uiState by
        produceState<UiState<List<Person>>>(UiState.Loading, viewModel) {
            viewModel.people.map { UiState.Data(it) }.collect { value = it }
        }
    when (val state = uiState) {
        is UiState.Loading -> Text("Loading...")
        is UiState.Data ->
            Column {
                for (person in state.data) {
                    Text("Hello, ${person.name}")
                }
            }
    }
}
```
### ProduceStateAwaitDispose
```kotlin
@Suppress("UNUSED_VARIABLE")
@Composable
fun ProduceStateAwaitDispose(viewModel: ProduceStateSampleViewModel) {
    val currentPerson by
        produceState<Person?>(null, viewModel) {
            val disposable = viewModel.registerPersonObserver { person -> value = person }
            awaitDispose { disposable.dispose() }
        }
}
```