what stackpulse tracks
SolidJS releases from GitHub
StackPulse watches SolidJS release notes and keeps the original source link close to every summary.
Simple and performant reactivity for building user interfaces StackPulse turns upstream changelogs into scannable summaries with risky changes, deprecations, migration notes, and source links.
what stackpulse tracks
StackPulse watches SolidJS release notes and keeps the original source link close to every summary.
upgrade risk
Risky changes are separated from normal feature notes so you can scan upgrade impact before changing production dependencies.
migration notes
Migration steps and recommended actions are only shown when the upstream release notes support them.
This prerelease delivers a broad set of correctness and performance fixes across streaming SSR, hydration, live server components, DOM updates, and reactive holds. It also improves list reconciliation and preserves connected DOM nodes during reorders, while introducing a new development warning for invalid HTML nesting discovered during hydration.
SolidJS web users may see improved SSR, hydration, reactive-update, and list-rendering reliability and performance; code using host-tagged `insert` outside Portal needs an explicit setup call.
If your code uses `insert(..., { host })` outside `<Portal>`, add `installHostTagging()` before using it.
This prerelease refines runtime attribution and flush reporting, adding per-drain change records while simplifying internal attribution hooks. It also fixes issues across refs, async holds, server rendering and streaming, dynamic mounts, controlled inputs, and head tags; development builds gain additional diagnostics.
SolidJS 2.0 prerelease users are affected, especially developers relying on flush attribution, refs, async updates, or server rendering and streaming.
This prerelease adds `setTrustedTypesPolicy(policy)` to support rendering on pages that enforce Trusted Types for scripts. The supplied policy’s `TrustedHTML` is used for compiled template markup, server HTML parsed by the client, and `html` tagged-template text decoding; the function is a no-op on the server and has no effect for apps that do not call it.
Applications running under Trusted Types enforcement are affected if they need to render; they can pass a Trusted Types policy to the new API, while other applications are unchanged.
For applications enforcing Trusted Types, create a Trusted Types policy and pass it to `setTrustedTypesPolicy(policy)`.
This prerelease fixes ref callbacks interacting incorrectly with held async-memo updates, preventing updates from remaining stuck. Ref callbacks now run untracked in the context of the pass that creates the element, so their reads see the state being built rather than pre-commit state.
Applications using ref callbacks with async memos or optimistic writes may see previously stuck updates or hidden non-keyed branches recover correctly; in development, creating reactive primitives or calling onCleanup inside a ref callback remains forbidden.
This prerelease contains extensive fixes to async memo and display-ahead behavior, including keeping fallbacks visible while held writes or async work are pending and preventing stale or mismatched values from appearing. It also improves store chaining and projection liveness, reduces attribution-engine retention of disposed scopes, and introduces a flush change-recording API; the notes are truncated during the attribution changes, so details beyond the visible portion are unclear.
SolidJS Signals users relying on async memos, optimistic actions, display-ahead gates, derived stores, or attribution tooling are affected; the change-recording API may also affect consumers of flush records.
Review the prerelease changes if you use attribution hooks or consume flush records, and test async memo, optimistic-action, and display-ahead behavior before upgrading.
This prerelease fixes several SSR and streaming correctness issues, including concurrent render context isolation, stylesheet loading gates, and streams that previously could hang or leave client-side promises pending after aborts or serialization failures. It also improves preload prioritization, asset-manifest typing, server-function behavior, and rendering performance; `solid-js` is updated to 2.0.0-rc.21.
SolidJS applications using server rendering, streaming, server functions, asset manifests, or the affected RC `createOwner` API may see behavior or typing changes.
If your RC application uses `createOwner`, migrate that usage to `createRoot()` and `runWithOwner()`; otherwise, review the SSR and streaming fixes relevant to your application.
This prerelease updates dependencies, including @solidjs/web to 2.0.0-rc.21. The release notes provide no further details about the changes.
Users of @solidjs/html receive an updated @solidjs/web dependency.
This prerelease updates dependencies, including solid-js to 2.0.0-rc.21. The notes do not describe any other changes.
Users of @solidjs/universal are affected by the updated solid-js dependency.
This prerelease is primarily a broad set of correctness fixes for derived stores, async/pending computations, transitions, and `<Loading>`/`<Errored>` boundaries. It also improves store snapshot consistency and adds a development-only diagnostic for reactive reads whose thrown errors are caught inside a computation.
Users of derived stores, async computations, transitions, and loading or error boundaries may see corrected pending, error propagation, recovery, and rendering behavior.
This prerelease includes fixes for hydration recovery and truncated-stream handling, plus improvements to reactive pending-state reads and hot reload argument forwarding. It also adds a development-only diagnostic for caught reactive-read errors and removes `createOwner` from Solid's public types.
Applications relying on the RC's public `createOwner` typing need to update their scope management; users of hydration, pending-state reads, or hot reload may benefit from the fixes.
If your application uses `createOwner`, migrate to `createRoot()` and `runWithOwner()` before upgrading.
This prerelease fixes several async store and boundary behaviors, including pending-state reporting, derived-store updates after resolution or recovery, and hydration and streaming edge cases. It also improves shallow-store array performance and narrows the development warning for multiple Solid instances to copies that actually interact.
SolidJS 2 prerelease users working with async memos, derived stores, hydration, streaming, or large shallow-store arrays may see more correct behavior and faster array operations.
This prerelease updates dependencies, including @solidjs/web to 2.0.0-rc.20. The notes provide no further details about the dependency changes.
Users of @solidjs/html may be affected by the updated @solidjs/web dependency.
This prerelease improves direct server-function call performance by avoiding unnecessary copies of plain objects and arrays in returned values. It also fixes duplicated or replaced streamed content when a client begins hydrating mid-stream and a loading boundary has a bare-string fallback.
Applications using direct server-function calls may see faster result handling, and applications hydrating streamed content may avoid duplicated or incorrectly replaced loading-boundary content.
This prerelease updates dependencies, including solid-js to 2.0.0-rc.20. The notes provide no further details about the changes.
Users of @solidjs/universal are affected by the dependency update to solid-js 2.0.0-rc.20.
This prerelease primarily fixes reactive consistency and recovery issues involving async memos, transactions, `isPending()`, `latest()`, and `<Errored>` boundaries. It also reduces core bundle size for apps that do not use the related async and optimistic-lane features, with no behavior change from that optimization.
Applications using async memos, actions, `isPending()`, `latest()`, optimistic lanes, or error boundaries may see corrected pending, rendering, and error-recovery behavior.
Upgrade to this prerelease to receive the reactive consistency and error-boundary fixes if your application uses the affected features.
This prerelease improves server rendering and hydration reliability, especially for streamed async reads, failed boundaries, and hydration during an in-progress stream. It also improves focus preservation and event replay behavior, while fixing DOM insertion and event-dispatch edge cases.
SolidJS applications using server rendering, streamed boundaries, hydration, or dynamic list reconciliation benefit from these correctness and behavior improvements.
Upgrade to this prerelease to obtain the server-rendering, hydration, and focus-preservation fixes.
Static HTML attribute values now decode character references using the HTML parser’s quoted-attribute rules, matching the existing behavior for text children. This fixes literal entities in rendered attributes and ensures components receive decoded static props; the release also updates the @solidjs/web dependency to 2.0.0-rc.19.
Users rendering static HTML attributes or passing static attribute values as component props are affected by the change to entity decoding.
This prerelease fixes the placement of dynamic child regions in universal-renderer elements when the region renders an empty fragment. The region retains its sentinel while empty, so later content is inserted at the correct position among siblings rather than after them.
Users rendering dynamic empty fragments in universal-renderer elements are affected by the corrected sibling placement.
This prerelease fixes numerous server-rendering and hydration edge cases involving asynchronous memos, `<Loading>` and `<Errored>` boundaries, streamed output, and client updates. It improves fallback rendering and adoption, error propagation and recovery, and prevents rendered JSX-like output from being incorrectly treated as async memo data.
SolidJS 2.0 prerelease users relying on SSR, streaming, hydration, or async boundary behavior are affected; async memos that return rendered output must be adjusted.
Update async memos that return JSX or other rendered output to return data instead, and render the output separately.
This prerelease fixes numerous issues in async memo, hydration, boundary, and derived-store behavior, including correct pending/error propagation and streamed rendering recovery. It also adds the `onFlush(fn)` API for running work after a pending flush and exports the internal flush-round counter `clock`.
Users of async memos, hydration, loading/error boundaries, and derived stores benefit from the behavioral fixes; applications may also use the new `onFlush` API.
Review the `onFlush(fn)` guidance before using it, particularly the development warning against calling it in a component body or computation.