Preact Signals

This page summarizes the projects mentioned and recommended in the original post on

Our great sponsors
  • Sonar - Write Clean JavaScript Code. Always.
  • Scout APM - Truly a developer’s best friend
  • InfluxDB - Build time-series-based applications quickly and at scale.
  • Zigi - Close all those tabs. Zigi will handle your updates.
  • signals

    Manage state with style in every framework

    The implementation involves unsafe monkey-patching, at least for React:

    1. A hook is injected into every single component (!) so that if you use signals, they can perform a re-render.

    2. React.createElement is patched so that it can render signal values as Text nodes.

    [1] -

    [2] -

  • solid-site

    Code that powers the platform.

    Don't get why you would use it over Solid ( I guess to keep compat with React ecosystem but moving React components to Solid is trivial.

    I feel like Solid signals have better DX too.

  • Sonar

    Write Clean JavaScript Code. Always.. Sonar helps you commit clean code every time. With over 300 unique rules to find JavaScript bugs, code smells & vulnerabilities, Sonar finds the issues while you focus on the work.

  • MobX

    Simple, scalable state management.

    I guess it's similar to this MobX :)?

  • flimsy

    A single-file <1kb min+gzip simplified implementation of the reactive core of Solid, optimized for clean code.

    These are difficult to understand concepts imo. I have written an annotated implementation of a simple reactive system (you may want to run it through Prettier if that's your thing):

    A signal is basically a function that you have to go through to read and write a value. In the case of Preact the function is split into getter and setter assigned to the "value" property. The interesting thing about signals is that they can tell their parent computation to re-execute, automatically, without any manual dependency array.

    A computed is a signal generated from a function rather than a primitive. So like the function that generates the value is re-executed automatically whenever any of the signals read inside it change.

  • blog

    FWIW, one specific counter-example would be Etsy choosing to adopt Preact to migrate upwards from React 15:



  • Preact

    ⚛️ Fast 3kB React alternative with the same modern API. Components & Virtual DOM.

    For Preact, there is a TODO pointing to [1] which was merged in 10.10.3, so hopefully that can be fixed soon?


  • dependable-view

    View layer for @dependable/state

    Really interesting to see Preact adopt this kind of model.

    I have been working on a similar programming model for a while, where this kind of state management is the only approach:

  • Scout APM

    Truly a developer’s best friend. Scout APM is great for developers who want to find and fix performance issues in their applications. With Scout, we'll take care of the bugs so you can focus on building great things 🚀.

  • dependable-state

    Observables and computeds for state management

    The library has other kinds of agendas like being able to run without a build step, being really small and allow multiple versions in the page.


  • dependable-example-hackernews

    Hackernews example using @dependable

  • dependable-example-todomvc

    TodoMVC example in @dependable/view

  • jotai

    👻 Primitive and flexible state management for React

    I suggest using jotai for atomic state management. What they're trying to do is nice, but I think it's full of unnecessary complexity.

  • moment

    Parse, validate, manipulate, and display dates in javascript.

    But some libraries are not build with performance in mind and libraries like [momentjs]( have proved to be performance bottlenecks on many occasions.

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts