Solid.js

Solid.js is yet another declarative Javascript library for creating user interfaces. It does not use the Virtual DOM. Instead it opts to compile it's templates down to real DOM nodes and wrap updates in fine grained computations.

Key Features:

• Real DOM with fine grained change detection (No Virtual DOM! No Dirty Checking Digest Loop!)
• JSX precompilation with support for standard JSX features and W3C Web Components
• Declarative data
  • Data behavior is part of the declaration
  • No need for lifecycle functions, and the large chains of conditionals they bring.
• ES6 Proxies to keep data access simple and POJO like
• Expandable custom operators and binding directives.
• Immutable interface with performance of mutability.
• Performance amongst the fastest libraries. See Solid on JS Framework Benchmark

A Simple Component could look like:

import { root } from 'solid-js'

const MyComponent = props =>
  <>
    <h1>Welcome</h1>
    <p>Hello {(props.name)}</p>
  </>

root(() => mountEl.appendChild(<MyComponent name='Taylor' />));

Installation

> npm install solid-js babel-plugin-jsx-dom-expressions

Solid State

It all starts with a State object. These objects can represent the local state or the props in your components. State objects look like plain javascript options except to control change detection you call their setter method. They give the control of an immutable interface and the performance of a mutable one.

import { root, useState } from 'solid-js'

const CountingComponent = () => {
  const [state, setState] = useState({counter: 0}),
    interval = setInterval(() => setState({
      counter: state.counter + 1
    }), 1000);
  useCleanup(() => clearInterval(interval));

  return <div>{(state.counter)}</div>
}

You can also deep set:

const [state, setState] = useState({
  user: {
    firstName: 'John'
    lastName: 'Smith'
  }
});

setState('user', {firstName: 'Jake', middleName: 'Reese'});

You can also use functions:

const [state, setState] = useState({counter: 0});
setState('counter', c => c + 1);

This takes the form similar to ImmutableJS for set and setIn leaving all mutation control at the top level state object. Keep in mind that setState when setting an object attempts to merge instead of replace.

But where the magic happens is with computations(effects and memos) which automatically track dependencies.

useEffect(() => setState({
  displayName: `${state.user.firstName} ${state.user.lastName}`
}));

console.log(state.displayName); // Jake Smith

Whenever any dependency changes the State value will immediately update. JSX expressions can also get wrapped in effects so for something as trivial as a display name you could just inline the expression in the template and have it update automatically.

Solid State also exposes a reconcile method used with setState that does deep diffing to allow for automatic efficient interopt with immutable store technologies like Redux, Apollo, or RxJS.

const unsubscribe = store.subscribe(({ todos }) => setState(reconcile('todos', todos)));
useCleanup(() => unsubscribe());

Solid Rendering

To accomplish rendering we use JSX for templating that gets compiled to native DOM element instructions. To do that we take advantage of the babel-plugin-jsx-dom-expressions which while converting JSX to DOM element instructions wraps expressions to be wrapped in our computeds.

JSX as a templating language brings a lot of benefits. The just being javascript goes beyond just not needing a DSL, but setting up closure based context instead of creating context objects. This is more transparent and easier to follow and debug.

To get setup add this babel plugin config to your .babelrc, webpack, or rollup config:

"plugins": ["jsx-dom-expressions"]

And include at the top of your files:

import { r } from 'solid-js/dom'

Or, if you prefer you can use HyperScript. It does come at signifigant performance hit, as it doesn't benefit from any of the compile time optimizations that set Solid apart in performance. But it is an option for those who want to avoid Babel or do not wish to use JSX. Even though it is much slower it is still in the performance category of most popular frameworks. There are some minor differences from how you would write typical HyperScript as you need to manually wrap expressions in functions to make them observable. More information available at babel-plugin-jsx-dom-expressions. Include Solid HyperScript by:

import { h } from 'solid-js/dom'

With HyperScript it is possible to map to element functions or even tagged template literals which offer many different development experiences. See examples below.

Components

Templates in Solid are just Pascal(Capital) cased functions. Their first argument is an props object and generally return their DOM nodes to render. Other than that nothing is special about them. Unlike Virtual Dom libraries these functions can contain state as they are not called repeatedly but only executed on initial creation.

Since the all nodes from JSX are actual DOM nodes the only responsibility of top level Templates/Components is appending to the DOM. Since contexts/lifecycle management is independent of code modularization through registering event handlers Solid Templates are sufficient as is to act as Components, or Solid fits easily into other Component structures like Web Components.

import { useState, root } from 'solid-js'

class Component extends HTMLElement {
  constructor () {
    const [state, setState] = useState({}),
      [props, __setProps] = useState({});
    Object.assign(this, {state, setState, props, __setProps});
  }

  connectedCallback() {
    this.attachShadow({mode: 'open'});
    root(() => this.shadowRoot.appendChild(this.render());
  }

  attributeChangedCallback(attr, oldVal, newVal) {
    this.__setProps({[attr]: newVal});
  }
}

class MyComponent extends Component {
  constuctor () {
    super();
    this.setState({greeting: 'World'});
  }
  render() {
    return <div>Hello {(state.greeting)}</div>
  }
}

Why?

This project started as trying to find a small performant library to work with Web Components, that had easy interopt with existing standards. It is very inspired by fine grain change detection libraries like Knockout.js and RxJS. The idea here is to ease users into the world of Observable programming by keeping it transparent and starting simple. Classically the Virtual DOM as seen in React for all it's advances has some signifigant trade offs:

• The VDOM render while performant is still conceptually a constant re-render
  • It feels much more imperative as variable declarations and iterative methods for constructing the tree are constantly re-evaluating.
• Reintroduced lifecycle function hell that break apart the declarative nature of the data. Ex. relying on blacklisting changes across the tree with shouldComponentUpdate.
• Homogenous promise of Components and the overly simplistic local state in practice:
  • Imposes boundaries on components to solve performance concerns
  • Prices you into a very specific but not necessarily obvious structure
  • Only served to make it more ambiguous when emerging best practices lead to specialized component classification anyway
• Abstracts debugging to the point a <div /> is not longer just a div
• VDOM libraries still are based around having a specialized data objects.

So the driving questions here are:

• If the data is going to be specialized anyway can we use Proxies to move the complexity into it rather than the rendering while keeping the appearance simple?
• Can this free up existing constraints on how you modularize your view code?
• Does this approach ultimately provide more adaptibility while reducing the API surface?
• Is fine grained change detection fundamentally more performant than the Virtual DOM?

Admittedly it takes a strong reason to not go with the general consensus of best, and most supported libraries and frameworks. And React's Hooks API addresses the majority of what I once considered it's most untenable faults. But I believe there is a better way out there than how we do it today.

I cover this in more detail in my Bring Your Own Framework Blog Series.

Blog Series

• Part 1: Writing a JS Framework in 2018
• Part 2: Web Components as Containers
• Part 3: Change Management in JavaScript Frameworks
• Part 4: Rendering the DOM
• Part 5: JS Frameworks in 2019

Documentation

• State
• Signals
• Rendering
• API

Examples

• Counter on CodePen
• Simple Todos on CodePen
• Async Effect on CodePen
• Redux Undoable Todos on CodePen
• Simple Todos HyperScript on CodePen
• Simple Todos Template Literals on CodePen
• TodoMVC Classic TodoMVC example
• WebComponent Todos Showing off Solid with Web Components
• JS Framework Benchmark The one and only
• UIBench Benchmark a benchmark tests a variety of UI scenarios.
• DBMon Benchmark A benchmark testing ability of libraries to render unoptimized data.

Related Projects

• babel-plugin-jsx-dom-expressions The renderer behind Solid.js that enables lightning fast fine grained performance.
• React Solid State React Hooks API to use Solid.js paradigm in your existing React apps.
• Solid Components Extensions to Solid.js that add a Web Component wrapper, Portals, and a Context API.
• S.js The fine grained change detection engine that drives all computations and tracks all dependencies.

Status

This project is still a work in progress. Do not use in production. I am still refining the API.