Beyond Signals: The Next Big Shift in Web Reactivity

Bookmark
Rate this content

Signals and fine-grained reactivity have recently become staples in modern JavaScript frameworks. However, 9 years ago, when Ryan Carniato created SolidJS, the blueprint for the modern framework, that was not the case at all. Today more developers use Signals than ever before, but we are only at the beginning of the journey. Join Ryan as he looks to the future of fine-grained reactivity, web development, and explores what lies beyond Signals.

This talk has been presented at JSNation US 2025, check out the latest edition of this JavaScript Conference.

FAQ

Ryan Carniato is the author of SolidJS, a JavaScript library for building user interfaces.

Signals are primitives used for representing synchronization in front-end frameworks, ensuring that changes in state automatically update dependent computations without reassigning variables.

SolidJS uses signals as a core part of its reactivity model, which allows fine-grained updates without re-running entire components, unlike traditional frameworks that rely on virtual DOM updates.

React has not adopted signals at its core because its re-render model focuses on re-running components, which is philosophically different from the signal-based approach where only specific parts are updated.

Fine-grained rendering allows updates to be localized only to the parts of the UI that depend on the changed data, improving performance by avoiding unnecessary re-renders of components.

SolidJS uses derived async signals to manage asynchronous operations, allowing for parallel data fetching and eliminating client-side waterfalls, which ensures updates occur seamlessly without blocking UI rendering.

Projections in SolidJS are a new primitive that allow for creating derived and granular reactive data, enabling the extension or splitting of reactivity without altering the original data source.

SolidJS flattens the component tree by deferring prop reads to the necessary points, unlike React's context which can cause re-renders down the component hierarchy.

SolidJS embraces controlled mutability for stable references and performance, allowing for granular updates without unnecessary re-renders, contrasting with the immutability favored in functional programming.

Ryan Carniato anticipates further evolution in SolidJS's handling of reactive data graphs, async operations, and expanding the library's functionality with new primitives and features.

Ryan Carniato
Ryan Carniato
29 min
17 Nov, 2025

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Ryan Carniato, author of SolidJS, discusses signals in the front-end world and their impact on reactivity. Signals in Solid JS have revolutionized frontend UI development by bringing signals to the forefront, impacting frameworks beyond React. Optimizing React performance with fine-grain rendering allows for updating only the necessary components, eliminating unnecessary reruns and enhancing performance composition. Mutability in programming offers benefits like stable references and reduced cloning needs. Stores in frameworks like Solid.js maintain references for unchanged data, reducing overnotifications and unnecessary recalculations. Signals enable fine-grained control with push and pull mechanisms, showcasing examples in counters, async operations, and error handling within UI components.
Video transcription and chapters available for users with access.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

SolidJS: Reactivity Unchained
JSNation 2022JSNation 2022
20 min
SolidJS: Reactivity Unchained
Solid.js is a declarative JavaScript library for building user interfaces that addresses performance optimization. It introduces fine-grained reactivity and avoids using a virtual DOM. The Talk explores rethinking performance and reactivity in web applications, understanding reactivity and primitives, and creating DOM elements and using JSX in Solid.js. It also covers rendering components, sharing state, and the advantages of fine-grained rendering and the reactive approach in Solid.js.
5 Years of Building React Table
React Summit 2022React Summit 2022
24 min
5 Years of Building React Table
Top Content
React Table is a popular table library that started with HTML5 tables and transitioned to React. It faced challenges with integration and user requests, leading to the development of React Table. The introduction of the Headless UI pattern and TypeScript support improved the library's capabilities and quality. Generics and TypeScript played a significant role in reducing the code size and improving development. React Table is now going framework agnostic and partnering with AG Grid.
Modern State Management with Vue 3
Vue.js London Live 2021Vue.js London Live 2021
22 min
Modern State Management with Vue 3
Top Content
Vanessa introduces Vue Free and discusses the benefits of using the Composition API. The order of execution and grouping logical units using the Composition API is explained. The Composition API is used for state management and refactoring components. The speaker shares their initial experience with state management using Vuex. Composables are explored as an alternative for state management in Vue 3.
Taking Vue.js to the Backend
Vue.js London Live 2021Vue.js London Live 2021
23 min
Taking Vue.js to the Backend
This talk explores using Vue.js in the backend, specifically focusing on Vue 3 Reactivity. It discusses how Vue 3 Reactivity leverages ES6 proxies to update changes and intercept hooks. The talk also covers implementing Vue.js backend with live demos, showcasing the modification of proxies and the use of reactive functions. It demonstrates the creation of a reactive array and the implementation of join, leave, and message functionalities. The talk concludes by mentioning the possibility of using computed properties and inviting further questions.
Build Your Own Reactivity: A Deep Dive Into Signals
JSNation 2025JSNation 2025
28 min
Build Your Own Reactivity: A Deep Dive Into Signals
Karl Vorden introduces signals for reactivity in JavaScript, aiming to demystify its implementation for better understanding. Signals in JavaScript provide efficient reactivity by updating only the necessary code without extra work. Different frameworks offer signal implementations like createSignal in solid JS, resembling React's useEffect but functioning differently. Vue signals are called refs, created with the ref function, returning an object with a value property. Define effect functions for tracking changes and execution in reactive signals. Explore computed functions for complex operations within reactive signals. Beware of pitfalls with conditionals affecting signal execution.
Why React Should Not Adopt Signals
React Advanced 2024React Advanced 2024
10 min
Why React Should Not Adopt Signals
Today I want to talk about why React should not adopt signals. By adopting signals in React, we can automatically track dependencies for effects and memos, leading to more efficient component rendering. Accessing specific parts of the JSX that read signals allows for fine-grained reactivity across component boundaries. Adopting signals in React requires migrating to single execution components, which only update specific parts of the application. This can become complex when dealing with components that read from different signals. In contrast, React assumes everything can change and enforces this assumption through linters and compilers, leading to more robust code and easier updates. If you're interested in signals in React or need performance improvements, let's chat!

Workshops on related topic

Build a Universal Reactive Data Library with Starbeam
JSNation 2023JSNation 2023
66 min
Build a Universal Reactive Data Library with Starbeam
WorkshopFree
Yehuda Katz
Yehuda Katz
This session will focus on Starbeam's universal building blocks. We'll use Starbeam to build a data library that works in multiple frameworks.We'll write a library that caches and updates data, and supports relationships, sorting and filtering.Rather than fetching data directly, it will work with asynchronously fetched data, including data fetched after initial render. Data fetched and updated through web sockets will also work well.All of these features will be reactive, of course.Imagine you filter your data by its title, and then you update the title of a record to match the filter: any output relying on the filtered data will update to reflect the updated filter.In 90 minutes, you'll build an awesome reactive data library and learn a powerful new tool for building reactive systems. The best part: the library works in any framework, even though you don't think about (or depend on) any framework when you built it.
Table of contents- Storing a Fetched Record in a Cell- Storing multiple records in a reactive Map- Reactive iteration is normal iteration- Reactive filtering is normal filtering- Fetching more records and updating the Map- Reactive sorting is normal sorting (is this getting a bit repetitive?)- Modelling cache invalidation as data- Bonus: reactive relationships