Solid.js feels like what I always wanted React to be

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • Appwrite - The Open Source Firebase alternative introduces iOS support
  • talent.io - Download talent.io’s Tech Salary Report
  • Scout APM - Truly a developer’s best friend
  • SonarQube - Static code analysis for 29 languages.
  • solid

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

    This is interesting because it's a bit like Svelte, but it doesn't use the Svelte "language" (which looks like JS and HTML but, in some crucial ways, sometimes isn't).

    It's a little disheartening to see that it's 3+ years old and has only had a single significant contributor though[1].

    It's impossible to avoid single-contributor projects in the JS world, especially with Node, but the alternatives (React, Vue, Angular, and even Svelte) are orders of magnitude more popular, so it's one area that we can play it safe if we need to.

    1. https://github.com/solidjs/solid/graphs/contributors

  • solid-site

    Code that powers the SolidJS.com platform.

  • Appwrite

    Appwrite - The Open Source Firebase alternative introduces iOS support . Appwrite is an open source backend server that helps you build native iOS applications much faster with realtime APIs for authentication, databases, files storage, cloud functions and much more!

  • solid-docs

    Cumulative documentation for SolidJS and related packages.

    https://github.com/solidjs/solid-docs/graphs/contributors

    We would have never gotten the docs translated into 15 languages otherwise. I do agree that one should be cautious regardless. But I don't want to underplay the contributions of many contributors putting in improvements every day.

  • solid-start

    SolidStart, the Solid app framework

    Like the author of this post, I appreciate Solid's API because component's only render (i.e. run) once by default and then you define which sections of the component should re-render on changes by using "signals" provided by the library (e.g. `createSignal()` and `createEffect()`). In react, the entire component re-renders on every change and you need to specify which code should _not_ re-run. This was necessary because of the way react was created, but strikes me as fundamentally flawed.

    Having used Solidjs for some pet projects, I've come to strongly prefer Solidjs over React. It's an evolution of react, so I've found my existing skills/knowledge transfers. This being said, Solidjs is brand new and the ecosystem is minuscule compared to React. For this reason, I plan to continue using React for the foreseeable future. One of the biggest weaknesses of Solidjs is the lack of a "nextjs" like framework. It appears work is being done in the solid-start[1] repo, but it looks like it's still years away from being fleshed out. I want Solidjs to succeed, but I'm not interested in being an early adopter.

      [1]: https://github.com/solidjs/solid-start

  • Recoil

    Recoil is an experimental state management library for React apps. It provides several capabilities that are difficult to achieve with React alone, while being compatible with the newest features of React.

    The current implementation looks a lot like my current favorite state framework, Recoil - https://recoiljs.org/

  • react-solid-state

    Auto tracking state management for modern React

    [2]: https://github.com/solidjs/react-solid-state

  • valtio

    💊 Valtio makes proxy-state simple for React and Vanilla

    "UI state knows what its dependencies are automatically and only updates when they change" - you should check out [valtio](https://github.com/pmndrs/valtio).

  • talent.io

    Download talent.io’s Tech Salary Report. Median salaries, most in-demand technologies, state of the remote work... all you need to know your worth on the market by tech recruitment platform talent.io

  • proposal-record-tuple

    ECMAScript proposal for the Record and Tuple value types. | Stage 2: it will change!

    Sorry for the "+1" chain but I want to express my agreement as well.

    Especially when I compare it to Svelte and Vue (not solid, solid.js is just... good), If I look at component, with react it's way easier to say what's going to happen.

    Aren't there gotchas? Yes, but sometimes it's just stuff JS lacks, and so does React.

    I'm very excited about Records and Tuples in JS to help with the immutability, for example: https://github.com/tc39/proposal-record-tuple

  • Cycle.js

    A functional and reactive JavaScript framework for predictable code

  • reagent

    A minimalistic ClojureScript interface to React.js

    This reminds me a lot of Clojurescript's Reagent https://reagent-project.github.io/ (link also has a counter example)

    I've tried using bare React in the past (after using Clojurescript), because I wanted my project to be more approachable for outsiders. But I couldn't really handle the (to me, and the author) unnecessary complexity that's added.

    I would even say the Reagent version is even simpler than the Solid.js version, because you're Clojure's Atom API rather than creating read / write functions. For the adventurous hearted I'd definitely recommend giving it a try!

  • kuinox_pokedex

    I ran a profiling tool. I searched "zz" then deleted these.

    Deleting it caused a 120ms UI freeze (and I notice it :p):

    Profiling report: https://share.firefox.dev/3C3OhIq

    Given I had slightly more entries (a hundred more) and that I had way more node per entry, it led me with way worse performance.

    Instead of a plain list I have a little summary card per pokemon (which is why I have more node per entry).

    The naive implementation in Vue run flawlessly(sadly no preview):

    https://github.com/Kuinox/kuinox_pokedex/

    Note that the react implementation do weird thing because I tried to get around the issue without success.

  • lion

    Fundamental white label web component features for your design system.

    I've been maintaining a web component library with Lit for a while. Web components overall don't feel ready for primetime. Just making a custom input field and have it work with a is chore.

    Just look here at how much overall code is needed to do it right: https://github.com/ing-bank/lion/blob/master/packages/input/...

    After you get through all the inheritance and mixins it's thousands of lines

  • htm

    Hyperscript Tagged Markup: JSX alternative using standard tagged templates, with compiler support.

    You might find this interesting: https://github.com/developit/htm#readme

  • Performance-Analysis-JS

    Map/Reduce/Filter/Find Vs For loop Vs For each Vs Lodash vs Ramda

    https://github.com/dg92/Performance-Analysis-JS

    The problem with JS is that the execution model is so nebulous, that performance advice basically boils down to - trust in Google.

  • return-optics

    Extending Return with Lenses to do fun things in the Elm update function

    Yeah? I wrote something to deal with it too (https://github.com/toastal/return-optics) 5.5 years ago. You arguably chose the wrong data as `(model, Cmd msg, Maybe extMsg)` instead of `(model, Cmd msg, List extMsg)` which would give you more flexibility and still functions as a monoid on [] instead of Nothing, but allows multiple messages shrug. I tried this approach more recently and it involved me having to encode all of actions in a massive tree and then I still had issues with certain messages including now having to UUID all elements that that previously I didn't need to think about. It was a mess, but the best I could do with the tools at hand.

    If you compare this to Halogen (https://github.com/purescript-halogen/purescript-halogen/blo...) where you still have purity but can set up subscribers and listeners from any component. It's much easier to use and for some components like dialogs, it's much simpler. And this actually isn't the best example because with the latest Halogen, Portals (https://github.com/purescript-halogen/purescript-halogen/pul...) was introduced so you can launch a dialog on the spot instead of even needing to communicate between them at all.

  • purescript-halogen

    A declarative, type-safe UI library for PureScript.

    Yeah? I wrote something to deal with it too (https://github.com/toastal/return-optics) 5.5 years ago. You arguably chose the wrong data as `(model, Cmd msg, Maybe extMsg)` instead of `(model, Cmd msg, List extMsg)` which would give you more flexibility and still functions as a monoid on [] instead of Nothing, but allows multiple messages shrug. I tried this approach more recently and it involved me having to encode all of actions in a massive tree and then I still had issues with certain messages including now having to UUID all elements that that previously I didn't need to think about. It was a mess, but the best I could do with the tools at hand.

    If you compare this to Halogen (https://github.com/purescript-halogen/purescript-halogen/blo...) where you still have purity but can set up subscribers and listeners from any component. It's much easier to use and for some components like dialogs, it's much simpler. And this actually isn't the best example because with the latest Halogen, Portals (https://github.com/purescript-halogen/purescript-halogen/pul...) was introduced so you can launch a dialog on the spot instead of even needing to communicate between them at all.

  • Tiger VNC

    High performance, multi-platform VNC client and server

    https://tigervnc.org

    Does some impressive compression tricks that results in it being remarkably snappy.

    You may prefer to run Xvnc directly rather than use the wrapper script, depends how you want to set everything up.

    I will be honest here that my setup is not properly automated yet because it's inside a jail on a FreeBSD install and the underlying box gets good enough uptime that my current half-assed approach hasn't yet annoyed me into finishing it.

    There weren't any interesting gotchas though.

  • 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 🚀.

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