Sulat.com / Writing on AIThursday, November 19, 2026
Developer Tools/18 November 2026

Solid 2.0 reaches stable with async in the reactive graph, and SolidStart is retired

Solid 2.0 is stable after five years. A memo can now return a Promise or async iterator, server functions move into core, SolidStart is retired and seven Solid 1 APIs are gone.

Glossy 3D Solid logo beside a glowing cube graph with an hourglass node

At a glance

  • Solid 2.0 is stable, and npm's latest tag for solid-js points to 2.0.0. It asks for Node 22.12.0 or newer.
  • A createMemo can return a Promise or async iterator, so loading, pending and race handling live in the reactive graph.
  • Server functions move into core, and SolidStart, the metaframework, is retired.
  • createResource, batch, startTransition, on, produce, createComputed and createMutable are removed.
  • Development builds report reactive mistakes with a stable code, a source location and a repair guide for agents.

Five years after Solid 1.0, the SolidJS team has shipped 2.0. Ryan Carniato, who started the project, wrote it up in a release post, and the project’s X account said that signals went mainstream five years ago and async signals now get the same treatment. The big idea is that async now lives inside the reactive graph. A memo can hand back a Promise or an async iterator, and whatever reads it simply waits.

https://x.com/solid_js/status/2122768111774629946

Check npm and you’ll see solid-js 2.0.0 sitting on the latest tag. A fresh project starts with npm create solid@latest. One catch from the package metadata: it asks for Node 22.12.0 or newer.

Async moves into the graph

Fetching data in Solid 1 meant createResource. Now you put the fetch in a createMemo and let it return the Promise. Wrap the part of the page that depends on it in <Loading> to get a fallback, and call isPending if you’d rather keep old content on screen, styled as stale, while a refetch runs. Carniato says races are handled for you, and that speculative state gets rolled back so the server keeps the final word.

function Profile(props) {
  const user = createMemo(() => fetchUser(props.id));
  return (
    <Loading fallback={<Skeleton />}>
      <h1 class={{ stale: isPending(user) }}>{user().name}</h1>
    </Loading>
  );
}

Server functions arrived in SolidStart in early 2022 and have now moved into core. They handle plain RPC calls over Request and Response, and they can also hold a connection open over Server-Sent Events. Mark an async generator with "use server", wrap it in live from @solidjs/web/server-functions, and a memo can read it as a stream.

import { live } from "@solidjs/web/server-functions";

const stockPrice = live(async function* (symbol: string) {
  "use server";
  for await (const tick of subscribe(symbol)) yield tick.price;
});

// in your component
const price = createMemo(() => stockPrice());

More is coming. Reactive Server Components are on the team’s list for the next few weeks.

Warnings written for agents

Carniato’s argument is that Solid’s graph already knows what was read, where, and what will update, so it can tell you when something’s off. In most frameworks a reactive slip is silent. The app runs, and it’s wrong. In Solid 2.0’s development builds the mistake gets reported the moment it happens, with a stable code, a spot in your source and a suggested fix.

Annotated Solid 2.0 dev error: stable code, problem, component path, file location, agent repair guide
Each Solid 2.0 dev warning carries a stable code, a location and a fix guide for agents.

Each warning points to a docs page and to a repair guide for agents that ships in the package itself, at node_modules/solid-js/skills/reactivity-diagnostics/SKILL.md. With async in the graph, Solid can also catch waterfalls, effect loops and graphs that fan out too wide. An updated Sentry plugin brings the same detail to production builds. Two syntaxes, ReactiveScript and TSRX, arrive as experiments, both meant to make code easier for agents to write.

The post’s title comes from this system too. “The Long Hold” is a diagnostic that fires once a hold has been shown through isPending and plenty of time has passed since the last input.

SolidStart retires and seven APIs go

SolidStart, the metaframework, is retired. Core now supplies server functions, Request and Response primitives and observability hooks, and framework-agnostic Vite plugins fill in the rest. Anyone who wants to build an opinionated layer on top doesn’t need to rebuild all that. It also means a single Clerk or Sentry plugin can serve every framework. On routing and caching, Carniato says TanStack Query and Router do as much as anything the Solid team built itself.

The API surface shrinks too. createResource, batch, startTransition, on, produce, createComputed and createMutable are all removed, because the new async model makes them unnecessary.

Seven struck-through Solid 1 APIs: createResource, batch, startTransition, on, produce, createComputed, createMutable
Seven Solid 1 APIs are gone because async now lives in the graph.

What an upgrade involves

Don’t expect a find-and-replace. The migration guide frames this as an app-level upgrade and says to move the runtime, renderer, JSX compiler and framework integrations together. A few of the changes it lists:

  • @solidjs/vite-plugin replaces vite-plugin-solid, and Solid 2 doesn’t provide the old solid-js/web or solid-js/store exports.
  • A library that imports removed paths, or relies on Solid 1 effect, store or resource behaviour, needs a Solid 2-compatible release.
  • createEffect splits into a tracked compute function and an untracked effect function, and cleanup is returned from the effect.
  • Store setters now receive a mutable draft, so produce wrappers go away and path arguments become ordinary property writes.
  • Destructuring props in a component’s parameters loses reactivity, and a top-level read of a reactive value in a component body now triggers a warning.
// Solid 1
createEffect(() => {
  document.title = title();
});

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

Its advice is to run your tests in development mode first, so the new diagnostics fire, and then check production client and server builds. A clean type check isn’t enough. Compiler transforms, event delegation, hydration IDs and async scheduling are all runtime contracts, the guide says.

Five years, 23 release candidates

Carniato dates the real work on 2.0 to late 2024, with the roadmap announced in February 2025. The beta landed in March 2026 and the release candidate in August, API frozen. After that came 23 release candidates over 14 weeks, with 971 pull requests merged and 753 issues closed.

Stat cards: 5 years, 23 release candidates, 14 weeks, 971 pull requests, 753 issues
Solid 2.0 took five years, 23 release candidates and 971 merged pull requests.

The bar for calling it stable was a full week with no regression in ordinary app code and no crash or hang anywhere. It took a while. Near the end, he says, the reports were coming from people and agents going out of their way to hunt edge cases in the scheduler’s deepest corners. The Solid docs now cover 2.0.


Discover more from Sulat AI & Tech News

Subscribe to get the latest posts sent to your email.