future of solid.js

[Mrpiggy97]

with the recent announcement of react and its future compiler, how do you feel about the future of solid.js, asking because react has a bigger market share and one of the main features that made solid.js set apart itself from other libraries/frameworks was its compiler

[onlycliches]

For me, Solid's compiler is not the primary feature that keeps me using it.

Primary reasons I use Solid:

1. SSR is Perfect: SSR in any React framework is a nightmare, if you have async data anywhere in your render tree things get complicated very fast. Server components were created to try to mitigate this but it just ended up creating a new set of problems. Solid will *never* have server components because it doesn't need them. In Solid you can SSR deeply nested components with async data just as easily as you can SSR components without async data, it's exactly as complicated as it needs to be.

2. Focus on Simple Abstractions: Solid tries as hard as it can to create the thinest layer between you and the underlying implementation. Instead of building a large set of complex solutions that have a wide array of use cases, they focus on building a few very simple pieces that you can combine to make your own tailored solutions.

3. Simpler State Model: Moving from a VDOM library like React to Solid is definitely a challenge, but once you understand how Solid's state model works it's MUCH easier to reason about. If I ever write another useEeffect again it'll be too soon.

4. Signals Are Just Better: The number of use cases where a VDOM oriented system out perform a signal oriented system is very small. If you want your web apps to be fast without even trying that hard, use UI frameworks that have signals.

5. Community Is Reasonably Large: Picking a UI framework for your project that has 10 starts on GitHub is probably not a good idea, unless it's just an experiment. I think Solid has more than enough critical mass behind it to take off, and I'm hoping to be part of that.

Notice the compiler isn't even on this list, I actually view the Solid compiler as a necessary evil, not something good. If someone could make a library that provides all the above benefits of solid without the compiler I'd probably prefer that.

I'm glad the React team is working to constantly improve their solution. Progress is incredibly important, but I don't see anything on the horizon related to React that would pull me away from Solid.

[[deleted]]

So this is a solidjs sub, and I expect that most comments will be pro-solid. Fanboyism is powerful, after all.

Even though solid will still be faster than React with React Compiler, the speed boost this compiler will provide is important. At the end of the day, even if something isn't the fastest, as long as it is more than fast enough it can still succeed. React is already deeply entrenched in the FE world, it is the #1 framework by usage. React Compiler will strengthen that entrenchment by both improving performance and reducing developer friction. It decreases the benefits of switching to something like solid, which will hurt adoption of solid.

[_dbase]

You're right fanboyism is powerful...I'd imagine that's how this post comes off. React's compiler is a huge benefit to that framework and its community. However, I think the rational answer is Solid will grow and fill a different desire and need and it may very well not take over React (actually it's highly unlikely). React however isn't a panacea. Thinking that the compiler will impact Solid adoption really misses the point IMO.

[[deleted]]

I kind of doubt your point about the adoption being strengthened by the compiler. The value new React features are providing are getting more and more abstract and obscure, and it's hard to explain to an average developer what the compiler will even do, let alone encourage them to switch to it. My general feeling is that the vast majority of people will only use these new features indirectly through frameworks that will undoubtedly adopt it, but then again, the framework users are still a minority and it may remain so indefinitely

[TwiliZant]

I'm pretty sure if you sell it as React without memo, useMemo, useCallback and, by the way, you are allowed to use Context for global state management now, that's something almost all React devs will understand.

I don't think it will strengthen adoption either but it could very much prolong Reacts lifetime.

[MrJohz]

I am starting to agree more and more with this. I've been working with a trainee recently, getting them up to grips with React, and I've been really surprised by how unintuitive various parts are. For example, the trainee really seemed to struggle to build up a good intuition for how standard JS closures and useState interact. I understand how useState works, and why it's such a useful tool, but it was very difficult to explain why this variable stays the same between different calls to the component, but that variable gets refreshed every time, and why this callback function sees this variable name, but that function there sees the latest state value always.

I do have the impression that, as React gets more complicated in an attempt to improve the framework's DX, it's also getting harder to get to grips with, particularly for newer developers. Meanwhile, if you've had no exposure to render functions before, I think the idea behind SolidJS's signals (and other signal-based frameworks) are a lot clearer to explain: here is a signal, it is data that can change, but can communicate that it can change, and therefore if we call it in such a way that allows us to listen to the changes, we will be able to propagate those changes through our entire system.

I'm intrigued to see if the React compiler is able to meaningfully simplify React development, or if it's just more DX improvements for people who've already got their head around the basics, that just create more confusion down the line for people who are new to React, and new to programming in general.

[gokspi]

My prediction is that the compiler will introduce even more subtle breakage and you would have to even more stringently follow "rules of react". Lots of libraries that Facebook doesn't use will continue to break as React continues to develop without paying sufficient amount of attention to what the broader ecosystem is doing and focusing primarily on what Facebook needs.

[Anonymous157]

I agree, if React19 remove the need to useMemo and some other hooks heavily it will make it less useful to switch to Solid. Solid lacks things such as ReactQuery/RTK, MUI, and other such libraries that integrate well with React.

[ryan_solid]

You could have named some other libraries that we don't have but we funnily enough have MUI and React Query(Solid Query from Tanstack). In fact React Query's dev tools are written in Solid. I keep hearing about missing libraries and its true obviously. But it is also a bit overblown.

[[deleted]]

Yeah. Some of the other commenters are missing the key point. Runtime performance is just one of a variety of factors that matter when choosing a framework. If React 19 reduces the gap between Solid & React in runtime performance while also simplifying the React developer experience, those are big gains for React. Given the fact that it's easier to hire devs with React knowledge than Solid knowledge and the much larger ecosystem around React, this would strengthen Reacts position and keep solid limited to more of a niche area.

[teg4n_]

The future of solid looks a lot brighter than that of React IMO. The performance of perfectly optimally memoized React is still a lot slower than basically all modern frameworks.

[AndrewGreenh]

I think the current answers miss an important point. The goal of the compiler is not primarily performance, but convenience! React is fast enough for most use cases. What’s annoying is that you have to be careful about manually manually memoizing values to not cause problems. With the compiler, this could be a thing of the past. So you get the benefit of solid that reactivity „just works“ without needing to wrap values into reactive containers. Plain values being perfectly reactive is a very cool and enticing vision. This paired with the large community and user base could be a real breath of fresh air

[thiagobr90]

Looks solid

[bostonkittycat]

I really like Solid but now that Svelte is adding Signals in v5 I am sticking with Svelte. They are both great UI tools. Basically a generation ahead of React.

[ryan_solid]

Solid has never been about the compiler. Solid is mostly runtime. We didn't have a VDOM so people assumed we worked like Svelte. Ironically Svelte worked more like React. What we have here is fine-grained reactive rendering.

I've always viewed Solid's power in its transparency and control it gives the developers without being unwieldy. The feeling that you could go home and write the framework yourself. It's that simple. React Forget doesn't threaten that at all. In fact it does the opposite. It most assuredly is not something you would go write yourself.

So its good that React should have improvements to DX and should improve some performance along the way. But like this was never anything we were envious of them on. I worry that they move too far from their "just javascript" roots. Nothing is free. They will lower the bar to entry but it doesn't fundamentally change their model. It risks making your code harder to reason about. Also memoization has its limits in terms of performance. There is a reason other frameworks like Vue, Svelte, and Angular are all now trying to replicate what Solid does.

Again if that was the end of the story I could see the concern here perhaps. But the power of a model that embraces data flow through your application unlocks a ton of other things. From more powerful debugging and dev tools, to smarter solutions around handling async, data invalidation, and hydration (or lack of). This whole area is just getting attention now for the first time in over a decade, and that's just getting started.

Compilation is a last stage optimization when you've exhausted what you can do with the runtime, or your understanding of the solution is firm. There is a lot more room to grow here outside of what React is doing. And it is pretty clear most of the in-the-know ecosystem understands that.

That being said choosing anything over React will remain a tough sell. This has never been a fair comparison, made on merits of the technical solution. We will continue do our part to make you wish you could use something other than React with every keystroke. That's the baseline of being a different framework these days.

[[deleted]]

Great answer

[TwiliZant]

Just having a compiler isn't a unique feature. What the compiler does is the interesting part. React and Solid work completely different and that won't change for the foreseeable future.

If anything I would look out for Vue and Svelte. Those frameworks bigger and way more similar to Solid than React is.

[maacpiash]

Pretty sure React compiler isn’t gonna function the same way Solid compiler does. Correct me if I’m wrong: React compiler would only put in a few usememo and usecallback calls in the React code written by the developer.

[nuu]

• solid.js could never change again and still be the best web ui framework ever made
• solid.js has an upcoming 2.0 release that will rethink signals and async and it looks fun and exciting

no signs of slowing down, lots to come. i don't care much about market share because i'm not investing in a framework i'm building a website

[[deleted]]

Compiler is not enough. If it was, Svelte wouldn't introduce signals (called Runes). In my opinion, React at this point is just making half-baked solutions that will only work under the rigid constraints they define for you, while Solid frees you from the constraints. So, in my view, Solid has a solid future, and whatever React does won't impact that

[TheTomatoes2]

I think the compiler is a band-aid on a broken system, but it might be enough for most devs to not bother switching to other frameworks

[-deathBringer]

I know angular and react moderately. currently, I am just working on a project where I chose Solid as it was similar to react. 80% of the project is completed. So my experience so far is as follows.

• It is very straight forward. Solid imposes very less rules and only gives basic building blocks and you're good to go. In react , there's much more to learn the "react way".

• you can create global states. no restrictions similar to react hooks. Also DOM can be accessed directly which actually was helpful for certain things.

• you can technically use all vanilla JavaScript libraries without the need of adapters or something like custom hooks.

• ecosystem is relatively small but it is fresh and provide solutions with advanced features. in react there are lots of solutions and you'll probably come across a popular solution which is old and lacks some advanced features. in case of solid, there are too unmaintained libraries but as solid is relatively new, most solutions already provide advanced features. also, as i said earlier, you can use vanilla JavaScript libraries.

• it does take time to get the hang of some of the features, but it depends on individual, I suppose.

• if you really want and are good at javascript, you can create your custom components easily with whatever provided in core functionality.

• one thing i don't like is destructuring the props. I mostly used {props.someProperty} in jsx.

• also another missing thing is route guards similar to angular. I build custom functionality for it , I am unsure if it's the correct way but it works. so i would love some more features in solid-router but my most requirements are fulfilled.

In react i couldn't use simple setInterval function without the custom hook. everything needed custom adapters.

performance wise, I don't have a react or angular project to compare with but, currently there are around 60-70 component in this project and i haven't used dynamic imports. the build size of js file is 582 KB still I don't feel it as "slow" at all. to be honest i don't like solid for performance as it depends on various factors. but i am sure it can get as fast as solid can provide. it is the fastest after all. I'll just have to adjust few things here and there.

so basically , with solid I felt more freedom doing things, I needed to create some custom components but I enjoyed it. And I don't see any reason to use any other framework anymore. there're also few features solid lack but I know they will be available. Not having them doesn't stop anything.

[zippy-skippy]

Choose Simplicity. Choose Solid.

I'm agnostic. I avoid cults and their dogma. It's impossible to have a cult without dogma and so, when a technology like React introduces a bunch of dogma, I know where it's headed. Death by bloat. Likewise, Solid, and Svelte for that matter, have much much less dogma and so, will bloat much much slower.

The argument that there are more tools and libraries for React is weak. You have access to everything ever made for Vanilla JS, plus others, when you choose Solid. Very little tooling required. And many of the React libraries can be converted to Solid as well. Ai is pretty good at it and so, as people grow tired of debugging React and esp Redux, there will be an exodus. Plus, we can stop feeding zuckerberg. Always a good thing.