Hacker News new | past | comments | ask | show | jobs | submit
What's amusing and/or interesting is that the stuff under "Built to Be Written by Agents" also would make it easier to write by hand, I imagine. It's just better debug diagnostics; nothing really to do with agentic development specifically.

Maybe that's just marketing, but it's really intriguing how human best practices are also agent best practices; how, maybe, we've reached a point where even devs aren't recognizing agent best practices as human best practices anymore; and how suddenly best practices are being prioritized in a way they often weren't - humans could/would/were expected to suck it up and deal with poor devex, but agents simply can't. A strange sort of victory for us folks who cared about it.

loading story #50538644
loading story #50538149
loading story #50539356
loading story #50545185
loading story #50540188
loading story #50550491
loading story #50539480
Remix originally pitched itself as solving the 'middle' layer between frontend and backend. Closing the gap. It never quite managed to do so imo.

Solid's solution here is beautiful. The server RPC and 'live' and 'broadcast' are seamless, and feel much more natural to use than liveview or htmx/datastar imo.

loading story #50539250
loading story #50539906
If you're sensitive to bundle sizes (which you almost certainly aren't), heads up: the Solid 2 bundles are much bigger.

My counter component bundle test is:

     4.8 KiB (brotli'd) in Solid v1.9.18
    20.3 KiB (brotli'd) in Solid v2.0.0
loading story #50544383
loading story #50542541
Congrats to Ryan and the team. I never got deep enough into front-end to understand the nuance of these things but I still occasionally tuned into his Friday streams just to listen. You can tell he cares about this subject deeply and I enjoy listening to passionate people talk about their craft.
loading story #50545255
A gist I wrote about my experience migrating from Solid 1.0 to Solid 2.0 (RC) a couple of months ago: https://gist.github.com/FlameWolf/7b3be7acb06775f02ea4a57297...
There are still not many component libraries for Solid. But if I needed to build something from scratch, I would definitely try Solid.

It just feels like the right way React should be.

loading story #50537180
loading story #50539645
loading story #50537070
Congrats to the Solid team. This is a monumental release.
Still waiting for Vue 3.6 Vapor to be released which is supposed to be more competitive with these frameworks like Svelte and Solid in performance. Vue 3.5 came out in Sept 2024 and I've ported a lot of code off Vue since then.
loading story #50539162
I really like the ideas and concepts (one graph integrating async and reactivity) and also been a fan for some while (watching (at least in parts) Ryans YT streams, having used Solid 1.0 for a smaller project). But I have some mixed feelings knowing that the majority if not all code was written by AI. I have no doubt that every line was reviewed carefully. But this is a very complex code base. And I'm old enough to know that reading is miles away from writing when it comes to understanding. So, I'm sitting here wanting to choose Solid 2.0 for every new project but on the other hand having those nagging doubts whether that project is really sustainable. By the way, those are the same doubts I have for all newly created projects and I usually don't spent a second considering them, but this is a very special case because of Ryan and the team and because of Solid 2.0 being IMO such a significant step in simplifying frontend dev. I guess I need to see a therapist helping me out of my personal AI crisis ... I'm still writing all my code myself and are not left behind like the other dozends of us ;-).
I honestly don't remember what drove me (and apparently a lot of the frontend JS community) to place my bets on Svelte over Solid, years ago now. It probably had something to do with Svelte feeling (and at the time, being) much simpler to develop in, looking on the surface like simple HTML and CSS with some JavaScript sprinkled in, and believing strongly in its magic compiler.

Honestly, I was probably just so tired of React that it felt refreshing to develop in something so un-React-like, and it ergonomically felt better at the time than writing something similar to React via Solid, even if the latter was still holding its own in performance on paper. If you've spent years learning French then it might feel more refreshing to start learning Japanese than Italian.

It turns out Solid had a lot of it right all along. And after using Svelte for a while, something starting feeling... weird. For all its complexity, something I always appreciated about React was that I was ultimately just writing JavaScript, and with Svelte it felt like I was writing in something only made to resemble JavaScript.

I still really appreciate Svelte, but I'm wondering if this would be a good time to see if Solid will feel more "natural" to me, having worked with JavaScript all these years. Curious if anyone can confirm if that would be the case.

Now might also be a good time to tinker with it myself before the coding models are fully up to date on 2.0 and I turn to laziness (/efficiency) and have them handle the rest.

loading story #50537344
loading story #50537913
loading story #50539498
Hoping the TanStack Solid 2 adapters are out soon. They're the only blockers for me now.
loading story #50539832
Ryan Carniato is to Solid as rhickey is to Clojure as evancz is to Elm.

They all convinced me to use their respective languages by sharing all the thought they put into them, especially to address problems in the alternative, more popular options.

This looks like <Suspense> and Next.js SSR all over again.

I didn't like it then either.

I see something like ”const user = createMemo(() => fetchUser(props.id));” or “use server” and I’m instantly reminded of why I abandoned JS frameworks (not to mention anything touching JS on the server).

I much prefer Solid over React, but at least the idea of a compiler makes so much more sense instead of manually maintaining memoization.

loading story #50539531
Solid has been my framework of choice for the past 5 years. Haven't touched React since.
The async graph is VERY cool. It does a great job of encapsulating async's nature to cause "colored" functions by using the existing signal graph (which admittedly is its own color; but virtually every UI framework has similar coloring so at least Solid's cutting a color/making it composable).

Contrast that with React, where hooks are colored functions. You thought that hooks were just functions? Nope, if you have a hook, it MUST be called in a hook/component... exactly like async. Did you want to load this TTS player conditionally? Hahah, you can't. Have fun allocating memory for every TTS provider your app supports, even if the user uses only 1 player. https://news.ycombinator.com/item?id=45257413

"Thanks to async in the graph we can detect waterfalls, poorly constructed effect loops, poorly scaling graph shapes like wide graph fanouts and fan-ins." Incredibly cool. Apparently Tanstack Query has a waterfall detector https://github.com/bamlab/tanstack-query-detect-waterfall so the other frameworks have something similar, but it won't work with their state graphs.

> "Thanks to async in the graph we can detect waterfalls, poorly constructed effect loops, poorly scaling graph shapes like wide graph fanouts and fan-ins."

That needs to emphasized more. Pretty sure React's Suspense suffers from waterfalls if memory serves.

loading story #50539164
That async cascading dropdown example is very compelling.
They've gone all in on AI and Agents, how wonderful
bought solidjs merch off their store, it's been months of radio silence
Im so happy about this, got around influencing it, which means a lot, this is the future of all the UI!
It doesn't explain what is the point of this and why would anybody use this apart from to look cool?
Now we just need Qwik 2.0 to get released for their async resumable framework.

I think with the advent of AI it doesn't matter so much about the DX and your main focus should be on better UX (the best lighthouse metrics) though I don't think their DX is bad either.

loading story #50554077
Hurray! Solid 2.0 is finally out!
Tangential, but since the thread is all DOM: I've been using Solid 2's universal renderer for native watchOS UIs, and just put the renderer and host up as an MIT repo: https://github.com/esensible/solid-watch

The bundle (Solid JSX compiled with the new babel plugin) runs in QuickJS-ng on the watch; the renderer emits node mutations over a small host interface; a Swift host lays them out with Yoga and draws with SwiftUI. The same bundle runs in a browser harness for development. The structure is borrowed from React Native's Fabric: three trees, batched commits, one schema that generates the prop code for both sides. A dozen node types, React Native style names, on purpose.

For context, it's the display layer of a larger personal project (not open source at this point): application state lives in a small expression language with a Rust evaluator, running on the phone or on an ESP32 box, with the state, events and view described by JSON Schemas and a schema-derived wire codec. The watch and an e-ink display are synced views of that state. Bundles and firmware are served and updated over BLE, and the phone app has a sign-in-with-ChatGPT authoring mode that writes the Solid UI and the expression logic against those schemas, checks them on the device, and packs the bundle locally on the phone, no server. Solid's universal renderer is what made the watch part feasible: the UI author writes ordinary JSX and the same bundle runs on the wrist and in a browser tab.

Rough edges in the public piece: you build the QuickJS xcframework yourself, and getting a bundle onto a real watch still means an Xcode build. Examples built with plain npm and the browser harness are in the repo if you want to poke at it. Moving from the RCs to 2.0.0, the only breaking change I hit was <Show> compiling to a ternary, which only reordered mutations inside a commit.

loading story #50541284
Too many things called Solid... I thought this was Tim Berners Lee's project getting an update.
"Built to be written by agents"? To me that would mean to drop the framework altogether: they've always just been an abstraction to bridge knowledge gaps in bigger teams and enforce coding patterns. But now that's just the job of the agents, and instead you can prompt it to set up a proper server in any language you want.
loading story #50538206
loading story #50537093
loading story #50537373
loading story #50544039
loading story #50537326
loading story #50537027
loading story #50537059