SolidJS 2.0 Is Stable: Async Reactivity, Server Functions, and the Migration Path
Solid 2.0 is not simply a faster renderer or a new set of JSX conventions. It changes where asynchronous work lives in the framework, how server interactions are expressed, and how the runtime explains mistakes.
The stable release was published on November 17, 2026. That makes this a good moment to evaluate the new model, but not a reason to upgrade a production application without a migration plan.
Official Solid 2.0 artwork. Source: Solid maintainers' release announcement.
What Solid is trying to solve
Solid is a JavaScript UI framework built around fine-grained reactivity. Instead of repeatedly diffing a virtual DOM tree, Solid tracks the relationships between values and the parts of the interface that read them. When a signal changes, the dependent computation can update directly.
That model has always been attractive for interfaces with frequent, localized updates. The harder problem is coordinating data that does not arrive synchronously: network requests, server mutations, streaming responses, optimistic updates, and cancellation.
Solid 2.0 brings those operations into the reactive graph rather than making every application invent a separate loading-state convention.
The release is also a genuine current trend rather than a recycled framework story. The stable tag landed on November 17 after 23 release candidates in 14 weeks. The maintainer's announcement records 971 merged pull requests and 753 closed issues during that final stretch. The November 17 r/solidjs discussion attracted more than 100 points and focused on both excitement and migration questions.
The important architectural change: async belongs in the graph
In Solid 2, a computation can return a Promise or an async iterator. Downstream computations understand that result as part of the same reactive model.
That matters because a request is not just a function call. It has a lifecycle: it can be pending, superseded by a newer request, cancelled, or replaced by a mutation. When the framework understands that lifecycle, it can coordinate dependent UI and avoid stale responses overwriting newer state.
The maintainer's release example is intentionally small:
function Profile(props) {
const user = createMemo(() => fetchUser(props.id));
return (
<Loading fallback={<Skeleton />}>
<h1>{user().name}</h1>
</Loading>
);
}
Here, fetchUser returns a Promise and the loading boundary owns the pending presentation. In a real app, Loading, Skeleton, and fetchUser come from your own components and data layer. The important idea is that the async value remains inside the reactive graph.
Solid's server functions also move into core. The release announcement demonstrates a live server function backed by an async generator and consumed as a reactive value. That enables persistent Server-Sent Events workflows without forcing every component to manage a separate subscription protocol.
A small project you can run
The official release uses this scaffold command:
npm create solid@latest
Choose a starter in the prompts, enter the generated directory, install its dependencies, and start the development script provided by the template.
For a first component, the familiar signal model remains useful:
import { createSignal } from "solid-js";
export default function App() {
const [count, setCount] = createSignal(0);
return (
<main>
<h1>Solid 2.0</h1>
<button onClick={() => setCount(value => value + 1)}>
Clicked {count()} times
</button>
</main>
);
}
The setter updates the signal and only the dependent expression needs to refresh. This is a good starting point before introducing async reads, server functions, or optimistic mutations.
Diagnostics designed for real development
One of the more interesting changes is not a new component. Solid 2.0 development builds can report reactive mistakes with a stable diagnostic code, source location, explanation, and suggested fix.
For example, a value read outside a tracked scope can trigger a diagnostic explaining why that read will not update. The same reactive graph can identify request waterfalls, runaway effect loops, and graph shapes with excessive fan-out or fan-in.
This is useful for humans and coding agents. A compiler error that says what went wrong and points to the source is easier to repair than a UI that silently displays stale data. The project also includes a Reactivity Diagnostics skill file that gives compatible agents more specific repair guidance.
A useful video overview from Better Stack was published during the release-candidate period. It predates the stable tag, so use it for the architectural tour and the final release notes for stable-version decisions.
What changes for existing Solid 1 applications?
This is a major version. The migration guide should be treated as required reading, not optional background.
The 2.0 release removes several APIs because their responsibilities are handled by the unified async model or newer primitives. The announcement specifically lists createResource, batch, startTransition, on, produce, createComputed, and createMutable among the removed APIs.
Do not run a blind dependency update and assume that a passing type-check proves behavioural compatibility. Inventory those APIs first, then migrate one feature at a time. Pay particular attention to code that reads a value immediately after writing it, custom resource wrappers, and effects that depend on implicit execution order.
SolidStart is also retired as a separate metaframework. The maintainers' direction is to put the primitives required for a metaframework in Solid core and use framework-agnostic Vite plugins. That reduces the need for one blessed stack, but it also means teams should check the current compatibility of their router, cache, authentication, and deployment integrations.
When should you choose Solid 2?
Solid is a strong candidate when you want fine-grained updates, explicit reactive relationships, and more control over the libraries that form your application stack. It is especially interesting for dashboards, interactive editors, real-time views, and applications with complex async state.
React still has a much larger ecosystem and hiring pool. Svelte offers a compiler-oriented authoring model with a different set of trade-offs. Solid is not a drop-in React replacement just because both use JSX: its reactivity and component semantics are different.
The biggest practical risk today is ecosystem readiness. Solid 2 is stable, but every third-party integration does not become compatible on release day. Check your router, data cache, testing tools, UI library, and deployment adapter before choosing a migration date.
Sources and further reading
- Solid 2.0 stable release and full changelog
- Solid 2.0: The Long Hold
- Official Solid documentation
- Migration guide from Solid 1.x
- Solid 2.0 community discussion
The project is MIT-licensed. Review the migration guide and your integration matrix before upgrading a production application.
Have you tried Solid 2.0 yet? Which part of the new async model would make the biggest difference in your current frontend?
Written by Shaswat Raj

Top comments (0)