Creates a readonly derived reactive memoized signal.

`compute(prev)` runs reactively — every reactive read inside it is
tracked, and the returned value becomes the memo's current value.
The memo is cached: it only recomputes when one of its tracked
sources changes.

```ts
const value = createMemo<T>(compute, options?: MemoOptions<T>);
```

## Import

```ts
import { createMemo } from "solid-js";
```

## Type signature

```ts
function createMemo<T>(
	compute: ComputeFunction<NoInfer<T>, T>,
	options: MemoOptions<T> & { loadingValue: T }
): SourceAccessor<T>;
function createMemo<T>(
	compute: ComputeFunction<undefined | NoInfer<T>, T>,
	options?: MemoOptions<T>
): SourceAccessor<T>;
```

## Parameters

### `compute`

* **Type:** `ComputeFunction<T | undefined, T>`

Receives the previous value and returns the new value; reads inside are tracked. Returning a promise or an `AsyncIterable` makes the memo async, and readers suspend until the first value arrives.

### `options`

* **Type:** `MemoOptions<T>`
* Optional

`name`, `equals`, `lazy`, `loadingValue`, `deferStream`, and `ssrSource`. See the members below.

## Return value

A read-only accessor. Call it to read the memoized value; reading tracks the memo in the surrounding scope.

## Examples

```ts
const [first, setFirst] = createSignal("Ada");
const [last, setLast] = createSignal("Lovelace");

const fullName = createMemo(() => `${first()} ${last()}`);

fullName(); // "Ada Lovelace"
```

```ts
// Async memo — reads suspend inside <Loading>
const user = createMemo(async () => {
	const res = await fetch(`/users/${id()}`);
	return res.json();
});
```

**Hydration:** `MemoOptions` accepts an `ssrSource` field
(`"server"` | `"hybrid"` | `"client"`) that controls what initial
value the client uses and whether `compute` re-runs. See the `ssrSource` option. `transparent: true` opts a memo out of
hydration (it consumes no id slot and computes live); a memo created
with no owner, or under a root without an `id`, has no id to consume
and takes that path on its own.

## Caveats

* Reads inside `compute` are tracked; reads in the code that calls the accessor are tracked there, not in the memo.
* When `compute` returns a promise, reading the accessor before it resolves suspends to the nearest `Loading` boundary. Later updates hold the previous value instead.
* A memo is for values. Put side effects in `createEffect`, not in `compute`.
* While hydrating, a memo that adopts the server's answer runs `compute` once only to track its reads, with the global `Promise` and `fetch` replaced by stand-ins that never settle. Do not store a promise created in `compute` in a cache that outlives the run; see [Async data during hydration](/concepts/rendering-and-ssr#async-data-during-hydration).

## Common problems

* [A value renders once and never updates](/concepts/reactivity#a-value-renders-once-and-never-updates)
* [An effect copies one value into another and the copy lags](/concepts/reactivity#an-effect-copies-one-value-into-another-and-the-copy-lags)
* [Something updates too often](/guides/debugging-reactivity#something-updates-too-often)

## Learn more

* [Derived values](/concepts/reactivity#derived-values)
* [A memo that returns a promise](/concepts/async-reactivity#a-memo-that-returns-a-promise)
* [Reactivity](/concepts/reactivity)
* [Async reactivity](/concepts/async-reactivity)
* [Debugging reactivity](/guides/debugging-reactivity)

## Related types

### `isEqual`

```ts
function isEqual<T>(a: T, b: T): boolean;
```

### `MemoOptions`

:::deep-dive[MemoOptions members]
Options for read-only memos created with `createMemo`.
Also used in combination with `SignalOptions` for writable memos
(`createSignal(fn)` / `createOptimistic(fn)`).

```ts
interface MemoOptions<T> {
	id?: string;
	name?: string;
	loc?: string;
	transparent?: boolean;
	_plumbing?: boolean;
	equals?: false | ((prev: T, next: T) => boolean);
	unobserved?: () => void;
	lazy?: boolean;
	sync?: boolean;
	loadingValue?: T;
	deferStream?: boolean;
	ssrSource?: "server" | "hybrid" | "client";
}
```

**`id`** — `string`

Stable identifier for the owner hierarchy

**`name`** — `string`

Debug name (dev mode only)

**`loc`** — `string`

Source location (`file:line:col`, root-relative) written by the
compiler's `sourceNames` `locations` kind beside `name`; dev and observe
builds keep it for console reports and diagnostic events, production
ignores it. Not meant to be written by hand.

**`transparent`** — `boolean`

Advanced (integration tier). When true, the memo is invisible to the
hydration id scheme: it inherits its parent's id instead of consuming a
child slot, and during hydration it computes live instead of adopting
the serialized server value. For client-only memos with no
server-rendered counterpart — see `EffectOptions.transparent` for
the full semantics. No-op outside hydration.

**`_plumbing`** — `boolean`

**`equals`** — `false | ((prev: T, next: T) => boolean)`

Custom equality function, or `false` to always notify subscribers.
Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
`(a, b) => a.id === b.id`) for value-based equality, or `false` to
notify on every recompute regardless of equality.

**`unobserved`** — `() => void`

Callback invoked when the computed loses all subscribers

**`lazy`** — `boolean`

When true, defers the initial computation until the value is first read,
**and** opts the memo into autodisposal — once it has no remaining
subscribers it is torn down and recomputed from scratch on the next read.
Use it for compute-on-demand values that should not retain state across
idle periods. Non-lazy owned memos live for their owner's lifetime and
never autodispose.

**`sync`** — `boolean`

Advanced. When true, asserts the compute function returns synchronous
values only (never `PromiseLike` / `AsyncIterable`). Skips the
async-shape probe in `recompute` for a small fixed-cost win per run.
Intended for compiler emissions and library code that
provably returns sync values. Returning a Promise or async iterable
from a `sync: true` memo is undefined behavior — the value will be
stored as-is and never awaited.

**`loadingValue`** — `T`

First committed value: a value the memo is born with, shown until the
compute's first real answer lands. While that first answer is in flight
the memo reads as a settled value everywhere — nothing suspends to a
`<Loading>` boundary, no update is held (first-flight work is
loading-class, like a boundary fallback), and `isPending(memo)` stays
**false**: the declared first value answers the question by declaration, so first-load
affordances are driven from the value itself (a `null` placeholder, a
`skeleton: true` field, etc.). Once the first answer lands, the loading
value leaves the lineage forever: refetches use normal pending semantics
(stale value shown, `isPending` true, and the runtime coordinates the update)
— the canonical guard is `data.skeleton || isPending(data)`, whose two
terms cover the two disjoint states.

Typed strictly as `T`: to use `null`/`undefined` as the placeholder,
declare it in the memo's type (e.g. `createMemo<User | null>(...)`), so
every consumer sees the nullable window honestly. If the placeholder is
shaped data standing in for real data, encode its provenance in the data
(e.g. a `skeleton: true` field) rather than letting it impersonate truth.

The loading value is also the compute's first `prev`, so `prev`-based
memos fold from it.

**`deferStream`** — `boolean`

Defer the SSR stream flush until this primitive's first value is
resolved. Lets late-resolving sources hold the document open
rather than forcing the surrounding `<Loading>` boundary to render
its fallback into the HTML. Server-only; ignored on the client.

**`ssrSource`** — `"server" | "hybrid" | "client"`

Hydration policy. Decides what initial value the client uses and
whether the compute re-runs.

* `"server"` *(default)*: client uses the serialized server value
  as initial state. Compute does **not** re-run for the initial
  value — the serialized result is authoritative. Choose this when
  the compute is deterministic from server-available inputs.
* `"hybrid"`: client uses the serialized server value first; then,
  for a compute that returns an **async iterable**, the client
  continues the stream from it (the server consumed exactly one
  yield; the client's first yield duplicates it and is discarded,
  later yields update the node). For a sync or promise-shaped
  compute, `"hybrid"` is identical to `"server"`: the serialized
  value is adopted and the compute does not re-run until a
  dependency changes or `refresh()`. Choose this for streaming
  sources the client should keep consuming after hydration.
* `"client"`: skip the server value entirely. Compute is deferred
  until hydration completes, then runs as if first-mounted.
  Choose this for client-only state where serialization is
  meaningless. Two forms decide what the pre-compute window
  renders: **bare** (structural) — the source suspends on the
  server as a final hole and the nearest `<Loading>` boundary
  renders its fallback, handing the position to the client; or a
  **declared first value** — `loadingValue` on signal-family
  sources (`loadingValue: undefined` is a valid declaration),
  `seedLoadingValue: true` on store-family sources — which renders
  provisional data with no boundary involvement.
:::

### `SignalOptions`

:::deep-dive[SignalOptions members]
Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`.

```ts
interface SignalOptions<T> {
	name?: string;
	loc?: string;
	equals?: false | ((prev: T, next: T) => boolean);
	ownedWrite?: boolean;
	unobserved?: () => void;
	deferStream?: boolean;
	ssrSource?: "server" | "hybrid" | "client";
}
```

**`name`** — `string`

Debug name (dev mode only)

**`loc`** — `string`

Source location (`file:line:col`, root-relative) written by the
compiler's `sourceNames` `locations` kind beside `name`; dev and observe
builds keep it for console reports and diagnostic events, production
ignores it. Not meant to be written by hand.

**`equals`** — `false | ((prev: T, next: T) => boolean)`

Custom equality function, or `false` to always notify subscribers.
Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
`(a, b) => a.id === b.id`) for value-based equality, or `false` to
notify on every write regardless of equality.

**`ownedWrite`** — `boolean`

Suppress dev-mode warnings when writing inside an owned scope

**`unobserved`** — `() => void`

Callback invoked when the signal loses all subscribers

**`deferStream`** — `boolean`

Defer the SSR stream flush until this primitive's first value is
resolved. Lets late-resolving sources hold the document open
rather than forcing the surrounding `<Loading>` boundary to render
its fallback into the HTML. Server-only; ignored on the client.

**`ssrSource`** — `"server" | "hybrid" | "client"`

Hydration policy. Decides what initial value the client uses and
whether the compute re-runs.

* `"server"` *(default)*: client uses the serialized server value
  as initial state. Compute does **not** re-run for the initial
  value — the serialized result is authoritative. Choose this when
  the compute is deterministic from server-available inputs.
* `"hybrid"`: client uses the serialized server value first; then,
  for a compute that returns an **async iterable**, the client
  continues the stream from it (the server consumed exactly one
  yield; the client's first yield duplicates it and is discarded,
  later yields update the node). For a sync or promise-shaped
  compute, `"hybrid"` is identical to `"server"`: the serialized
  value is adopted and the compute does not re-run until a
  dependency changes or `refresh()`. Choose this for streaming
  sources the client should keep consuming after hydration.
* `"client"`: skip the server value entirely. Compute is deferred
  until hydration completes, then runs as if first-mounted.
  Choose this for client-only state where serialization is
  meaningless. Two forms decide what the pre-compute window
  renders: **bare** (structural) — the source suspends on the
  server as a final hole and the nearest `<Loading>` boundary
  renders its fallback, handing the position to the client; or a
  **declared first value** — `loadingValue` on signal-family
  sources (`loadingValue: undefined` is a valid declaration),
  `seedLoadingValue: true` on store-family sources — which renders
  provisional data with no boundary involvement.
:::