跪拜 Guibai
← Back to the summary

SolidJS 2.0 Makes Async a Part of Its Reactive Core

SolidJS 2.0 Officially Released: Async Becomes Part of Reactivity

After five years, SolidJS reaches 2.0. The new version no longer treats async requests as a special case outside the reactive system; instead, it brings promises, server data, and optimistic updates into the same reactive dependency graph.

On November 16, 2026, SolidJS founder Ryan Carniato published Solid 2.0 - The Long Hold on the official blog, announcing that SolidJS 2.0 has reached stable. The official SolidJS X account then posted, summarizing the upgrade's keyword as Async Signals.

For a front-end framework known for fine-grained reactivity and no virtual DOM, this is not a simple API update. Solid 2.0 attempts to solve a long-standing problem: when data comes from the network, updates must wait for the server, and multiple states depend on each other, can the UI still treat them like synchronous variables?

From Signals to Async Graph

Solid 1.0's core idea is fine-grained reactivity: component functions typically run only once, after which signals precisely drive the DOM updates that depend on them, without re-rendering the entire component.

But data in real applications doesn't always arrive synchronously. Search suggestions, cascading selects, user information, and server operations can introduce request latency, duplicate requests, and state races. In the past, developers had to coordinate these with dedicated APIs like createResource.

Solid 2.0 brings async into the reactive graph (Async Graph). Now, a regular createMemo can return a Promise, and downstream computations that depend on it are coordinated by the framework.

import { createMemo, isPending, Loading } from "solid-js";

function Profile(props: { id: string }) {
  const user = createMemo(() => fetchUser(props.id));

  return (
    <Loading fallback={<p>Loading user information...</p>}>
      <h1 class={{ stale: isPending(user) }}>
        {user().name}
      </h1>
    </Loading>
  );
}

fetchUser is an async function implemented by the business logic. The noteworthy part isn't that the code is a few lines shorter, but that responsibilities have shifted:

For example, if a user quickly toggles two filter conditions and the earlier request returns later, the page shouldn't revert to a stale result. This kind of consistency problem used to be scattered throughout component request logic; Solid 2.0 lifts it to the framework layer.

A clarification is also needed: bringing async into the reactive graph does not mean applications no longer need to think about caching strategies, request failures, server permissions, or business consistency. It solves the coordination problem at the UI reactive scheduling layer; it does not replace the entire data access architecture.

More Than Reading Data: Optimistic Updates and Server Functions

Solid 2.0's async model covers both "reads" and "writes." The new version provides action, createOptimistic, and createOptimisticStore, allowing user actions to get UI feedback first, then wait for server confirmation, and roll back temporary state if necessary.

This is valuable for scenarios like to-dos, shopping carts, and likes: users don't have to wait for a network round-trip; the UI can show the operation result immediately, while the server remains the final authority on data.

Server capabilities have also changed. The Server Functions previously handled by SolidStart now move into the more fundamental framework capabilities, callable with Web-standard Request/Response and supporting continuous data streams via Server-Sent Events.

The official demo shows a live with an async generator: the server continuously produces price data, and the client still consumes it via reactive computations. Async data streams no longer need a separate state-synchronization mechanism outside the UI reactive system.

Of course, server functions require the corresponding build and runtime environment; you can't just write "use server" in any static page and automatically get a server.

A Batch of Old APIs Exit the Stage

To unify the underlying semantics, Solid 2.0 removes multiple 1.x-era APIs:

Solid 1.x Solid 2.0 direction
createResource Use async-capable createMemo and similar computations
batch Microtask batching by default; use flush when necessary
startTransition / useTransition Updates coordinated by the reactive graph, with isPending and related capabilities
on Declare dependencies explicitly in the effect's computation phase
produce Use the draft provided by the Store setter directly
createComputed Convert to createMemo or the new Effect model depending on use
createMutable Use createStore with draft updates

The keyword here is reducing special cases. Rather than having developers learn an ever-growing set of APIs dedicated to async and state changes, Solid 2.0 wants to integrate the relevant semantics into the reactive system.

But the cost is also clear: this is a major version upgrade with breaking changes; you can't just change the version number in package.json.

In particular, note that Signal setters use a staged commit write timing. A normal write is usually committed at the next microtask, so reading immediately after writing may return an uncommitted old value; only at an imperative boundary where you truly need to observe the new state immediately should you consider flush(). Don't mechanically replace every batch() with flush().

Store and Effect Syntax Also Changes

Store updates shift from path-based calls to draft style.

// Solid 1.x
setState("user", "address", "city", "Shanghai");

// Solid 2.0
setState((draft) => {
  draft.user.address.city = "Shanghai";
});

createEffect also clearly separates the dependency-tracking computation phase from the side-effect execution phase:

import { createEffect } from "solid-js";

createEffect(
  () => title(),
  (value) => {
    document.title = value;
  }
);

The first function reads the tracked reactive dependencies; the second executes the actual side effect. This makes dependencies clearer and makes it easier to diagnose errors where "code runs but the UI doesn't update as expected."

Additionally, web rendering imports move from solid-js/web to @solidjs/web; Store APIs now import from solid-js. Related JSX types, Vite plugins, and server integrations also need updating.

SolidStart Retires, Start Mode Takes Over

Another significant change is that SolidStart is no longer an official meta-framework that will evolve independently.

The SolidJS team explains that SolidStart was originally used to fill gaps in the core framework. As server functions, service layers, and routing infrastructure have gradually moved down, its responsibilities can now be handled by core capabilities and Vite plugins.

The new approach provides application building and serving capabilities through Start Mode in @solidjs/vite-plugin:

import { defineConfig } from "vite";
import solid from "@solidjs/vite-plugin";

export default defineConfig({
  plugins: [solid({ start: true })],
});

Here, start: true defaults to client mode; for SSR, further configuration is needed per the official guide. The team says existing SolidStart projects won't stop working immediately from this decision; 1.x will still receive maintenance updates, but migrating to 2.0 requires following a dedicated guide.

At the same time, Solid 2.0 introduces a new Rust/Oxc-based compiler toolchain, enabled by default in the new Vite plugin. The team published significant speedup data for certain compilation samples during the RC phase, but compile-time speedups should not be taken as equal runtime performance improvements for production pages.

In the AI Era, the Reactive System Starts Explaining Errors Proactively

Another direction worth noting in this release: Solid 2.0 treats AI coding agents as a developer workflow that needs support.

The team believes the most troublesome problem with large models writing code isn't just generation speed, but code that appears to run but actually has incorrect reactive dependencies.

Solid 2.0 leverages the fine-grained reactive graph's knowledge of dependencies to provide diagnostics with stable error codes, source locations, and fix guidance in the development environment, helping developers or AI agents locate untracked reads, unreasonable writes, and certain async scheduling issues.

In addition, the official docs list CHEATSHEET.md, Skills, and diagnostic tools shipped with the package, and the new templates include an AGENTS.md guide. This is a notable change: front-end frameworks are beginning to engineer "making the framework easier for AI to use correctly" into their design, rather than relying solely on models remembering documentation.

It must be stressed that these diagnostics don't mean AI-generated business logic is inherently correct; testing, code review, and application-boundary verification remain essential.

X Discussions: Excitement, but Also Ecosystem Issues

The official SolidJS X post framed 2.0 with Async Signals. Founder Ryan Carniato joked about finally shipping before GTA 6 and thanked all contributors who participated along the way.

From the verified public discussions, developers' attention focuses on three areas.

First, interest in the async model. Developer Adam Rackis said that while many front-end trends no longer interest him, Solid 2.0's async capabilities remain appealing. Japanese developer しまぶー particularly praised the design of bringing async into the reactive graph and encouraged developers familiar with React, Vue, and Svelte to try it.

Second, real-project performance experience. Peter Steinberger mentioned in a reply that his team moved a project from Lit to Solid and received positive feedback on web performance. Note this describes actual migration experience to Solid, not a controlled benchmark of Solid 2.0 versus 1.x.

Third, ecosystem adaptation. shadcn noted that its UI SDK now supports Solid 2.0. At the same time, for teams preparing to migrate, whether existing component libraries, routing, data-fetching libraries, and build tools have adapted is still a checklist to verify item by item.

These are the public statements that could be verified, not a statistically representative sample of X as a whole. The release has drawn clear attention, but whether it drives large-scale production migration remains to be proven by time and more practice.

What Does It Mean for Vue and React Developers?

The most notable thing about SolidJS 2.0 may not be whether it can change the front-end framework landscape in a short time, but that it offers an alternative architectural answer:

Async is not a problem that needs separate "patching" outside reactivity; it can become a component of reactive computation.

From Vue Vapor and Svelte's Runes to Angular's adoption of Signals, fine-grained reactivity is no longer just a niche framework experiment. Different approaches still differ significantly in compilation strategy, component semantics, and async handling, but the front-end ecosystem continues exploring the direction of "describing state dependencies more precisely."

For developers preparing new projects, Solid 2.0 deserves a spot on the technology selection shortlist. For existing Solid 1.x projects, it's better to first verify dependency compatibility, Effect behavior, Store migration, SSR, and build output in a branch before deciding the upgrade pace. There's no need to hastily refactor a stable, running system just to chase a version.

Conclusion

SolidJS 2.0 took five years to complete an underlying refactor. According to the official retrospective, the stable release went through 14 weeks and 23 release candidates, merging 971 pull requests and closing 753 issues.

The direction it shows is clear: fewer special-case APIs, more unified async state handling, more complete server infrastructure, and reactive diagnostics that can be understood by both developers and AI tools.

The significance of this release isn't just that SolidJS has a new major version; it's that it continues to push an important front-end question: just how much complexity should a UI framework that understands its own dependency graph handle for the developer?

References

  1. SolidJS official release blog: Solid 2.0 - The Long Hold (2026-11-16)
  2. SolidJS 2.0 RC: The Big Reveal
  3. SolidJS official 1.x → 2.0 migration guide
  4. SolidJS official AI tools guide
  5. SolidJS official X post
  6. Ryan Carniato's X reply
  7. Adam Rackis's X comment
  8. しまぶー's X comment
  9. Peter Steinberger's X comment
  10. shadcn's Solid 2.0 ecosystem update
Comments

Top 1 from juejin.cn, machine-translated. The original thread is authoritative.

组合搭配函数

Bringing async into the reactive graph is a bold move, and letting the framework handle race condition coordination is a real relief. Cutting a pile of 1.x APIs is a pretty harsh move though; migrating old projects is going to be a chore.