🧭 Decision Guide
Why trending now: The materials show that [email protected] has been released, the repository gained 40 stars that day, and it entered GitHub Trending. The README also highlights Solid 2.0, Streaming SSR, progressive hydration, and SKILL.md/CHEATSHEET.md for AI assistants, but the specific reason for the attention cannot be determined from the materials alone.
Try it if you
-
You are using TypeScript and JSX in a Vite project and want component functions to run only once.The README's “Quick start” and “At a glance” examples use Vite, TypeScript, and JSX, and explicitly state that the component function runs once.
-
Your application needs Streaming SSR, progressive hydration, or hydrate from @solidjs/web.The README's “Key features” and Repository table list Streaming SSR, progressive hydration, and hydrate in @solidjs/web.
-
You want fine-grained state updates using createSignal, createMemo, and createStore.The README's “Key features” lists these reactive primitives and explains that only code depending on changed state reruns.
-
You need a non-DOM renderer or Web Components integration.The README's “Key features” and Repository table list @solidjs/universal and @solidjs/element.
Skip it if you
-
Your target browsers include IE or other sunset browsers.The README's “Browser support” explicitly says that IE and similar sunset browsers are not supported.
-
Your code depends on Solid 1.x examples and you are not prepared to read the Solid 2.0 migration guide.The README's “Coming from Solid 1.x?” and “For LLMs / AI assistants” sections state that the 2.0 API differs from older examples and provide migration documentation.
-
Your synchronous interop logic cannot accept updates being deferred to the next microtask.The README's “Explain this!” section says reads update on the next microtask and that flush() is needed for synchronous interop.
-
Your project does not use JSX, TypeScript, or the Solid compiler chain listed in the README.The README's “Key features” calls Solid TypeScript-first and JSX-first; “Quick start” uses @solidjs/vite-plugin.
Requirements
- Node LTS, the latest Deno, or Cloudflare Worker runtimes; from the README's “Browser support”.
- The last 2 years of modern Firefox, Safari, Chrome, and Edge versions; from the README's “Browser support”.
- For a Vite project, install solid-js, @solidjs/web, and @solidjs/vite-plugin; from the README's “Quick start”.
- For Solid 2.0, read packages/solid/skills/solid-2.0/SKILL.md, packages/solid/CHEATSHEET.md, and documentation/solid-2.0/MIGRATION.md; from the README's “For LLMs / AI assistants”.
First step (verbatim from README)
npx degit solidjs/templates/solid-v2/basic my-app
Watch out
-
Do not use Solid 1.x examples as if they were Solid 2.0 APIs.The README's “For LLMs / AI assistants” section explicitly requires reading SKILL.md, CHEATSHEET.md, and MIGRATION.md first.
-
Dependency changes take effect on the next microtask by default; pay attention to flush() when synchronous behavior is required.The README's “Explain this!” section explicitly mentions the next microtask and flush() for synchronous interop.
-
JSX types must point to @solidjs/web; installing only solid-js is not the complete setup.The README's “Quick start” requires jsx to be preserve and jsxImportSource to be @solidjs/web.
-
solid-js and @solidjs/web share runtime versions, while @solidjs/h, @solidjs/html, and @solidjs/element may version independently.The README's “Repository” section explicitly describes the PNPM workspaces monorepo versioning rules.
Alternatives
-
Solid 1.x:It is a better fit when you have existing Solid 1.x code or examples and need to retain the 1.x API.README “Coming from Solid 1.x?”
-
@solidjs/html:It is a better fit when you need build-less tagged template literals instead of a JSX compilation chain.README “Repository”
-
@solidjs/universal:It is a better fit when you need to connect the Solid runtime to a non-DOM platform or custom renderer.README “Key features” and “Repository”
Not stated in the README
- The materials do not provide the complete Solid 2.0 breaking-changes list.
- The materials do not provide concrete JS Framework Benchmark scores or numerical comparisons with other frameworks.
- The materials do not specify the production build, SSR, or progressive hydration resource costs.
- The materials do not state the size of the official maintenance team; the base data only provides 10 contributors.
- The materials do not provide the dates, contents, or upgrade strategy for the 5 releases.
- The materials do not specify version compatibility ranges for specific ecosystem component libraries.
💡 Deep Analysis
6
No
Our Web application must support IE or similar legacy browsers, while new code should use JSX and TypeScript. Is Solid suitable as the runtime framework?
No. Solid is not suitable because the README explicitly limits SolidJS Core to the latest two years of modern Firefox, Safari, Chrome, and Edge, and excludes IE and similar sunset browsers.
- The Browser support section directly states: “IE and similar sunset browsers are not supported,” which conflicts with a mandatory legacy-browser requirement.
- The README’s Web approach relies on compiled JSX, real DOM operations, and a modern reactive runtime; transpiling syntax does not establish IE runtime compatibility.
- The README supports recent desktop and mobile Firefox, Safari, Chrome, and Edge, but does not promise support for older versions or provide an IE polyfill solution.
Therefore, JSX and TypeScript are not the deciding issue. The blocking constraint is the officially stated browser support range.
- README Browser support: "SolidJS Core supports the last 2 years of modern Firefox, Safari, Chrome, and Edge"
- README Browser support: "IE and similar sunset browsers are not supported."
- README Why Solid? / Pragmatic: "Built on JSX and TypeScript"
No
I maintain a Solid 1.x application, target [email protected], and use AI to generate component code. Can I upgrade only the npm dependency without checking APIs individually?
No. A dependency-only upgrade is not appropriate because the README explicitly warns that Solid 2.0’s public API differs from examples written before 2.0, and 1.x is not fully drop-in compatible.
- The README directs migrants to
documentation/solid-2.0/MIGRATION.md, showing that the upgrade requires API and behavior checks. - Before generating AI code, the project requires reading
SKILL.md,CHEATSHEET.md, and the migration guide; it specifically warns that older examples can produce incorrect 2.0 code. - Solid 1.x remains maintained on the
1.xbranch and can be installed withnpm i solid-js@v1-latest, so the versions can be compared, but their mental models should not be mixed. - Project data identifies
[email protected]as the latest release, so the upgrade should also verify compatibility among Solid, compiler, and renderer packages.
Copying old Effect, async, or control-flow patterns directly may produce unexpected behavior.
- README For LLMs / AI assistants: "The public API differs from any Solid examples that predate 2.0."
- README For LLMs / AI assistants: "Before generating Solid 2.0 code, read... SKILL.md... CHEATSHEET.md... MIGRATION.md"
- README Coming from Solid 1.x?: "Solid 1.x is maintained on the `1.x` branch"
- Project data: latest_release is `[email protected]`
npm i solid-js @solidjs/web
Yes
I need SSR on Node LTS, Deno, or Cloudflare Workers, with a gradual adoption of streaming SSR and progressive hydration. Does Solid meet this deployment constraint?
Yes. Solid fits this deployment constraint: the README explicitly lists these server runtimes and treats SSR, streaming output, and progressive hydration as first-class Web capabilities.
- The Browser support section explicitly supports Node LTS, the latest Deno, and Cloudflare Worker runtimes.
- Key features lists “Streaming SSR and progressive hydration,” rather than only conventional one-shot server rendering.
- The Powerful section describes full SSR, streaming, and progressive hydration as capabilities that can be adopted when needed.
@solidjs/webowns browser DOM, SSR, and hydration capabilities, whilesolid-jsprovides renderer-neutral component types, enabling a shared component model across server and client.
This is not zero-configuration deployment: server data boundaries, hydration consistency, and async timing still depend on the target runtime and application architecture.
- README Browser support: "For server environments, Node LTS, the latest Deno, and Cloudflare Worker runtimes are supported."
- README Key features: "Streaming SSR and progressive hydration."
- README Why Solid? / Powerful: "Full SSR, streaming, and progressive hydration"
- README Quick start: "`solid-js` owns renderer-neutral component types, while renderer packages such as `@solidjs/web`..."
npm i solid-js @solidjs/web
Yes
We are building a highly interactive Web application with TypeScript, JSX, and Vite, where lists and state change frequently. Is Solid 2.0 suitable as an alternative to a Virtual DOM-based approach?
Yes. Solid 2.0 is a good fit because it compiles JSX into real DOM operations and updates expressions rather than re-rendering components or diffing an entire tree.
- The README explicitly says Solid does not use a Virtual DOM; when state changes, only dependent code runs.
- Component functions run once on mount, while expressions such as
{doubled()}become tracked updates, which fits frequent local changes. createSignal,createMemo, andcreateStoreprovide fine-grained reactive state management without requiring a separate full state layer.- The README also lists tree-shaking and low runtime cost, describing performance as close to optimized vanilla JavaScript.
The benefit still depends on precise state modeling. Broad Stores or unnecessary Effects can reduce the advantage.
- README: "Instead of a Virtual DOM, it compiles templates to real DOM nodes and updates them with fine-grained reactivity."
- README: "The component body runs once. Only `{doubled()}` updates when count changes."
- README Key features: "Fine-grained updates to the real DOM" and "Declarative reactive primitives"
- README Why Solid? / Performant: "runtime cost is close to optimized vanilla JavaScript"
npx degit solidjs/templates/solid-v2/basic my-app
Yes
We use TypeScript and modern browsers and need to integrate Promise, AsyncIterable, loading states, and optimistic updates into UI state. Can Solid 2.0 cover these requirements?
Yes. Solid 2.0 is a good fit because it places async computations and optimistic updates inside the reactive model rather than supporting only synchronous UI state.
- Key features explicitly support Promise, AsyncIterable, async boundaries, and
isPending, connecting async results with reactive UI computation. - The README also lists
createOptimistic,createOptimisticStore, and structuredaction(...)mutations for optimistic interfaces and async changes. createSignal,createMemo, andcreateStoreare built-in primitives for expressing state, derived values, and object state in TypeScript and JSX components.- The supported browser range is the latest two years of Firefox, Safari, Chrome, and Edge, matching the stated deployment constraint.
The README does not prove that Solid replaces a particular data layer or request library. External caching, retry, and persistence strategies still need separate evaluation.
- README Key features: "First-class async: any computation can return a `Promise`/`AsyncIterable`"
- README Key features: "Optimistic UI primitives (`createOptimistic`, `createOptimisticStore`) and structured `action(...)` mutations."
- README Key features: "Declarative reactive primitives (`createSignal`, `createMemo`, `createStore`)."
- README Browser support: "last 2 years of modern Firefox, Safari, Chrome, and Edge"
npm i solid-js @solidjs/web
Yes
We want to reuse TypeScript, JSX, and reactive logic on a non-DOM platform instead of rendering only browser pages. Does Solid’s architecture support custom renderers?
Yes, provided that your team is prepared to implement and maintain the renderer for the target platform. Solid separates its reactive core from platform-specific rendering.
- The README says
solid-jsowns renderer-neutral component types, so the component model is not tied to browser DOM. @solidjs/universalis explicitly provided for writing custom renderers targeting non-DOM platforms.- Renderer packages such as
@solidjs/weband@solidjs/hown their JSX namespaces andjsx-runtimetype entries, showing that platform adaptation sits outside the reactive core. - The project insight also describes cooperation among the compiler, reactive runtime, and platform renderers for Web Components, custom renderers, and non-DOM targets.
This makes Solid suitable for teams with platform-rendering expertise, but it does not mean that ready-made component libraries exist for every non-DOM target.
- README Key features: "Universal: write custom renderers via [`@solidjs/universal`] to target non-DOM platforms."
- README Quick start: "`solid-js` owns renderer-neutral component types"
- README Quick start: "renderer packages such as `@solidjs/web` and `@solidjs/h` own their JSX namespaces"
- Project insight solution_analysis: "core runtime is decoupled from platform rendering"
npm i solid-js @solidjs/web
✨ Highlights
-
createSignal updates only the changed DOM expression
-
Components run once on mount without Virtual DOM diffing
-
Supports Promise, AsyncIterable, and streaming SSR
-
[email protected] provides a TypeScript-first JSX experience
-
The Solid 2.0 API differs from older examples
🔧 Engineering
-
solid-js provides the createSignal, createMemo, and createStore reactive primitives
-
@solidjs/web provides render, hydrate, SSR, Portal, and dynamic
-
Promise and AsyncIterable values can drive computations with Suspense boundaries
-
Streaming SSR and progressive hydration support progressive server rendering
⚠️ Risks
-
The Solid 2.0 public API differs from some Solid 1.x examples and patterns
-
Updates are batched to the next microtask; flush() is needed for synchronous interop
-
IE and similar sunset browsers are outside the SolidJS Core support range
-
The PNPM workspaces monorepo has different versioning rules for runtimes and compilers
👥 For who?
-
Teams building modern web UIs with TypeScript, JSX, and Vite
-
Applications requiring SSR, streaming output, or progressive hydration
-
Developers needing custom renderers or Web Components integration