SolidJS vs. React: The Go-to Information

On the floor, SolidJS and React seem like carefully associated. The client-side frameworks are mutually intelligible and are each used to create single-page purposes (SPAs). Whereas the developer expertise is almost similar for each, the underlying mechanisms of every framework are a exceptional distinction.

Each SPA frameworks are answerable for compartmentalizing an app’s webpage construction and performance, however in a browser, these frameworks manipulate pages’ HTML parts otherwise to ship the specified person expertise. SolidJS and React diverge of their use of the Doc Object Mannequin (DOM). Let’s develop on how React and SolidJS elements enable utility logic to imitate a multi-page web site.

A Temporary Comparability

I’m a agency believer in a TL;DR method, so I’ve boiled down and offered React and SolidJS’s essential variations within the following desk:




TypeScript assist

Declarative nature

Unidirectional information movement

JSX first-class assist

Direct manipulation of the DOM

Avoids part re-rendering

Extremely performant

Wealthy group and ecosystem

Wonderful developer documentation

Scaffolding instruments

Conditional rendering

Server-side rendering (i.e., hydration)

Concurrent rendering (i.e., suspense)

Now we’ll go into extra element on the similarities and variations between React and SolidJS.

Element Construction

React and SolidJS have precisely the identical programmatic constructions and assist for elements (particular person, reusable items of code).

In each trendy React and SolidJS, a part consists of a render perform with properties as arguments. Along with every part’s JSX, the code is tight and succinct. JSX is straightforward to grok, and permits skilled builders to visually describe a part’s mannequin in its definition.

React and SolidJS supply the identical elements, however every framework has a novel rendering method. React elements render each time (barring memoization use), whereas SolidJS elements solely render as soon as.

One other distinction between the 2 frameworks is their various options that allow part performance.

Element Performance

A part with out performance is simply markup. So how do React and SolidJS make elements operational? Their approaches are related:






use (e.g., useState)

These are features meant to run when triggered by the framework at particular occasions in a part’s lifecycle.

Hook features are impartial from each other, however can name different hooks from throughout the similar part. Such name chains enable for extra complicated performance and for code to be composed into subfunctions.


Reactive primitives

create (e.g., createSignal)

These are features whose APIs are just like these of hooks.

Beneath the hood, each hooks and reactive primitives are a approach to join into the respective React and SolidJS change administration methods. General, the 2 frameworks deal with part features in an identical method, however make use of totally different strategies or nomenclatures to take action.

Let’s discover extra complicated performance variations: state, memoization, and results.


At occasions, a framework might want to observe data and sure properties tied to a part. This idea is called state, and could be accessed in React with the useState perform. In SolidJS, this idea is called sign, and its corresponding creation perform is createSignal.

States and alerts home part information (within the type of props), enabling the framework to trace worth adjustments. And when the framework detects a change, the part is rendered with the in accordance worth(s).


An impact is a particular perform that may be a core constructing block in each React and SolidJS. As an alternative of responding to a direct person interplay with the browser, an impact is triggered when a part state adjustments, akin to a callback or occasion listener.

React defines an impact with the useEffect perform, whereas SolidJS makes use of the createEffect perform.


Memoization optimizes framework efficiency by caching expensiֵve part render outcomes, and utilizing cached values when acceptable versus recomputing values. In React, we implement memoization by utilizing certainly one of three hooks:

Memoization Hook

Used With


Pure elements


Elements that depend on perform props


Costly operations and part operations

React will depend on memoization for its purposes to render rapidly. In distinction, due to its optimized change monitoring and DOM utilization, SolidJS not often requires express memoization. For excessive edge circumstances during which part prop adjustments don’t entail a rendering replace, SolidJS manages memoization by means of a single methodology referred to as createMemo.


SolidsJS and React have efficiency variations that attain past their approaches to memoization. The 2 languages method HTML manipulation in very other ways. The point of interest of this distinction is how every updates the browser DOM.

React’s founder gave it a light-weight digital DOM to interface with the browser’s precise DOM. React’s code causes its personal digital DOM to replace as elements render. React then compares the up to date digital DOM in opposition to the browser’s DOM, and the recognized adjustments bleed by means of into the precise web page construction (i.e., the DOM).

We may argue that—as a result of React re-renders elements by default, counting on DOM distinction calculations for updates—React is doing its work twice. Because it renders elements each time, React requires memoization to keep away from pointless, repetitive computations.

In distinction, SolidJS’s founder managed to dodge all of this round-tripping. By utilizing a mechanism referred to as fine-grained reactivity to straight manipulate the browser’s DOM, SolidJS delivers a a lot lighter reminiscence footprint and a blazingly quick utility of web page edits and injected code.

Tremendous-grained reactivity tracks variable interdependencies. Primarily based on variable dependency and edit chains, SolidJS limits our web page construction updates to replicate solely what has modified, bypassing pointless part renders. This ends in a large efficiency enchancment over React.

Although I’m tempted to finish the article right here and say that SolidJS is the clear winner attributable to its speediness, it stays essential to debate how the 2 frameworks stack up when it comes to developer effectivity.

Developer Productiveness

There are just a few key concerns after we think about developer productiveness in React versus SolidJS:




Figuring out and monitoring part dependencies

Manually tags part dependencies with useEffect.

Routinely detects and tracks part dependencies.

Destructuring properties inside render or hook definitions

Helps this function.

Doesn’t assist this function out of the field, however this utility mission bridges the hole.

Utilizing state elements with out markup

Requires extra scripting to implement a shared state between a number of elements.

Helps this effectively and natively.

A evaluation of your mission’s particular use circumstances can reveal which framework is a better option, productivity-wise.

SolidJS vs. React

I’ve appreciable expertise with each SolidJS and React. From my perspective, SolidJS is the clear winner of the 2. SolidJS matches React’s energy and strong options. Furthermore, it delivers a brisk responsiveness to finish customers that’s unmatched by React.

For a React developer to rise up to hurry on SolidJS, which leverages the teachings, construction, and summary approaches discovered over React’s lifetime, there may be virtually no studying curve. I’d suggest you begin utilizing SolidJS right now—it might be the way forward for entrance finish.

The editorial crew of the Toptal Engineering Weblog extends its gratitude to Yonatan Bendahan for reviewing the technical content material offered on this article.

Related Articles


Please enter your comment!
Please enter your name here

Latest Articles