Solid 2 Killed Its Own Meta-Framework

Solid 2.0, now a Release Candidate, fundamentally reworks asynchronous operations, integrating them as first-class citizens within the reactive graph. This eliminates the need for the createResource primitive from Solid 1, allowing computations like createMemo to return promises directly. The framework now natively understands and manages async values, streamlining how fetchUser or similar data sources integrate into reactive flows.

Removing createResource simplifies data fetching logic and cleans up component code. In Solid 1, developers managed createResource outputs, necessitating scattered null or undefined checks when accessing resource values. Solid 2's direct promise return means the reactive graph handles data readiness, removing these checks and allowing components to deal only with plain, defined values.

Boundary primitives have also been re-architected to align with the new async model, improving both developer and user experience. Suspense is replaced by the Loading boundary, which renders fallbacks specifically for initial data absence. ErrorBoundary becomes Errored, largely a rename with underlying reworks, and SuspenseList is now Reveal.

This refined boundary approach significantly improves user experience. Unlike other frameworks that block UI upon promise consumption, in Solid 2, the framework consumes promises on creation into its graph and blocks only where the value is read. This allows the UI to update immediately as individual data pieces become ready, rather than waiting for all requests to finish. isPending tracks subsequent data fetches without tearing down the UI.

Solid 2.0 significantly refines the developer experience for data mutations and effects. A new mutation flow introduces the action primitive, which defines a clear lifecycle for updates. Paired with createOptimistic and createOptimisticStore, this system enables automatic UI rollback: local optimistic changes are transient, disappearing if an API call fails and reverting the UI to the authoritative server state.

Store management simplifies as direct mutation becomes the default behavior. This change removes the need for the produce function and deprecates createMutable, allowing developers to modify store drafts directly. The storePath helper remains available for specific legacy use cases.

createEffect receives a major refactor, splitting into two distinct functions. The first, a tracked 'compute' phase, defines dependencies. The second, an untracked 'apply' phase, executes the side effect, receiving the computed value. This architectural shift eliminates the on helper and allows the defer option to be set directly on the effect.

Effect cleanup also evolves. The apply function now directly returns its cleanup logic, streamlining resource management. onMount has been superseded by onSettled, which fires only after all asynchronous operations within its scope have resolved, similarly returning its cleanup function. The createComputed primitive is removed, its functionality now covered by createMemo or the new split effect.

Solid 2.0 significantly simplifies JSX syntax, reducing framework-specific idioms. The classList prop has been removed entirely; the class prop now directly accepts strings, objects, or arrays. This allows for more intuitive and dynamic conditional styling without requiring manual string concatenation or array manipulation.

Attribute handling also aligns closer with native HTML. attr: and bool: prefixes, previously used for explicit attribute and boolean property binding, are no longer necessary. This change standardizes attribute declaration, removing a layer of Solid-specific syntax for common HTML attributes.

Event handling namespaces, such as on: and onCapture:, have been removed. Events are now managed using standard camelCase props like onClick or onInput, mirroring conventional web development patterns. The use: directive has also been replaced by stackable ref callbacks, providing a more flexible and composable method for custom element behaviors and lifecycle hooks.

List rendering received a simplification. The dedicated Index component is no longer available, with its non-keyed list functionality now integrated into <For keyed={false}>. Additionally, a new Repeat component has been introduced to streamline count-based rendering, providing a declarative way to render a block of JSX a specified number of times. Learn more about these and other changes in the Solid 2.0 RC: The Big <Reveal> - SolidJS blog post.

Solid 2 incorporates a new Rust-based compiler, built upon the high-performance Oxc project. This re-engineered toolchain significantly elevates the framework's build performance. Internal benchmarks indicate compilation speeds ranging from 20x to over 350x faster than Solid 1's previous JavaScript-based compiler, translating directly into quicker development cycles and more efficient project builds.

The updated Vite plugin introduces a potent 'start mode', offering developers a complete application build out-of-the-box. This mode supports both client-only rendering and comprehensive Server-Side Rendering (SSR) capabilities. It integrates core features like server functions directly into the framework's tooling, eliminating the need for separate packages and streamlining project setup for various deployment targets.

This integrated and powerful tooling renders the separate SolidStart meta-framework redundant. SolidStart's established conventions, including its server functions and serving layer, have been absorbed directly into the Solid core or its compiler plugin. This strategic move consolidates the development ecosystem, embedding SolidStart's proven architectural patterns and full-stack capabilities directly within the primary framework, simplifying the overall developer experience.

What is the biggest change in Solid 2.0?

The core innovation is making asynchronous operations a first-class feature of the reactive graph. This allows computations to return promises directly, removing the need for special primitives like createResource.

Is SolidStart being discontinued?

Yes, SolidStart is being retired as a separate meta-framework. Its key features, like server-side rendering and server functions, have been integrated directly into the core Solid 2.0 Vite plugin via a new 'start mode'.

How does Solid 2 handle data fetching without createResource?

Computations like createMemo can now return promises directly. The reactive system automatically understands and handles the async state, simplifying data fetching logic and component code.

Is Solid 2 faster to build?

Yes, significantly. Solid 2 introduces a new compiler toolchain written in Rust, which benchmarks show is over 20 times faster, with some tests showing up to a 355x speed improvement.

What replaces Suspense in Solid 2?

The Suspense boundary has been replaced by Loading. Loading renders a fallback only for the initial data fetch, while subsequent fetches can be tracked with isPending without unmounting the existing UI.