r/solidjs • u/ryan_solid • Aug 13 '26
Solid 2.0 RC - The Big <Reveal>
r/solidjs • u/MichiganTypeScript • Nov 20 '23
r/solidjs • u/snnsnn • Oct 05 '25
SolidJS is moving fast, and so is the material to master it. Over the past year I’ve expanded and polished SolidJS – The Complete Guide into what I believe is now the most complete resource out there for learning and using Solid in production.
What’s new in this edition?
Full coverage of Solid Router and the SolidStart framework for building real-world apps.
Chapters rewritten and expanded based on community feedback.
A brand-new GitHub repo packed with ready-to-run examples — so you can learn by doing.
The book builds toward a complete, server-rendered SolidStart application with user registration and authentication. This isn’t a toy example — it’s written with production in mind. You’ll work through collecting and validating user input, handling confirmation flows, and managing state in a way that mirrors real-world applications. By the end, you’ll have patterns you can directly apply to building secure, maintainable SolidStart apps in production.
Along the way, you’ll also create several other large-scale projects, so you don’t just read about concepts — you practice them in realistic contexts.
Beyond Solid itself, the book also touches on larger front-end engineering concepts in the right context — highlighting how Solid’s patterns compare to approaches taken in other popular frameworks. By exploring trade-offs and alternative solutions, it helps you develop stronger architectural intuition and problem-solving skills. The end result isn’t just mastery of SolidJS, but becoming a better front-end engineer overall.
The goal is to make Solid concepts crystal clear so you can confidently ship apps with fine-grained reactivity, SSR, routing, and more.
The book is available for purchase on two platforms:
I recommend the solid.courses option. It goes through Stripe payments directly, which means there’s no extra platform commission — the purchase comes straight to me as the author.
Already purchased the book? No worries — the updated edition is free on both platforms. Just log in to your account and download the latest version with all the new content.
I’ve also extracted some parts of the material into their own focused books — for example, on Solid Router and SolidStart. These are available separately if you’re only interested in those topics. But if you want the full journey, the Complete Guide brings everything together in one cohesive resource.
r/solidjs • u/ryan_solid • Mar 23 '26
Async in frameworks happens in 4 phases:
create
consume
block
read
The problem? Most fuse 2 & 3. Consumption triggers blocking. This puts DX (coloration) at odds with UX (blocking).
Solid 2.0 snaps them to the poles. Colorless logic. Non-blocking UI.
---------------------
More detailed explanation.
Regardless of framework async goes through these 4 stages:
create. Ie.. like fetch(`users/${props.id}`).. or wherever the promise is created
consume.. at a certain point the promise needs to be converted into a value that can be rendered. So like `await` in Svelte or `use` in React are common ways to do this transform. It could be some other explicit API. `createResource` or `createAsync` are examples.
block... usually this transformation is the point at which the UI is blocked.. ie where we look up and find the nearest Suspense/Boundary etc.. Or where the rendering has to stop.
read... somewhere below we read this value in the UI where we actually need. Ie.. `user().name`
Async primitives color. Between creating the promise and consuming it in the framework you now are dealing with Promise<T> instead of T. If you need to await it you need async functions. Async functions beget more async functions. You need to color the whole tree. You can read more about coloration here: https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/
For this reason people naturally gravitate towards consuming where they create in frameworks. They don't want to have to deal with non-values, migrate all their APIs to `MaybePromise<T>`, do composition with `.then` chains. The problem is if consuming and blocking are tied together (like they naturally are) moving the bar up means the UX suffers. We block too high.
In Solid 2.0 we've decoupled these so we can consume the async where you declare it (you don't have to). But you can block or move your affordance all the way down to the reads. Here is a simple (although contrived) example:
https://stackblitz.com/edit/github-evfywxxk-rjhkp5tj?file=src%2Fmain.tsx
r/solidjs • u/ryan_solid • Sep 22 '26
Solid 2.0's async design is not a happy coincidence. But the result of chasing finally being able to unify all frontend architecture.
r/solidjs • u/Alex6357 • Jan 26 '26

Hey everyone,
We all love Solid's performance, but building desktop apps usually means shipping a heavy browser (Electron) or relying on a WebView (Tauri).
I’ve been working on a "No-DOM" runtime experiment called Alloy.
How it works:
I used solid-js/universal to write a Custom Renderer that, instead of manipulating the DOM, emits a binary command stream.
You write standard JSX: <button onClick={...}>Count: {count()}</button>
Solid's fine-grained reactivity detects the change.
The renderer sends a bytecode (e.g., SET_TEXT [ID] "Count: 1") to a native Rust backend.
The backend draws it using GPUI (the high-performance rendering engine used by the Zed editor).
Why SolidJS?
Solid is perfect for this architecture. Since it doesn't have a VDOM, we don't need to diff trees on the JS side. When a signal updates, we send exactly one command over the bridge. It's incredibly efficient.
Current Status:
This is an early prototype (built with some "AI Vibe Coding" assistance over the weekend).
✅ Reactivity works perfectly (Counter demo runs).
🚧 Styling is still buggy (mapping CSS to native layout is hard!).
I'm sharing this to show what's possible with Solid's custom renderers. It opens the door to native performance with Solid DX.
Repo: Alex6357/alloy: A "No-DOM" GUI Runtime: SolidJS Logic driving Rust GPUI Rendering.
r/solidjs • u/throwaway1230-43n • Dec 11 '24
r/solidjs • u/thinline20 • Jul 03 '25
This project is a port of Neobrutalism Components to Solid UI. Some of the styles are modified for my taste, so it won't look the same as the original Neobrutalism Components.
Some components haven't been implemented yet, and I need to add more blocks and examples. I'm also planning to revamp the dark theme since I don't like the current dark theme.
Features
Tailwind CSS v4
shadcn CLI registry
r/solidjs • u/andrepimentaa7 • Sep 02 '26
I've been building React Native apps for a long time. They all start fast. Keeping them fast as they grew is another story.
More state, more dependencies, more devs, and suddenly you are doing re-render arithmetic in your head. Is this selector too broad? Did that context wake the whole screen? Is the animation fighting the JS thread?
Obviously large React Native apps can be built. I'm just tired of what it takes to keep a large one feeling fast.
And then I found Solid.
To my React-trained brain, Solid felt like React if someone removed the part I had spent years optimizing around. Same JSX and components, but components run once and signals update only what depends on them. No virtual DOM. No reconciliation. No wondering whether one innocent change froze the whole app.
That was the part that made everything click. I wanted that feeling on a phone.
Kind of by accident, I also found react-native-graph, which draws with Skia and is extremely fast. It made me wonder what would happen if the whole application was rendered that way.
So I went down a rabbit hole. Turns out Flutter already owns its rendering pipeline (used Skia, now Impeller) and it's fast. Bun + JavaScriptCore, which is also one of the fastest JS engines out there, gave me the web APIs I was tired of polyfilling.
Now I had the three parts: Solid for the application, Bun for the JavaScript runtime, and Flutter for rendering.
So I cross-compiled Bun to run on iOS and Android, put Solid inside it, and let Flutter render what Solid describes.
I named it Skal, a mixture of Solid + Skia. (It also means cheers if you have ever watched a Viking show 🍻. )
I think of it as Solid Native.
Solid's universal renderer turns JSX into binary UI operations written into shared memory. Flutter reads the same bytes and renders the widget tree. No JSON or platform channel in the hot UI path. No DOM. No WebView.
When a signal changes, Solid already knows the exact consumer, so Skal sends the operation for that node and stops there.
It currently has 49 fast-path widget types, navigation, persistence, animations, overlays, and some native integrations. It runs on Android arm64, iOS, macOS, and the web. It is still early.
Here are some results from a Samsung Galaxy A14 5G running Android 15, with release builds on both sides and interleaved runs:
| Test | Skal | React Native |
|---|---|---|
| Dropped frames, image feed | 0 | 13 |
| Tap to render, median | 3.53 ms | 7.30 ms |
| One frame of work (200 components x 10 reads + 1 update) | 0.05 ms | 0.80 ms |
| State updates per second, 288 cells | 103,846 | 4,901 |
| Idle CPU | 1.20% | 6.93% |
What excites me is writing Solid code, running it on a real phone, and knowing that as the app grows, it still flies.
To try it, you need Bun and Flutter installed on your computer, plus the normal Xcode or Android tooling for the platform you want to run. Then:
npm create skal my-app
cd my-app
bun run dev:ios # or dev:android, dev:macos, dev:webOr throw your AI at the Markdown docs.
Repo: https://github.com/skal-multiplatform/skal
If you already use Solid, what would Skal need before you would try it for a real mobile app?
Skal 🍻
r/solidjs • u/GoingOnYourTomb • Jul 06 '24
I've been using React/Nextjs for about 4 years now. I would say i'm still new but today i tried SolidJs. I'm blown away at how logical everything is. I'm in love. Big shoutout to all the devs and you kind folks in the community.
r/solidjs • u/AtilaFassina • Mar 20 '26
Hey folks, today we published a Roadmap update for SolidStart and we’re effectively inviting you to try it out as we get closer and closer to a stable release!!
`npm create solid —start —v2` will get you set up with a v2 app
For existing projects, the migration guide should be helpful: https://docs.solidjs.com/solid-start/migrating-from-v1
We’d love to hear any feedback you got!
r/solidjs • u/ryan_solid • Apr 11 '26
r/solidjs • u/xegoba7006 • Jul 20 '25
I just wanted to publicly share my experience after migrating an internal medium sized app from React Router to Solid Start.
The application is an internal media content review system for the most part.
It's been my first time using Solid, and I'm honestly super impressed on how simpler things are. Everything clicked very quickly for me, and I've managed to remove a lot of code. For some reason implementing the same stuff takes a lot less "dancing" and you can just do the thing you wanted to do. Feels like things are much better thought out and you don't have to fight as much your tools.
The most difficult part for me was migrating a (server api) route where the response is a video stream, that also needs to support 206 responses (partial content) which I managed to resolve after discovering the fromNodeMiddleware function from Vinxi, the send NPM package, and figuring out I had to return null from the GET handler to avoid the dev server crashing due to headers sent after the response, etc.
But I've had absolutely zero issues with Solid's reactivity model, etc.
I've even managed to use the same translations systems we had (lingui.dev), which I also love. And it works great. No JSX macros though, but I implemented (with chatgpt's help) a custom interpolate function that would do the same thing, but just as a function call instead of JSX. And it works great.
I'm in love with Solid, and Solid Start. It seems to me like the only thing missing is more people to try it out, because it's so much easier than React. And I'm not even considering the performance here (as it didn't matter much for this project anyways).
r/solidjs • u/ryan_solid • May 23 '22
r/solidjs • u/thinline20 • Mar 04 '26
I know reactivity system is reworked, but that's pretty much it.
r/solidjs
•
u/WesleyWex
•
Dec 18 '24
r/solidjs
•
u/snnsnn
•
Nov 04 '24
Hi everyone, I have some exciting news to share: over the past two years, I've been busy writing the first-ever SolidJS book, and now it's finally ready for release. 🎉🎉 I hope you’ll enjoy it.
I did my best to organize the topics in a way not to overwhelm the readers and to enhance progressive learning, with examples that focus on the subject matter without introducing unnecessary complexity. Reactivity turned out to be quite a challenge because everything is interconnected and somewhat circular in nature, and the documentation was sparse. I ended up rewriting the book twice to find the right approach. I would love to hear your feedback on how the book has helped you understand SolidJS better, or any questions you might have!
The book 🙌 is available for purchase on two platforms—solid.courses via Sellfy and Leanpub.
If you're into SolidJS, you might wanna check it out—it’s designed to seriously cut down the time it takes to master SolidJS and get you building faster. 🚀🚀🚀
r/solidjs • u/zerinekw • Aug 04 '25
I’m currently building a custom IDE from scratch with Monaco Editor — built on top of Solid.js for the frontend and a Chromium Embedded (via C++) native shell.
Think of it like a modern take on VSCode, but with a leaner core and very focused UI.
r/solidjs • u/Appropriate-Push8381 • Jan 28 '26
I've been working on solid-jsx-oxc (v0.1.0-alpha.14) - a Rust/OXC-based JSX compiler for SolidJS.
bun add bun-plugin-solid-oxc solid-jsx-oxc
// build.ts
import solidOxc from 'bun-plugin-solid-oxc';
await Bun.build({
entrypoints: ['./src/index.tsx'],
outdir: './dist',
plugins: [solidOxc()],
});Build both client and server bundles:
// Client (hydration)
await Bun.build({
entrypoints: ['./src/entry-client.tsx'],
target: 'browser',
plugins: [solidOxc({ generate: 'dom', hydratable: true })],
});
// Server (SSR)
await Bun.build({
entrypoints: ['./src/server.ts'],
target: 'bun',
plugins: [solidOxc({ generate: 'ssr', hydratable: true })],
});Full example with Elysia in the repo: examples/bun-solid-elysia
Run .tsx files directly without a build step:
# bunfig.toml
preload = ["bun-plugin-solid-oxc/register"]
bun run src/index.tsx # Just works™Works great with TanStack Start/Router. Just allowlist the packages that ship JSX:
solidOxc({
exclude: [
/node_modules\/(?!(?:@tanstack\/solid-start|@tanstack\/solid-router)\/)/,
],
hydratable: true,
})Full TanStack Start example in `examples/tanstack-start-solid`.
Packages (v0.1.0-alpha.14):
solid-jsx-oxc - Core compiler
bun-plugin-solid-oxc - Bun plugin
vite-plugin-solid-oxc - Vite plugin (if you still need it)
Currently alpha - feedback and bug reports welcome! 🚀
r/solidjs • u/PayAcrobatic6727 • Mar 19 '25
I built a Chrome extension that organizes browser history by tabs instead of a messy chronological list. From the start, I wanted the extension to be fully in sync with the browser—if the user opens a new tab, it should instantly appear at the beginning of the list; if they navigate to a new site, the tab’s title and favicon should update without needing to refresh.
I initially used the go-to library React, but quickly ran into performance issues. Since new tabs are added to the top of the list, React re-rendered the entire list and all its children every time. This became a problem—imagine a user with hundreds or even thousands of tabs loaded. Even on a powerful machine, there were noticeable lags.
With SolidJS, things were different. Fine-grained reactivity meant that only the affected parts of the UI were updated. I didn’t have to worry about unnecessary re-renders or rely on external state management. Using signals, stores, and built-in utilities like <For /> and <Index />, updates were fast and efficient.
The developer experience (DX) was fantastic, and the switch completely changed how my extension performs. If you are excited about the idea of the extension give it a try and install it from here, it is completely free!