I'm one of the authors of the @preact/signals library and this is by far the best video about signals and why they are so exciting. I love the way you demonstrate it by coding along and moving an app over to signals. That's a fantastic way of showing the benefits. Thanks for making this video!

Wow, this is a paradigm shift for me. This will completely change how I manage states from now on, in a good way! Thanks for the video Kyle! Looking forward to a video showcasing what else this can do!👏

This is an insanely helpful and informative video! 100% would love a full crash course!

This makes me excited to code in react once again. A crash course on signals would be much appreciated but also make sure to cover its shortcomings, if there are any.

This is amazing!!!!!! React + signals (easy state management) + improved performance! What else would I want in life? Thank you Kyle!!!!!

epic! Coming from svelte-land and needing to implement signals in my app so it's easier to maintain and update state between components. This showed me multiple concepts I hadn't grasped/thought of from other signals videos yet! Appreciate the timely + informative video! Would love to see more content on signals! fav takeaways: 1. Signals can reduce triggering needless component re-renders when your apps state has moved up to top-most components. 2. We can place our main backing logic in other locations than the parent components and use signals to interact with only the needed parts e.g. sibling component communication. 3. We can use computed signals to add additional functionality to existing signals e.g. getting the length of an array using another signal which is that array. 4. Coming full-circle, we can still have our backing code in the parent component, and simply pass that signal into our child components. Only the child components who reference that parent component via the signal will be re-rendered when the signal's value changes! on 4... This makes me think we can potentially do the scaffolding for the signal in another file entirely and just import it into the parent component and then pass it into our child component? Can't wait to bring these back to svelte and apply them there!

This library makes our lives so much easier. It makes so much sense, as it enhances clarity and enforces cleaner code, in the end. Great explanations, Kyle!

Dropping bombs on us, Kyle. Love it. I checked out vanilla JS signal patterns and moved on, using context and custom hooks. This pattern looks like a winner.

This video just blows my mind, if been struggling quite a lot with hooks and signals just simply everything to an absurd level. Thank you for this piece of gold content.

Great video but you missed the best feature: when you render a signal in JSX, without ".value", it renders the signal as a TextNode, and it re-renders just that TextNode when the signal changes without re-rendering the component! This provides HUGE performance gains and is the main reason to adopt signals!

Pretty cool thanks for exposing me to this Kyle. Amazing it works within react too, making it able to be leveraged inside our existing apps easily. I plan on using this in my high level state for sure.

Thank you for sharing your knowledge. I am waiting for full course

Nice video! I'd be curious to see a comparison between preact signals and other state alternatives using similar constructs like redux, zustand, etc, as maybe a follow-up idea.

I'd love a crash course on signals! Thank you for being so clever and awesome!

The part with exporting the signal and using it anywhere in the app blows my mind. That is a great one! Thanks

What a timely video. I was struggling with React's hooks due to the complicated parent-child relationship that you mentioned. Thanks.

Tested it in large project by adding it in one place and it completely broke another unconnected place that uses a lot of hooks, because: ""In addition to overriding React's public API, Preact Signals works by taking React internals and patching them while relying on fragile assumptions about how they work. This library is an entirely unsupported way to use React. The only reason it isn't constantly breaking is that we haven't done stable releases recently."

Very straightforward and clear explanation! 👍

Man, this is way too cool! I feel like this is how things should be. Feels much more intuitive and natural as opposed to the growing complexity of hooks. Especially for newer developers like myself. I'm working on an app right now, and it consistently gets more complex with hooks and passing data, and this will make it soooo much easier. Great demo for Preact Signals! Thanks a lot!

WOW, I can't believe I didn't know about it, I will implement it in one of my projects as soon as possible. thank you very much.

Looks fun and easy to use, great video! I would love to see an example in a large project. For example managing lots of signals and/or splitting them into different files.

If these work with React Native, signals are really gonna transform the whole React ecosystem. I'm really happy to see people actually taking notes from all the react alternatives, like Solid, Qwik, etc., and actually creating real solutions to React's biggest down sides.

U change a LOT of ppl's lives for the better. Good on u dude! Big fan

It’s a awesome demo of what signals solve in everyday situations. It’s just funny that there’s a huge hype around it right now, when Vue did it some time ago. It just boosts my respect towards Evan You and the whole team behind Vue.

An incredibly interesting and formative video as usual! It's great to see that, lately more and more React library developers are embracing inspiration and key concepts from other libraries, rather than the usual scenario where other libraries draw from React. The only minor concern with these Preact Signals is that they access React's secret internals and React JSX runtime function. This can sometimes lead to unpredictable behavior in a production environment. I'd be eager to hear your thoughts on this. I've conducted a small experiment with 'signals-for-react,' a package that aims to implement signal-like primitives for React without relying on or overloading the React source code. However, it's a bit more verbose compared to Preact's solution at the same time.

Great explanation and example. It's so much better to see a working example instead of dummy functions. I really enjoy it. Now about signals, it makes me a little cautious because everything looks very... global? Should I use this only for global stuff? How to know when to use? Also, how to organize them in a large project? I'm guessing those questions are going to wonder for a while, but I'm excited regardless. Thanks for this video!

this is really exciting!! definately going to try it out in my next project. would love a crash course on signals.

Thank You kyle, amazing video as ever. I have believed for some time now that all logic can live in vanilla JavaScript/TypeScript files rather than mixed in with React creating messy code. As you have demonstrated, Signals achieve this. Hopefully this approach can become more mainstream and see a shift to cleaner React code. As the author of the not so popular outer-state library, I'm delighted to see the same philosophy and simplification of state management promoted this way.

wouldn't mind more content on signals, this looks amazing! I hate state management in react, and this looks like the perfect solution

Hi Kyle, thank you for your content! I see that this library still solves basic state management problems, so my question is why do you think (if you do) this is better than zustand for example that has tools for persistence in box or atom if you need lightweight solution? I’ve started to use them in my work and very satisfied, maybe I missed some point here in this video. Thank you in advance

Thanks so much for sharing, would love to see more about signals 👀

That's the way to do it! Full React Signal Course would be much appreciated! Thank's for publishing!

Hey! You have many great contents. And I value what you do. Thank you for that. But doesn’t this approach break the one pillar react stands on? I.e unidirectional data flow? If we pass data to a component up the tree, it makes it incredibly hard to debug and read. One other major thing this goes against is the Command Query separation. Which helps us know if a piece of code changes state or consumes it. And useState, useReducer, redux have by default. Is there anything am not seeing? Please correct me if am wrong.

So it basically works like Vue 3. I'm glad that React devs start to realize what they've been missing out on.

A crash course would be awesome. Thank you for putting out great videos!

absolutely clean explanation on this topic. Thanks for sharing!

Thanks for this! Really well timed, Svelte just announced Runes which are based on signals. I think they realized how awesome signals are and how well they’re already working in other frameworks, especially in large-scale projects

Welcome to the Vue 3 composition API! Proudly using 'signals' in its reactivity since September 18, 2020.

Would love the crash course. Thanks for your time on this.

can you make a video about the shortcomming of signals and why someone may not want to use them? you make them seem like a magic to a lot of react problems but i know there's always a catch

Btw: Meteor introduced Tracker which is very similar to signals in 2012. It is always amazing how those concepts get forgotten and then pop up as the next new hot thing…

1274 comments and still waiting for that crash course link at the end of the video. Great job, KUDOS. to you and the team behind this awesome library!

Wow - this is amazing! I'm currently learning react and got really frustrated with the state management, since it was adding soo much noise and the code flow felt broken into tiny pieces with no clear structure.

I think there are trade-offs for both. I've used signals in large codebases and they can become very hard to debug/untangle once you have complex relationships. I think solid handles this better with explicit setState rather than implicit.

The reactivity of signals is very like Vue (specifically Vue 3 Composition API). I would encourage anyone to try Vue 3. It just makes sense. React is a headache.

Love your content mate, clear and easy to follow

🤯 fantastic video! Absolutely up for that course!

Rendering optimizations With signals we can bypass Virtual DOM rendering and bind signal changes directly to DOM mutations. If you pass a signal into JSX in a text position, it will render as text and automatically update in-place without Virtual DOM diffing: const count = signal(0); function Unoptimized() { // Re-renders the component when `count` changes: return {count.value}; } function Optimized() { // Text automatically updates without re-rendering the component: return {count}; }

Amazing video. Vue3 has ref, watch and computed available within as an equivalent of signal, effect, and computed explained in the video.

Loved the content. Very well explained. Thank you very much!

I really want to see your course on this!

So aside from persisting the state, would signals be a viable replacement for state management libraries like Redux and Zustand? Seems fairly similar in utility.

I'd be interested in peoples thoughts on using Signals vs. Recoil. Are they basically delivering the same functionality? Are there different uses cases for each? What are the pros & cons of each?

Your Halloween demo is amazing. You have "hooked" 🙂 me on Signals. Looks to me Preact is an even preferable alternative, as Signals is natively part of it.

Great video! Thanks Kyle as always! 👍 P.S: Can you do the full-length tutorial about Signals, please?

I think this's just another approach. We can use different syntaxes (or libraries) but looks like the data flow and rendering logic did not change much. In my opinion, reactive things sometimes can be quite magic, especially in large codebase it will be hard to debug. Signals and React hooks can still exist equally and choosing which one depends on the personality of developer, like choosing framework for your project.

Splendid video! Great to know that this kinda of tech exists.

This Signal really is something, Plz make full course.‼

Still not as fine-grained as Solidjs because of the limitation of the react re-rendering mechanism. The smallest unit of update/re-render is still at the component level, whereas in solid, it can go down to a piece of style or part of the text on an element, since the update is on the browser DOM directly in solid. So with preact-signal for react, the level of granularity depends on how small your component is, so it doesn't offer too much added benefits over other global state management libraries like Redux, Valtio... All the benefits described in the video actually come from the separation of state and component. If you really want to achieve the finest level of granularity, you have to ditch the middle man - virtual dom and the re-rendering mechanism, which basically means, not react. But if you still use react, as least choose one of the global state management libraries and move all your state outside of your component, most of your troubles will go away.

Its nice but it seems to me like a more concise version of Jotai or redux basically without so many rules. I mean as your application grows you want to separate your state from your components more and more as it can get pretty complicated. I see this working but I would personally need some organisation around the signals element otherwise it could get unruly especially in a team of devs. But nice presentation and concept explained well.

This is really great, I always wanted to be able to import state from other components

Such an amazing teacher!. you really have a gift. Keep the good work coming :)

I am particularly excited about the potential of Preact Signals technology, but I have some reservations when considering its application beyond simple state updates between small components. Specifically, I'm curious about its use in more complex scenarios, such as a flight reservation system where seat selection impacts seat availability, total pricing, and can trigger various discounts or alerts based on intricate criteria. Would Preact Signals be adept at managing such a level of detailed and interconnected component coupling ?

The existence of signals in react is awesome. If i have to write react again most probably i'll use these hooks rather than terribly messy hooks.

Thankyou so much you really simplified web dev for me, I would love to have crash course on signals.

A crash course about signals would be so appreciated!

00:02 Signals make it incredibly easy to use powerful stuff without complex rules and with default performance 01:47 Using signals or state doesn't make a difference in simple applications. 03:16 Signals solve unnecessary renders and provide default performance 04:52 Signals library is powerful and can be used with various JavaScript frameworks including preact. 06:30 Using signals to automatically update code 08:08 Signals provide a way to store and update values, solving the need for useState. 09:47 Signals library provides built-in useEffect functionality. 11:24 Using signals allows for efficient updates to components based on the changing data 12:59 Signals allow easy sharing of information between components and improve testing 14:42 Extracting and passing down signals makes testing and performance gains easier. 16:21 The video talks about signals and how they are better than React hooks. Crafted by Merlin AI.

I am coming from vue background into react. regardless of whether vue hooks ref(), reactive(), watch(), watchEffect() are actually signals or something similar. When I used react I felt I am heavily constrained by a lot of rules and way to do things, and the re-render everything when something changes. the things I simply and intuitively do with vue, or even solid or qwik or svelte, are very hard to do within react. the problem is in some environments, react is a tabo, and criticizing it is forbidden! this preact signals actually saved the day.

NICE! IMHO, Signals is a game changer! I vote YES for a complete course. Thanks, Kyle!

I'm glad Preact recommends pulling the singals out to their own files. I would absolutely hate keeping both the components and their states in the same files.

When Kyle adds a new item to a signal at 09:15, I noticed that he spreads the current signal value (making a copy of the array) instead of mutating state directly using the .push() method. In Vue you can do this and it blew my mind when I discovered this because it simplifies thinking about state. You don't have to worry about the React rule where you're not supposed to mutate state. You can simply push an item to an array to update the state and call it a day. So simple.

Finally people find out Vue is actually doing the right things😂 React + Signals = Vue 3

Actually quite interesting. I wouldn't call this a complete replace for useState and all, especially for very locally used values, but it is really good to know about these. Especially not being limited to a component scope is neat.

Crash course would be amazing! Thank you for the video! :)

The problem with these approaches is that the abstract away a lot behind the magic and when something goes wrong it’s REALLY hard to debug if you don’t understand the internals (which are usually pretty complicated). Still, great way of cutting out boilerplate.

Update: Signals sounds really awesome. Will it work on server components though? Original: I wouldn't put all of the hook logic in the parent component (which you did in the beginning of the video to add count to header). Since you only need count, you just need to add a state variable in the parent to hold the count, then pass the state value to the header component and the setter function to the Todo form component. That would be much cleaner and keeps the main logic still inside the form component, but still communicates the necessary info upwards and outwards.

looking forward to the course : )

*Two lovely guitars making love on the background, soon we`ll see the little mandolin also*

Video title should be "Why Signals Are Better Than React useState" There's a lot more to React Hooks that just state management and signals or other state management libs are not a one-to-one replacement.

That is why i'm using vue (and solid). Because it's too easy to make something wrong in react (and it's harder to do so in vue). And i like to see that preact team trying to change that. And svelte team is implementing signals too (svelte 5 runes)

Signals look interesting. As someone who is still fairly new to React but getting a lot of exposure right now, one thing I have struggled with is getting States to update the way I need them to at times. That has probably been the most frustrating part of my React journey so far

Cool stuff! Thanks for sharing! Just a quick note, from the npmjs page, it says that using "count.value" is unoptimized, and the direct signal "count" should be used without ".value" to be optimized.

Thank you so much Kyle! Such an awesome video. Please please make a crash course on Signal, PLEASE! 🙏🏻🙏🏻🙏🏻🥹

so... we've just discovered Vue 3 basically. Vue has had this for years 😂

I hate hooks mostly since the unnecessary re-renderings. This seems something to me, thanks for the video. I'm starting to give it a try !

Please do another in-depth video about this topic...I've been in state management hell for so long, I see a glimmer of hope at the end of the tunnel...

The pattern of separating out the signals into a separate higher level file and then passing it into components is a lot like context (and undoubtedly when you have a large, complicated app tons of things end up getting pulled out into this pattern), but with built-in optimization and more flexibility/granularity.

I want a full crash-course of signals inside Angular

I think most of what React devs want signals for can be accomplished through react context. That said, whenever I find myself memoizing like every value in my state, I definitely start wishing I could just have a magic portal to shoot important values through.

DAMN, I love Solid for it's use of signals, had no idea you could use a library to use them in React!

Speaking from experience, this looks like a great tool. Like using a message bus but easier. And with that being said, be careful where you modify your state. This can become messy if you don't set a rule for your project on what files can modify and which ones can read only.

its crazy how we already had rxjs, but react managed to make something worse lol

A side-by-side comparison with Redux would be interesting

Wow this is insane, definitely will give it a try, thank you

Wow! This was the best suggestion I've seen lately for React. Do you know how this would work out with the new RSC in NextJS? Would I need to only use them in Client Components?

very happy for the React community that they finally got some Vue3 capabilities haha, sad that they have to install another lib for that though.

I believe that you are going to absolutely love Vue if you value the performance and simplicity of signals this much. Would love to see Vue vidoes from you.

Great video! thanks! i think this is what the new framework "Solid JS" is all about. it introduces and uses the "createSignal" hook instead of "useState" which eliminates the need to rerender the whole component when a value changes, just all the places it was used! and one more important thing is that using signals in Solid-JS (i'm not sure how it works in the library you were showing) you won't even need state management and store libraries like redux. you can just create a signal outside of a component and use it wherever you need and the data will persist across all of the places it was used with no effort!

Good Content, have a quick doubt, so can signals also be used for global state instance replacing apiContext?

Singleton and observer pattern