@solid_jsi
iAccount based inUnited States
About this account
- Account based in
- United States
- Connected via
- Web
Account-level information from X, not a live location or the device used for a specific post.
The Signals Framework Discord: https://nitter.cf/t.co/tEWWSIE5oN
Joined March 2021
- Tweets1.2K
- Following41
- Followers47.8K
- Likes6.1K
Pinned Tweet
New to Solid? Want to know more about it? dev.to/ryansolid/introducing…
Ryan wrote down the theory behind why Solid 2.0 is shaped the way it is. A framework built to move across the whole grid instead of picking a corner.
dev.to/playfulprogramming/th…
SolidJS retweeted
I need to remember to talk about this more. Because we pulled everything(including async) into our reactive graph at runtime, @solid_js has more knowledge to guide agents than any other solution out there.
We basically made agent targetted dev tools, shipped with every project.
SolidJS retweeted
It is probably of little surprise to anyone I'm in favor of this change. When we implemented our official TSRX preview for Solid 2.0 we intentionally walked back from lazy destructuring.
You can check out Solid 2.0 TSRX template here:
github.com/solidjs/templates…
As we prepare TSRX for 1.0, we’ve decided to remove “lazy destructuring”.
This reflects the direction we want to take TSRX: an extension of JSX, rather than an entirely new language.
We’ve written more about the reasoning behind the change here:
tsrx.dev/blog/removing-lazy-…
SolidJS retweeted
Stream is back today. Going to look at even more of the capabilities of Solid 2.0.
youtube.com/watch?v=khmx8Dvl…
SolidJS retweeted
Wrote a post about the little things that keep drawing me to Solid
brenelz.com/posts/solidjs-it…
SolidJS retweeted
The upcoming release of @solid_js 2.0 by @RyanCarniato and team also ends it's meta-framework. Is this the beginning of the next wave of web frameworks?
👀 Tomorrow we are talking JavaScript Frameworks and Solid 2.0!
special edition of Learn With Jason is live on Thursday at 9:30am PT with @RyanCarniato
what's the value in working on new web frameworks today? why should we care at all?
Ryan has been working on Solid 2.0 and grappling with the shifting landscape of OSS
SolidJS retweeted
Released solid-marked 0.8.0
TL;DR this is a project refresh. Moved to oxlint, tsdown, typescript@7, etc.
github.com/lxsmnsyc/solid-ma…
SolidJS retweeted
Well,I finally got to realize the docs design I've been planning since 5 years ago.
Terracotta (a.k.a. solid-headless) 2.0 soon
SolidJS retweeted
Table of Contents just landed in Moduix.
Built on top of @ark_ui_ and @zag_js
Give it a try:
moduix.dev/docs/table-of-con…
@solid_js community - stay tuned, we’ve got something exciting coming your way soon!
♥️ @EffectTS_
I looked at @EffectTS_ for the first time today and I think it works very well with @solid_js 2.0.
We naturally absorb async iterators, and our actions already are as well.
What do you think?
stackblitz.com/edit/github-e…
The final part of @RyanCarniato's deep dive into Solid 2.0's async model: server functions, live streams, and streaming SSR.
One reactive graph, spanning two machines:
solidjs.com/blog/async-solid…
Replying to @solid_js @RyanCarniato
This is what makes Solid so exciting to build on.
The primitives are fundamental enough that Async doesn't feel like bolting on a new programming model!
We're exploring the same idea from another direction: keep Solid's model🥰, replace the DOM underneath it with a Rust/Vello native renderer.
SolidJS retweeted
I'm retiring Dom Expressions today. For those who don't know it was a project that in a sense predates Solid itself. When I first was making a reactive renderer, I knew I wanted fine-grained updates but I wasn't sure how I wanted my signals to behave. So I made the renderer agnostic.
Early on I made versions that worked with Solid's Signals, my own reactive library, as well as Knockout and MobX. When Vue composition API came out I made a version with it too, basically foreshadowing Vue Vapor back in 2020. I entered all of these in the JS Framework Benchmark and they all outperformed all the popular libraries.
It had a good run but it has been a maintenance burden for Solid over the years as fixes needed to land cross repo. It wasn't that big of a deal when I was managing this all myself, but contributors would be confused about where the JSX types came from or how the rendering worked.
In Solid 2.0 with the increased core responsibilities this just got out of hand. The code got more inbred. Most Signals libraries aren't async native to start. And hoisting features core meant as we built on the protocols there has been a ton of back and forth. The most painful part is managing release sequencing, especially when DOM Expressions now with a Rust compiler has a binary build step.
We'd need to locally link repos in multiple work trees and then try to merge them all at the same time to make a release. If we discovered an issue or bug during this process the repos would be broken for contributors. The last month and a half has been so painful in this regard, and has made iterating on things like Server Functions, Server Components, along with bug fixes and performance optimizations related to the runtime/compiler seam incredibly painful. We spend half our time with the Solid repo in a broken build state and that isn't acceptable.
So today we fold it in. There are upsides here because we can finally optimize the code to be Solid specific. I left this on the table for the sake of agnosticism. But the reality I've seen over the years is people didn't implement their own dom-expressions libraries. They just forked the code when they wanted their own frameworks. And in an age of AI that seems even more likely.
This has basically zero API surface impact for Solid 2.0 RC users. It isn't really a breaking change. But it is part of growing up and recognizing the experiment is over. Dom Expressions will be continued to be maintained for Solid 1.x users.
github.com/solidjs/solid/pul…
SolidJS retweeted
. @solid_js 2.0 is rethinking async work at the reactive-system level.
@devagrawal09 explains how familiar primitives such as createMemo can handle asynchronous derivations, removing the need for a separate resource abstraction and simplifying the path from fetch to UI.
Tell us: where does async state create the most friction in your codebase?
Part Two of @RyanCarniato's in-depth look at Solid 2.0's Async shows how having the right primitives lets you skip the rewrite.
Your client-only app was the optimistic UI all along. It just wasn't aware of the server yet.
solidjs.com/blog/async-solid…