Asynchronous data has long sat awkwardly beside frontend reactivity, forcing developers to connect promises, loading flags, caches and component lifecycles by hand. Released as a stable version on November 16, 2026, SolidJS 2.0 addresses that divide by making asynchronous computations part of its fine-grained reactive graph. Five years after Solid 1.0, the update is less a collection of new features than a significant architectural rethink of how a JavaScript UI framework can coordinate browser state, server execution and streaming data.
The central idea is straightforward: a reactive computation should not stop being reactive because it returns later. A memo can now produce a Promise or an async iterator, while downstream computations track its eventual values. Solid handles pending work, loading boundaries and races within the graph rather than requiring a separate resource abstraction for every request.
Why async reactivity changes the SolidJS framework
Solid has always differed from component-driven JavaScript frameworks by tracking dependencies at the level of signals and computations. When a signal changes, Solid updates the consumers that read it instead of rerunning an entire component function or diffing a virtual DOM tree.
SolidJS 2.0 extends that fine-grained reactivity across time. A computation may begin now, settle later and invalidate only the downstream work that depends on its result. Pending states participate in loading boundaries, and stale results from superseded requests do not automatically overwrite newer data.
This matters for searches, route loaders and dashboards where inputs can change before a request finishes. Previously, developers often coordinated request identity or cancellation themselves. The new graph understands which asynchronous execution belongs to the current dependency state, reducing the amount of defensive state management application code needs.
From createResource to an asynchronous createMemo
Solid 1.x commonly represented remote data with createResource. A simplified user lookup looked like this:
const [userId, setUserId] = createSignal('42');
const [user] = createResource(userId, async id => {
const response = await fetch(`/api/users/${id}`);
if (!response.ok) throw new Error('Unable to load user');
return response.json();
});
<Suspense fallback={<p>Loading…</p>}>
<h2>{user()?.name}</h2>
</Suspense>That pattern worked, but it gave asynchronous data its own primitive and conventions. In SolidJS 2.0, createMemo can return a Promise directly:
const [userId, setUserId] = createSignal('42');
const user = createMemo(async () => {
const response = await fetch(`/api/users/${userId()}`);
if (!response.ok) throw new Error('Unable to load user');
return response.json();
});
const displayName = createMemo(() => user()?.name ?? 'Unknown user');
<Suspense fallback={<p>Loading…</p>}>
<h2>{displayName()}</h2>
</Suspense>The important change is not merely shorter syntax. The second memo is a downstream subscriber to an asynchronous value. It updates when the Promise resolves and is associated with the relevant pending boundary. If userId changes rapidly, Solid can keep the resulting executions ordered within the graph so an older response does not become the current value after a newer one.
Async iterators make streams reactive
A memo may also return an async iterator. Each yielded value becomes a new reactive value for its consumers, making the model useful for progressive results, event feeds and other streaming interfaces:
const latestEvent = createMemo(async function* () {
for await (const event of openEventStream()) {
yield event;
}
});
const eventLabel = createMemo(() => latestEvent()?.label);This does not remove the need to design reconnection, cancellation or error behavior. It does mean that streamed values can flow through the same dependency system as synchronous JavaScript signals rather than being copied into a separate signal by subscription callbacks.
Server functions move into the core
Another major architectural change is that server functions are now part of the core SolidJS framework instead of being treated solely as a metaframework concern. A server-marked function can retain a function-call interface in application code while the build system supplies the browser-to-server transport.
async function renameProject(projectId, name) {
'use server';
return database.projects.update(projectId, { name });
}
await renameProject(id, nextName);The exact generated transport depends on the runtime and SolidStart configuration, but the model covers conventional request-response RPC as well as persistent connections delivered through Server-Sent Events. SSE is particularly useful for one-way server streams such as job progress, notifications and live status updates without requiring a WebSocket for every case.
Optimistic updates make an interface feel immediate by displaying an expected result before the server confirms it. The risk is divergence: a rejected mutation can leave client state saying something the database does not.
SolidJS 2.0 connects optimistic state to the underlying server operation. The interface can expose the provisional value while work is pending, commit the authoritative response when it succeeds and roll back automatically when it fails. The server remains the source of truth rather than becoming one participant in a manually synchronized client cache.
Automatic rollback cannot decide product-specific behavior such as conflict messaging or retries. Teams still need to show useful errors and consider concurrent edits, authorization failures and offline behavior.
Diagnostics designed for developers and AI coding agents
The release also changes how Solid communicates reactive mistakes. Diagnostics now use stable error codes, source locations and suggested fixes. That structure is more actionable than a warning whose wording may change between versions.
For developers, a diagnostic can identify where a dependency was read incorrectly, where work causes unnecessary updates or where an API no longer matches the reactive model. Editors and build tools can link a stable code to documentation instead of parsing free-form console output.
This structure is also relevant to AI coding agents. An assistant may generate code that compiles while introducing an untracked read, excess recomputation or an unnecessary synchronization effect. Machine-consumable diagnostics give an agent a specific location and correction path, making automated repair more dependable. They do not prove that generated code is correct, secure or maintainable, but they provide better feedback than a successful compilation alone.
A smaller API surface brings breaking changes
SolidJS 2.0 removes several familiar APIs: createResource, batch, startTransition, on, produce, createComputed and createMutable. This is a substantial break for established applications, not a routine dependency bump.
The removals reflect a goal of making fewer primitives carry more consistent semantics. Async memos replace the separate resource concept, while scheduling and update coordination are integrated more deeply into the runtime. Mutable-store helpers and explicit dependency utilities may require redesign rather than a mechanical import change.
Practical SolidJS migration guide
- Inventory removed imports. Search application code, shared packages, tests and generated files for all seven removed APIs.
- Map resource flows. For each
createResource, document its source signal, fetcher, loading UI, error path, refetch behavior and cache assumptions before converting it to an asynchronous memo. - Review reactive dependencies. Code built around
onorcreateComputedmay rely on explicit timing. Confirm what is tracked and when the replacement should execute. - Revisit mutation patterns. Uses of
produceandcreateMutablemay be better represented with immutable updates or newly recommended state patterns. - Test races and failures. Include rapid input changes, rejected requests, navigation during pending work, stream disconnection and optimistic rollback.
- Upgrade integrations together. Check router, SolidStart, testing, compiler and deployment adapter compatibility rather than updating the runtime in isolation.
Because replacements vary by use case, teams should consult the official Solid documentation and review the versioned migration material before changing production code. The official Solid release history and changelog should also be checked for patches and package-specific compatibility notes.
SolidJS vs React, Vue and Svelte
These frameworks increasingly share ideas, but their execution models remain different.
SolidJS vs React
React primarily reruns component functions and reconciles their output. Its asynchronous and server features are increasingly integrated through Suspense, transitions, Server Components and framework-specific server actions. Solid retains components as an authoring tool but updates at the signal and computation level. SolidJS 2.0 puts promises and streams directly into that fine-grained graph rather than centering async work on component rerenders.
SolidJS vs Vue
Vue also provides fine-grained reactive primitives, including refs and computed values, within a component and template system. Async data and server execution are commonly coordinated through lifecycle code, composables or a metaframework such as Nuxt. Solid’s new model goes further in treating asynchronous computation itself as a first-class graph node, although Vue has a larger ecosystem and more established conventions for many application categories.
SolidJS vs Svelte
Svelte emphasizes compiler-assisted reactivity and has expanded its explicit reactive model through runes and SvelteKit’s server features. Solid performs fine-grained runtime dependency tracking without a virtual DOM. Both aim to reduce component-level update overhead, but SolidJS 2.0’s distinctive proposition is one graph spanning synchronous values, promises, iterators and server-connected operations.
Performance advantages—and important trade-offs
Fine-grained reactivity can avoid broad rerenders because only computations that consume a changed value need to run. Integrating asynchronous work may also eliminate duplicated loading state and synchronization effects. Those characteristics can improve responsiveness and simplify some data flows.
They do not guarantee that every migrated application becomes faster. Network design, computation cost, list rendering, caching, bundle size and application architecture still matter. Poorly structured dependencies can also create unnecessary work.
The learning curve is another trade-off. Developers accustomed to component lifecycles must think in dependency graphs, ownership and tracked reads. Solid’s ecosystem is smaller than React’s and less mature in some areas than Vue’s or Svelte’s. The reduced API surface may improve long-term developer experience, but the initial migration cost is real.
What the release means for SolidStart and new projects
SolidStart benefits from having async reactivity and server functions defined by the underlying framework. That can reduce conceptual seams between UI state, route data, mutations and streamed server events. It also gives adapters and tooling a common foundation for RPC, SSE, pending boundaries and diagnostics.
For new frontend development, SolidJS 2.0 is compelling when an application has highly interactive state, streaming data or many small independent updates. React may remain preferable when ecosystem breadth and hiring familiarity dominate. Vue offers an approachable progressive model, while Svelte provides a strong compiler-led full-stack experience. Framework selection should follow product constraints rather than benchmark headlines.
Is async reactivity a compelling alternative?
SolidJS 2.0 makes a coherent argument that time should be part of the reactive model, not an exception layered onto it. Promises, async iterators, server functions and optimistic mutations can now participate in a shared system of dependencies and pending work.
The breaking changes demand careful migration, and the architecture will not suit every team. Even so, integrating asynchronous behavior directly into a fine-grained graph offers a meaningful alternative to traditional component-driven designs—especially for applications where data changes continuously and coordination code has become more complex than the interface itself.
Frequently asked questions
When was SolidJS 2.0 released?
The stable release arrived on November 16, 2026, five years after Solid 1.0. It is a major version with architectural changes and removed APIs, so existing applications should not treat it as a drop-in upgrade.
Does createMemo replace createResource?
For asynchronous reactive computations, that is the core direction. A memo can return a Promise or async iterator, allowing pending and resolved values to participate in the reactive graph. Applications must still review caching, refetching and error requirements during migration.
Does SolidJS 2.0 automatically make applications faster?
No. Fine-grained updates can reduce unnecessary work, but real performance depends on application structure, network behavior, rendering patterns and dependencies. Teams should profile representative workflows before and after migration.
Are SolidJS server functions limited to request-response calls?
No. Core server functions support conventional RPC-style interactions and persistent server-to-browser delivery through Server-Sent Events, enabling both discrete mutations and ongoing event streams.