Solid is a declarative JavaScript library for creating user interfaces. It does not use a Virtual DOM. Instead it opts to compile its templates down to real DOM nodes and wrap updates in fine grained reactions. This way when your state updates only the code that depends on it runs.
- Real DOM with fine-grained updates (No Virtual DOM! No Dirty Checking Digest Loop!).
- Declarative data
- Simple composable primitives without the hidden rules.
- Function Components with no need for lifecycle methods or specialized configuration objects.
- Render once mental model.
- Fast! Almost indistinguishable performance vs optimized painfully imperative vanilla DOM code. See Solid on JS Framework Benchmark.
- Small! Completely tree-shakeable Solid's compiler will only include parts of the library you use.
- Supports and is built on TypeScript.
- Supports modern features like JSX, Fragments, Context, Portals, Suspense, SSR, Error Boundaries and Concurrent Rendering.
- Webcomponent friendly
- Context API that spans Custom Elements
- Implicit event delegation with Shadow DOM Retargeting
- Shadow DOM Portals
- Transparent debugging: a
<div>is just a div.
import { render } from "solid-js/dom";
const HelloMessage = props => <div>Hello {props.name}</div>;
render(() => <HelloMessage name="Taylor" />, document.getElementById("hello-example"));A Simple Component is just a function that accepts properties. Solid uses a render function to create the reactive mount point of your application.
The JSX is then compiled down to efficient real DOM expressions:
import { render, template, insert, createComponent } from "solid-js/dom";
const _tmpl$ = template(`<div>Hello </div>`);
const HelloMessage = props => {
const _el$ = _tmpl$.cloneNode(true);
insert(_el$, () => props.name);
return _el$;
};
render(
() => createComponent(HelloMessage, { name: "Taylor" }),
document.getElementById("hello-example")
);That _el$ is a real div element and props.name, Taylor in this case, is appended to its child nodes. Notice that props.name is wrapped in a function. That is because that is the only part of this component that will ever execute again. Even if a name is updated from the outside only that one expression will be re-evaluated. The compiler optimizes initial render and the runtime optimizes updates. It's the best of both worlds.
Want to see what code Solid generates:
npm init solid <project-type> <project-name>is available with npm 6+.
You can get started with a simple app with the CLI with by running:
> npm init solid app my-appOr for a TypeScript starter:
> npm init solid app-ts my-appOr you can install the dependencies in your own project. To use Solid with JSX (recommended) run:
> npm install solid-js babel-preset-solidThe easiest way to get setup is add babel-preset-solid to your .babelrc, or babel config for webpack, or rollup:
"presets": ["solid"]Check out these two introductory articles by @aftzl: Understanding Solid: Reactivity Basics Understanding Solid: JSX
- Reactivity
- State
- JSX Rendering
- Components
- Styling
- Context
- Suspense
- API
- FAQ
- Comparison with other Libraries
- Storybook
Dislike JSX? Don't mind doing manual work to wrap expressions, worse performance, and having larger bundle sizes? Alternatively in non-compiled environments you can use Tagged Template Literals or HyperScript.
You can run them straight from the browser with a script tag using (Solid Standalone)[https://github.com/ryansolid/solid-standalone] which exports both a Tagged Template(html.min.js) and HyperScript(h.min.js) versions of solid
<html>
<head>
<script src="https://unpkg.com/solid-standalone/html.min.js"></script>
</head>
<body>
<script>
const { createState, onCleanup } = Solid;
const { render, html } = SolidDOM;
const App = () => {
const [state, setState] = createState({ counter: 0 }),
timer = setInterval(() => setState("counter", c => c + 1), 1000);
onCleanup(() => clearInterval(timer));
return html`<div>${() => state.counter}</div>`
}
render(App, document.body);
</script>
</body>
</html>Or if installed from NPM. Tagged Template Literals Lit DOM Expressions or even HyperScript with Hyper DOM Expressions. For convenience Solid exports interfaces to runtimes for these as:
import h from "solid-js/h";
import html from "solid-js/html";Remember you still need the corresponding DOM Expressions library for these to work.
The last 2 versions of modern evergreen browsers and Node LTS.
Come chat with us on Discord
Support us with a donation and help us continue our activities. [Contribute]
Become a sponsor and get your logo on our README on GitHub with a link to your site. [Become a sponsor]
Solid is mostly feature complete for its v1.0.0 release. The next releases will be mostly bug fixes and API tweaks on the road to stability.
![dependabot[bot] avatar](https://avatars.githubusercontent.com/in/29110?v=4 "dependabot[bot]")
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent