SolidJS 2.0 Beta Brings First‑Class Async, Reworked Suspense and Deterministic Batching

What changed

SolidJS 2.0 Beta arrived on May 15 2026, skipping the scheduled Alpha phase after a prolonged experimental period. Creator Ryan Carniato explained that the “goalposts” defined for Alpha no longer reflected the direction the team was taking, so the beta ships with a complete async model, a new Suspense implementation, and deterministic batching of updates.

Key technical shifts include:

• Async as a first‑class primitive – any computation can now return a Promise. The reactive graph automatically suspends the node, waits for resolution, and resumes without developer‑written await wrappers.
• Loading component redesign – it now only displays a fallback on the initial load of a subtree. Subsequent data refreshes keep the UI stable, eliminating the “flash‑of‑loading” effect that many users found jarring.
• isPending(() => expr) – replaces the previous pattern of tearing down and rebuilding UI to indicate pending state.
• action() + createOptimisticStore – unified API for optimistic UI updates, server writes and automatic revalidation.
• Derived‑state primitives – createSignal(fn) and createStore(fn) turn derived values into first‑class signals, simplifying memoization.
• Micro‑task batching with explicit flush() – all reads are deferred until the end of the micro‑task queue, giving a deterministic scheduling model.

The release also introduces several breaking changes: <Index> is replaced by <For keyed={false}>, createEffect is split into compute and apply phases, onMount becomes onSettled, and the use: directive is removed in favor of a ref‑factory approach.

Provider comparison – impact on migration and cost

Feature	SolidJS 1.x (stable)	SolidJS 2.0 Beta	Migration effort
Async handling	Manual await inside effects or external stores	Promises accepted directly in createMemo, createSignal, createStore	Medium – replace most createEffect‑based async wrappers with isPending and action.
Suspense	Global <Suspense> that re‑mounts subtree on each fetch	Loading component shows fallback only on first render, UI stays stable afterwards	Low – update component hierarchy to use new Loading semantics.
Batching	Implicit, sometimes nondeterministic	Explicit micro‑task batching, flush‑controlled reads	Medium – add flush() calls where immediate reads are required (e.g., logging after a store write).
API surface	createEffect(fn) (single function)	createEffect(compute, apply) split	High – refactor complex effects that depend on multiple signals.
Directives	use: directive for DOM refs	ref factory pattern	Low – replace use: with ref={el => …}.

From a cost perspective, the beta is distributed via the npm next tag (npm install solid-js@next @solidjs/web@next). There is no licensing fee change; the framework remains MIT‑licensed. However, enterprises should budget for developer time to adapt to the new effect lifecycle and to audit code for the new deterministic read model, which can surface hidden race conditions.

Business impact and migration strategy

Performance gains

The deterministic micro‑task batching eliminates the occasional “double render” that some Solid 1.x apps exhibited under heavy async load. Benchmarks posted by the Solid team show a 12 % reduction in time‑to‑interactive for a typical e‑commerce product‑listing page when the new async primitives are used.

Developer experience

Developers who have struggled with manual promise handling now receive a cleaner mental model: a signal can be a value or a promise, and the framework guarantees that downstream computations see the resolved value. This reduces boilerplate and aligns the code more closely with TypeScript’s Promise<T> typing, making IDE assistance more reliable.

Risk considerations

The split‑phase createEffect has drawn criticism for making dependency tracking less implicit. Teams that rely heavily on auto‑tracking will need to audit effect boundaries and possibly introduce helper utilities that wrap the two phases into a single, readable abstraction. The delayed read model (flush() required for immediate values) also forces a shift in how state is inspected during debugging; console logs placed immediately after a signal write will now show stale values unless flush() is invoked.

Migration roadmap

1. Run the official migration guide – it lists all breaking‑API replacements and provides code snippets for common patterns.
2. Upgrade a low‑risk module (e.g., a widget library) to the beta and validate that the new Loading component behaves as expected.
3. Introduce action() in places where optimistic UI updates are needed, replacing custom optimistic patterns.
4. Add a lint rule (or extend eslint-plugin-solid) to flag direct reads of signals after a write without a subsequent flush(); this helps enforce the new deterministic model.
5. Gradual rollout – use feature flags to serve the beta bundle to a subset of users while monitoring performance metrics (TTI, CPU time, memory usage).

Competitive positioning

Compared with React’s concurrent mode, Solid 2.0’s first‑class async model offers similar suspension capabilities without a virtual DOM, preserving the library’s hallmark low overhead. For enterprises evaluating a move away from React for performance reasons, the beta demonstrates that Solid now handles async workloads with comparable ergonomics, reducing the friction that previously kept teams on the React side.

Bottom line

SolidJS 2.0 Beta represents a strategic shift: async handling is baked into the core reactive engine, Suspense has been simplified for a smoother user experience, and batching is now deterministic. The changes introduce a moderate migration cost but promise measurable performance improvements and a cleaner developer experience. Companies that prioritize low‑latency UI and fine‑grained reactivity should begin planning a phased upgrade, leveraging the provided migration guides and the npm next tag to test the new model in production‑like environments.

---

Daniel Curtis is a UI Development Manager at Griffiths Waite, guiding enterprise front‑end teams through modern JavaScript frameworks and cloud‑native deployment strategies.