One-line summary: Solid 2.0 (stable on 2026-11-16) puts "a memo that returns a Promise" directly into the reactive graph. When an input changes, it holds the current screen and swaps everything in at once when the new values are ready. Loading flags, race conditions, and rollback become framework guarantees; in exchange, the developer has to explicitly fill the "I clicked and nothing happened" gap with feedback.
createMemo(() => fetchUser(props.id)) and "use server" reminded them why they abandoned JS frameworks. Bundle size also came up (one report: a counter example went from 4.8 KiB to 20.3 KiB brotli).When showing async data in a UI, we have traditionally hand-written some combination of:
const [loading, setLoading] = useState(true) around and write data?.name with optional chaining. The type becomes T | undefined, and every reader has to handle "not yet".React has tackled this with Suspense + Transitions, but wrapping in startTransition is an opt-in choice made by the caller. React's useTransition docs also note that Transitions only "wait" long enough to avoid hiding already revealed content.
Solid 2.0's question: if the framework knows the dependency graph exactly, can it own async coordination, races, and consistency too?
import { Loading, createMemo } from "solid-js";
type Product = { id: string; name: string; price: number; description: string };
async function fetchProduct(id: string): Promise<Product> {
const res = await fetch(`/api/products/${id}`);
if (!res.ok) throw new Error(`Could not load product ${id}`);
return res.json();
}
function ProductDetail(props: { id: string }) {
const product = createMemo(() => fetchProduct(props.id));
return (
<Loading fallback={<p>Loading product…</p>}>
<h1>{product().name}</h1>
</Loading>
);
}
Per the docs, product() has type Product, not Product | undefined or Promise<Product>. If the value hasn't arrived when it is read, the reading expression becomes "waiting" and the nearest <Loading> shows its fallback. This works because pending propagates downstream through the graph: a memo derived from product, like priceLabel, automatically waits too (the derived code doesn't know it's async, which sidesteps the function-coloring problem).
Solid props compile to getters, so <ProductLayout product={product()} /> does not read the value in the parent; it is evaluated only where the child reads props.product.name. This yields two independent design decisions: