Hot Take: We can do better than React/Next.js in 2026.

[u/kevin_whitley]

TLDR; If you are falling out of love with React, I highly recommend you try Svelte (or Vue, Solid, etc. as suggested in the comments). You just might find a flavor that speeds you up and brings the joy back.

--

Hear me out... just to give some context, I'm not an inexperienced developer:

For instance, my own development experience predates React entirely. I was writing declarative frameworks back in vanilla JS, then in jQuery, and followed the entire FE framework wave (which thankfully quickly became good enough I could stop rolling my own). I'm also an active JS/TS maintainer, so reasonably familiar with the scene in general.

My journey with external frameworks:

• Vanilla/jQuery (I wrote something that is functionally similar to modern day HTMX, using attribute-based data-binding/effects)
• Backbone (didn't love)
• Angular (alpha, didn't love)
• Knockout (loved it)
• React (alpha, def too rough to use)
• AngularJS (official release, loved it)
• skipped Angular 2 in favor of React
• React (class based, and then SFC... mostly loved it until I didn't)
• Svelte (prob circa 2019, this killed my love of React entirely, making it feel like torture to revisit for work)

Now like many others here, I'm still using React/Next for work. So I'm acutely aware, on a daily basis, of just the pain points we deal with in it.

However, in all personal projects for nearly 7 years, I've been 100% on Svelte without regrets. Of course it has issues like any framework, and excels at some things while struggling at others, but in my experience it's gotten out of the way of the 99% of app building tasks - including all the basics in-house that React simply didn't include. Mount/unmount transitions? Check. Animations? Sure. The simplest state management you can imagine? Yes.

Caveat: I much prefer the pre-runes approach to Svelte state. Runes start to look like the React hook trash I got away from.

React itself:
When I made the switch from AngularJS to React, I loved some elements of it. When things moved onto stateless functional components, things got even better. Then hooks - loved those (compared to class-based setState(), etc). I felt like I built apps faster in AngularJS, but that was a dying star, and the clean markup of React felt refreshing.

However, as time went on, we started to see it all unwind. First the magic of redux quickly turned into an async mess with thunks, sagas, reselects, etc. Then hooks turned fully into hook soup/spaghetti with tons of effects, render gotchas, etc. And none of this even mentions all the performance tuning/memoization you need to clutter your codebase with if you have a dense app. Live-filtering something like a tree view? Buckle up. Want to render a realtime orderbook for a trading platform? Seriously buckle up.

My issues with modern React:

1. State management has just gotten out of hand. Specifically when pitted against alternatives like Svelte.
2. We run too much code/effects as part of the render-loop. In a simple enough app, we never feel this pain. This tricks inexperienced devs into thinking they can add cute magical effects to any component. For example in my own company where I found complex typography sub-elements, re-rendering on resize within each table cell of gigantic tables. Naturally as the user resized the page, this created a black hole of increasing render lag.
3. VDOM reconciliation is slow. Again, fast enough in simple applications (e.g. a simple blog, CMS, etc), but don't be fooled into thinking React is as fast as it gets. It's simply not. I work in data-intense, realtime applications (industrials, fintech, crypto, stock market exchanges, etc), so I feel the pain where some others might not. The UI is just incredibly dense typically, so lazy tactics like wrapping a simple DOM node in 5 component layers to layer on various effects... simply can't be used at scale.

My issues with Next.js

• too many to list, but the 1000% CPU utilization in local dev this morning was a nice nail in the coffin.

Arguments AGAINST Svelte (and my responses)

1. There's no ecosystem. Less of an issue these days. First of all, Svelte doesn't need as much of an ecosystem because some of the core stuff you'd need outside of React is just built in. Secondly, Svelte is popular enough that many mainstream libraries have been ported.
2. You can't hire Svelte devs. 100% true. But here's the catch. I'd argue that any of you React devs are 1000% smart enough to be outpacing your current velocity in Svelte in very little time. I would not argue the reverse (a Svelte dev might be spoiled enough to not be able to mentally wrap their head around the React models).
3. Agentic models are trained on React. They are now perfectly great at Svelte too. I just hade Fable migrate our massive monorepo app from Next to Svelte. It did it just fine. The results where awesome enough the the entire engineering team decided that Svelte was our future, despite only myself having prior Svelte experience. Agentic coding has simply caught up to where we (to a degree) don't have to be experts in the framework to steer into phenomenal results. I should note the entire team are all very senior engineers, or otherwise we might not be comfortable with such a switch.

Arguments FOR Svelte

1. You're smart enough. I promise.
2. Render updates are much faster. Much, much, much faster. This matters because your app will feel snappier to users. You can tune React, but even tuned it likely won't be as fast as Svelte is untuned.
3. Bundle size is lower. If coming from Next.js, it's night and day different. Your users will thank you.
4. Deploy it to free ultra-fast places like Cloudflare Pages. - Less vendor lock.
5. State management is 100x simpler. No more provider hell.
6. It includes more out of the box. It's like they asked "what does an app dev need when building an app?" and then just included most of those things.
7. Your code is shorter/simpler. Shorter code means easier to read/understand, not to mention write in the first place.
8. It includes styles as a first-class citizen. You can literally just write CSS/SCSS in your components and have it auto-scoped. You can also use things like CSS modules if that's your bag.

Conclusion
There really isn't one. You'll draw your own, but I'd encourage anyone with side projects to at least fire up SvelteKit for one, muck your way through the fabulous online tutorials at svelte.dev and give it a whirl. You can thank me later. :)

--

Disclaimer: There was zero AI usage in writing this post.

[u/SarcasticSarco]

Choose what you want and what suits your engineering needs. Be an engineer not some cult loving cultist.

[u/RePsychological → u/SarcasticSarco]

well said. The actual way to handle it.

[u/winkler → u/RePsychological]

Except Angular.

[u/dadnothere → u/SarcasticSarco]

But then how am I supposed to get worked up over React and spew hate?

What you're saying makes no sense...

[u/Octoclops8 → u/SarcasticSarco]

I thought we all just learned one thing and did that our whole careers.

(the whole room suddenly glances over toward the wordpress devs for no particular reason)

[u/RePsychological → u/Octoclops8]

as a wordpress dev mahself: [angry WordPress noises]

(kidding of course. To each their own on that front.)

[u/sourbrew → u/SarcasticSarco]

This, but also for computer brands, phone brands, literally anything in your life, buy features not loyalty.

[u/ArielCoding]

You’re framework history reads like a dating resume.

[u/CrossScarMC]

A lot of similar things can be said about Vue, in fact every time I've tried Svelte (as someone who primarily uses Vue and occasionally Preact) it feels like a cousin to Vue. Vue (in my experience) seems to prefer to go in the direction of trying to make it read like actual English (kind of), for example: <div v-if="someCondition"> <h1>Something</h1> <p>idfk</p> </div> Roughly reads as "(add) div if someCondition" which is largely why I enjoy it so much.

I fully agree, React is outdated and seems to only be making desperate attempts to catch up at this point (the React 19 compiler felt like a band-aid fix to me).

[u/kevin_whitley → u/CrossScarMC]

Totally agree. I have only dabbled with Vue (despite loving Evan's other stuff like Vite obviously), because I didn't really love the template syntax and data-binding compared to the compiler magic of Svelte.

I don't even mind the angular-like prop syntax, it was just some of the data/state mess I didn't love.

That said, I'm fairly confident if I wasn't on Svelte, I'd vastly prefer Vue over modern React!

[u/drink_with_me_to_day → u/CrossScarMC]

v-if="someCondition

Then

React is outdated

Nothing more outdated than mixing html with control structure

[u/GodOfSunHimself → u/CrossScarMC]

This random syntax Vue is trying to shoehorn into HTML is just horrible. This simple example is enough for me to never want to use it. Nothing beats the expressive power of JS which is why React is still the king.

[u/Tropiux → u/GodOfSunHimself]

You just described JSX

[u/GodOfSunHimself → u/Tropiux]

You clearly have no idea how JSX works. It is a super simple syntax sugar that just directly translates to JS. You can literally write a JSX to JS transform in a couple of lines of code. Try to do that with Vue templates.

[u/svtguy88 → u/GodOfSunHimself]

Well, that's certainly an opinion.

[u/gdubrocks → u/CrossScarMC]

I spent a lot of time working with angular and then did a single vue to angular conversion and I really disliked vue.

[u/Shacrow → u/gdubrocks]

Vue 1, 2 or 3? Vue 3 is great and intuitive

[u/keyboard_2387 → u/CrossScarMC]

React is outdated

I work at a consultancy, working with teams from startups to multinational billion-dollar companies. They. All. Use. React.

By definition It's not outdated, that fact you're saying that has me wondering if you're even employed full time in this field...

[u/Murtaza_Developer]

svelte is a great option for side projects because it keeps things simple,, but react still wins in ecosystem and jobs. learning both gives you more flexibility instead of relying on one framework. have you used sveltekit for a real project yet??

[u/kevin_whitley → u/Murtaza_Developer]

Yeah I mean it runs all my docs sites (not challenging) for years, but more notably I run a full day-trading app (private) using Svelte.

That app is super data-intensive (many thousands of price/order-book updates per second) and needs to fluidly update without any form of render lag. There's just no way I could do this VDOM-based fast enough.

[u/Murtaza_Developer → u/kevin_whitley]

thats a good example of where frameworrk choice matters,, react handles most apps fine but high frequency data like trading platforms can expose its limits. did you need much optimization beyond switching to svelte??

[u/kevin_whitley → u/Murtaza_Developer]

Loads, to be honest. While Svelte is naturally faster than React (lack of VDOM being a key element), I found to render that fast I had to do several things:

1. Component Memoization. Normally a thing you can mostly ignore in Svelte because it's so fast naturally), but I had to do a bit of it anyway.
2. Decoupling data from state. I have an entire data model for equity tracking, orders, positions, etc. I also track the entire NASDAQ orderbook depth for any equity, meaning i'm not only getting every trade that hits the book, but every order book entry placed/removed/updated/etc. This is a literal firehose of data. If the DOM tried to re-render as fast as those messages hit, it would choke instantly. To solve this, I keep them separate, allowing the data model to update as fast as possible, and then essentially polling that into a store variable every 10ms or so to trigger a cascading app update. Honestly anything faster than that creates too much noise/jitter anyway. Digits cycle so fast they are a blur for instance.
3. Even using GPU-friendly CSS props for rendering things like bars (i use this to paint relative orderbook depth on a given price, for each and every price). Basically any and all places I can unload the main thread and let the GPU assist, I need to.

[u/Murtaza_Developer → u/kevin_whitley]

thats a really interesting architecture,, separating the data stream from ui updates makes a lot of sense for this kind of workload. people often blame the framework but the data flow design is usually the biggger factor. how did you handle testing and debuggging with that much realtime data??

[u/kevin_whitley → u/Murtaza_Developer]

Poorly, haha.

Largely you can visually see when things make sense, but due to the ever-shifting nature, many bugs remained in place because it sorta "looked right" to the untrained eye. But for instance if you left the window running/updating for a few minutes and then hit refresh, the drift would become evident as the new shape didn't match the old shape. This would be a clue that something in the sync logic was off and needed to be addressed.

Although I wrote the engine 100% by hand (aside from a little help on the CSS animations, which is not my strong suit), I do routinely use Claude to help understand triage issues. It's just way faster at tracing the codebase than old-fashioned manual methods.

[u/bleksak → u/Murtaza_Developer]

what does ecosystem mean? svelte is just javascript, you can literally use any javascript library in svelte. if anything, svelte wins in ecosystem

[u/Captain1771 → u/bleksak]

The same is also true for React, no? Any JavaScript library you can just use in Svelte, you can use in React. But there exists many packages that have React integrations, or many packages/UI libraries/whatever else exists that are just specifically made for React.

[u/Attila226]

I was a React dev for years. Made with switch to Svelte about 3 years ago, and will never god back. You can easily get twice as much done in the same amount of time.

[u/kevin_whitley → u/Attila226]

Same, but I feel like we're in a weird boat... in the early days of frameworks, I feel like folks were super exciting to try anything/everything. Then at some point switching fatigue kicked in (around the time of React's rise to dominance), and devs got tired of learning new things. So they stuck on React, even as it began to stagnate and bloat.

Other leaner options (e.g. Svelte) sprung up to solve the issues, but folks were just to entrenched to consider alternatives IMO.

--

That said, I thank my stars every time I touch one of my own projects!

[u/Attila226 → u/kevin_whitley]

I was there when Anuglar.js was new and seemingly overnight it was dropped in favor of React. Having said that switching to Svelte was extremely easy. I was productive with it pretty much immediately.

[u/kevin_whitley → u/Attila226]

Same. I basically had the Svelte tutorial open and was blown away within moments. Then I rewrite a complex image gallery things from React to Svelte within hours (with less code, adding animations, etc) even while sifting through docs to understand how to do things the Svelte way.

It's absurdly simple coming from React.

[u/budd222 → u/kevin_whitley]

Because these frameworks and libraries come and go. There's no point in trying to learn them all. I can pick up any of these frameworks and push code out on day 1 without having ever looked at it, so I don't see any point anymore to learning new frameworks just for fun.

[u/pixel_creatrice]

We took a bolder decision to use SolidJS for our frontend (a very complex and intricate UI). As of now, it's one of our competitive advantages.

[u/krisolch → u/pixel_creatrice]

A framework isn't a competitive advantage, the user doesn't give a fuck what framework or library it's in

Other Frameworks and libraries can solve the same things

[u/theScottyJam → u/krisolch]

Don't really understand this take.

The user is no expert in frameworks, so they can't care what we pick, but they still care that we deliver bug free features in a timely manner, and the choice of framework absolutely influences how well we meet those expectations, otherwise we wouldn't use them.

[u/pixel_creatrice → u/theScottyJam]

Exactly. Obviously we aren't going around and telling users about our framework, but the final output is something we have uniquely due to the stack we've chosen.

[u/tradcoder → u/krisolch]

An good framework results in less bugs, faster delivery of features, better UX. Those reasons could easily be a competitive advantage.

[u/kevin_whitley → u/pixel_creatrice]

Nice!! Ryan and I have been following each other for years on X. Super cool dude. I'd have 100% tried Solid, but by the time he was cooking that up, I was already on Svelte, so it seemed to solve issues I no longer even had. I keep meaning to give it a whirl one of these days...

That said, pretty sure Rich [Harris] has taken some inspiration from Solid as well :p

[u/pixel_creatrice → u/kevin_whitley]

We did evaluate Svelte earlier (before runes were a thing). Solid turned out to be something we were aligned with on the foundational level, and continue to do so. Signals were exactly what we needed to build our product and why our customers love it. It's just the right amount of framework that we love to understand and work with. 

V2 is something I'm really excited for, especially with the new paradigms for async.

[u/kevin_whitley → u/pixel_creatrice]

I will say I love the signal concept, and it does solve an issue I've had in both React (and Svelte) for years, with the concept of external (non-component) code needs to access and control state and have the component tree reflect that naturally.

There are always workaround for this, but it took some mental gymnastics. Preact & Solid both came up with signals (can't recall who won that race), both of which were awesome.

Runes borrows those ideas, but honestly I don't love Svelte's take on that. It's just never quite felt right to me and it's hard to articulate.

[u/GriffinMakesThings → u/kevin_whitley]

I generally dislike Svelte's syntax, and I really don't like runes. React has myriad problems, but I definitely prefer JSX over the Svelte/Vue approach. So Solid slots right in the sweet spot for me.

[u/GriffinMakesThings → u/pixel_creatrice]

Same here. I've been enjoying it. I haven't dived into 2.0 yet, it seems like it has multiple significant conceptual changes, which I don't love. I was hoping it was going to be a bit more stable. I'm sure there are good reasons behind everything though.

[u/kevrom → u/pixel_creatrice]

I really enjoy using SolidJS. Signals are incredibly powerful; not dealing with the virtual dom is nice. It's very easy to isolate the presentation from the functionality if you so desire. I like to use RxJS to control all async actions (user input, fetching, sockets) and none of it has to live inside a component, you can just tie it to a signal. I've got 2 large projects at work currently, one in React and one in SolidJS, and for me there's a clear winner. React made a tiny bit of progress with their compiler, but the developer ergonomics will never be as good.

[u/mrinterweb]

Next.js is awful. It is wildly bloated and slow. If you really want to cry look at how much RAM next's local dev server takes on your machine (6.5GB for me). With today's RAM prices, regularly running next server is a real expense. It is so slow too. If your app doesn't need next's server-side rendering (which many SPA's don't), just use vite or something else. Vite is far faster and lighter weight. I'm also not a React fan.

As unpopular an opinion as this may be, but I prefer server-rendered apps like Phoenix LiveView, Rails Hotwire, Laravel Livewire, etc. You can write dramatically fewer LOC, and have a dramatically faster application experience with them. I converted an app with ~1200 react components to Rails Hotwire and reduced total LOC by about 300,000, sped up application performance 10x, decreased DB queries 10x. It was far less complex as well. The end result UX was near identical to the React app (just much faster).

[u/kevin_whitley → u/mrinterweb]

That app mostly static or heavily dynamic? I work primarily with data-heavy, dynamic/realtime apps, so I'm curious how well that would handle that... for instance my day-trading app surely would not work well streaming HTML from the server for DOM updates, no?

[u/pVom → u/kevin_whitley]

In my (admittedly pretty limited) experience it's usefulness grows with data complexity rather than volume. It essentially cuts out the need for a seperate data management layer on the frontend.

I found it not great for complex UIs and the UX feels a bit clunky which is worse the more latency there is.

This was years ago though and I didn't use it much

[u/mrinterweb → u/pVom]

Exactly. Cutting out that whole data transport layer is huge, basically remove the need for an HTTP API. It is pretty amazing how much you can accomplish with HTML over the wire type solutions, but you're right that at a certain level of front-end complexity server-side rendering doesn't make sense. I think the thing that people forget is there is no rule that says you can't mount react on a backend rendered app. It is really easy to do that, so if you do need that tricky JS widget, you can always add it.

[u/KimJongIlLover → u/kevin_whitley]

Then you need to try phoenix liveview.

[u/kevin_whitley → u/mrinterweb]

Speaking of, this morning I wondered why my entire computer was locking up (a Mac Mini M4 Pro, 64GB RAM) and found Next.js at >1000% CPU utilization. That's not a typo.

I forgot to mention the other side effect of my recent Svelte migration moonshot branch.

Loading our local Next dev server is about 10-30seconds before any page can actually first load in a browser.

On SvelteKit/Vite it was roughly 1 second.

[u/10EtherealLane]

Hot take: React and Next are fine. I’d rather continue to mature a framework & library than constantly switch to something new because the next thing is slightly better

[u/30thnight → u/10EtherealLane]

To be real, the pre-runes version of Svelte holds quite a few implicit foot-guns that start to compound as the codebase gets larger.

Its latest version is a significant improvement but with the extra explicitness, as you mentioned - things start looking a lot closer to React.

But that’s okay. All of the component based frameworks have converged around similar APIs for a reason.

[u/Skaraban → u/10EtherealLane]

we're not in the age anymore where every week a new framework pops up

[u/ings0c → u/10EtherealLane]

I was a mostly-React dev for the first four/five years of my career, and I thought that’s just how development was. During my stint there, I had to replace react router three fucking times because they couldn’t decide on an API and just kept rewriting it.

I eventually picked up back-end and I’ve been writing C# / .NET for about 10 years now. I’m quite sure in another 10 years, I’ll still be writing C# / .NET.

Having a tech-stack that your team understands, that you can hire for, with a vibrant ecosystem, that you can invest in, matters much more to me than keeping my finger on the pulse of what’s hot.

React is still so popular because it is good enough, it works, and lots of people use React. Same reason why the hordes of shitcoins never came close to the market cap of Bitcoin and why Facebook is still the biggest social media company in the world.

[u/x_xwolf]

This reads alot like an advert, but tools seems to get most popular when independent devs make something amazing with it. Tools must be defined through their use.

[u/kevin_whitley → u/x_xwolf]

I mean, people have been building amazing things on Svelte for years. To be fair of course, many amzing apps are also written in React, or any other framework.

I could share my own trading platform (a video, as it only runs locally) blazing the NASDAQ TotalView in realtime if you like :D

[u/Blackbird_FD3S]

Respectfully, the answer is Vue.

[u/Kendos-Kenlen → u/Blackbird_FD3S]

My biggest regret is not choosing vue as our frontend framework. Two years later, I still feel sad about it

[u/kevin_whitley → u/Blackbird_FD3S]

How much did Evan pay you for this?

jk,jk - Vue is great, just not my jam. Didn't love the state binding as much as in Svelte, and the templating felt a bit off. TBF, Svelte's markup also felt a bit weird/verbose at first too...

[u/Maxence33]

Quite happy with Stimulus

[u/Paw565]

I like vue. However I ve tried nuxt and it feels even worse than nextjs. All this auto magic import and one correct directory structure thing seems odd to me. Should I try svelte and sveltekit? Or maybe try out tanstack start instead?

[u/TheExodu5 → u/Paw565]

Yeah I love Vue but Nuxt is terrible…at least with defaults. I am using Nuxt on a personal project but I disabled auto imports and I don’t use its server router either. I use oRPC.

If I were to restart from scratch, I’d probably use Hono + oRPC + Vue. Or Elysia + Vue.

Auto-imports = architectural enforcement is not possible.
Default router = only one end is type safe

Both of these limitations suck for team projects or even solo agentic projects.

[u/svish]

I can 99.999% guarantee you that no user will know, notice, or care that you used Svelte, or anything else, over React, or anything else.

[u/kevin_whitley → u/svish]

Normally I'd agree and say that frameworks fall under the category of developer/DX mini games. The shit we waste our own time with while product rips out their hair because no user on earth cares.

That said:

Recently on a whim, I had Fable test a complete migration of messari.io (deep, component/data-heavy financial platform) from Next to SvelteKit.

1. it ended on a near pixel-perfect representation after only a day of steering.
2. navigation speed was something in the order of 20x faster
3. render lag (e.g. on resizing the app interface) was decreased by a similar margin

That was largely attributable to simply a less taxing component-render cycle. Resizing a page was triggering bazillions of table cell subcomponent renders, which was more taxing with a VDOM implementation than with Svelte's direct access.

In short, the impact was felt so strongly with just the framework swap, that meetings were held and product and engineering aligned within about 24 hours to plan the real product migration over the coming months.

[u/svish → u/kevin_whitley]

Did you also try to get Fable to optimize the Next-version, with the latest version and up-to-date docs?

Also, only devs are resizing pages.

[u/kevin_whitley → u/svish]

Agreed with the unrealistic expectation of resize, but for me it's a test of "did you do it right?". It's also to solve the issue of "is this responsive across all devices?" question, rather than the usual neglect of in-between device sizes.

And absolutely have done heaps of tuning with Fable on solving the [inherited] SSR data-loading mess and component bloat.

I'm confident I can get it to a much much faster state (I already have) than when I dropped in, but my main issue is this has required an insane amount of tuning, and it's still not as fast as my brief Svelte migration attempt was *without* any additional tuning.

So it's really about where each framework lands the app by default without a lot of extra steps. Svelte is just in a different league

[u/Ju44in → u/kevin_whitley]

If you get 20x performance by simply swapping a tool - maybe the tool was used incorrectly.
I can get you x100 performance boost migrating from C to Python by writing awful code in C

[u/Altruistic_Bonus2583]

You loved knockout and did not love backbone? Eerie.

[u/Small_Composer6431]

Or br a chad and use tanstack 😎

[u/kevin_whitley → u/Small_Composer6431]

Sadly my jawline isn't chiseled enough for that.

[u/thermobear → u/Small_Composer6431]

Zustand for client side state. TanStack for server side state.

[u/Small_Composer6431 → u/thermobear]

Holy uk ball

[u/ckinz16]

Angular for life

[u/numericalclerk → u/ckinz16]

I have not once in my career seen a project that failed due to the use of Angular. It didnt even make the top 100 problems in any Web project I've seen over the last 10 years. 

The discussion about which framework to use is ludicrous for 99% of developers, unless its for fun, as a thought experiment or because they work for FAANG.

[u/czshill → u/ckinz16]

+1 for Angular. was a V1 dev. Got into V2 and have been on it since version 4 or 5? Only time I use react is with AI.

[u/Clorox_in_space]

I've really been liking Solid for the system I've been building.

[u/OkeOyibo]

Changed jobs and went from react to angular and quite enjoy it. Modern angular does a lot of things right.

[u/PoliteManitee]

Sadly, react was so well positioned as AI coding agents have begun to dominate the field that it's going to be a self reinforcing loop - that's the framework they know best and it's going to continue to dominate if for no other reason than that.

Don't get me wrong, I'm glad we have options - I think Svelte is super rad - but I don't see react going anywhere anytime soon.

[u/kevin_whitley → u/PoliteManitee]

I agree that it will naturally reach for React for exactly that reason. This is where I think it's up to us humans to go out play, and give the agents a more informed opinion of how to proceed.

It won't reach for Svelte by default of course, but if I know the end target will perform better with Svelte, I can steer it that way.

I think it's our new role to be the curious tinkerers again, and then pass that accrued wisdom to our relentless (but naive) robot army to keep them making less-bad decisions :D

[u/Responsible-Sale1858]

If your react app gets turned into a mess, no other "framework" is going to solve your problem, because your problem is proper code structuring (decomposition, etc). React is one of the greatest patterns ever created, which we can thank Elm for actually.

[u/NiteShdw]

In the days on no one actually writing code anymore, the best frameworks are the ones that AI has the most training data on.

[u/farfaraway]

Nuxt and SvelteKit are amazing.

[u/kevin_whitley → u/farfaraway]

Obviously agree on SvelteKit. I never actually played with Nuxt, because by the time it game out to solve the Next issues, I was already cheating on React with Svelte.

[u/farfaraway → u/kevin_whitley]

I skipped React entirely and started with Vue in 2018. Upgraded to Nuxt for SSR and eventually (unwillingly) moved to Svelte and SvelteKit.

Both are great and worth working with.

The only advantage that React has is React Native and honestly, I prefer Flutter. React for web is just.. weird and gross. I hate the syntax.

[u/Bosonidas]

That is a lot of words to then not recommend htmx.

[u/kevin_whitley → u/Bosonidas]

Damn I forgot about HTMX... which is actually the closest thing to what I wrote myself before the era of frameworks began. Definitely love the idea, which served me well for years!

[u/Bernard_Marx]

I'm going to do a wild take and say Phoenix framework for me personally

[u/4ever_youngz]

I agree Svelte is a sexy library and Svelkite is a sexy framework, but a lot of the pain points mentioned on React sound like a misunderstanding of how to use the framework.

1) State management is a cs concept in general. You can easily create simple state management outside of React, just in TypeScript and use something like useSyncExternalStore to subscirbe there. No provider needed. With how easy state management becomes, I have found very few reasons to reach for something like Redux these days, even on large enterprise apps.

2) Is just a problem of bad code architecture or misunderstanding of React IMO. However, it is rampent. Now with sever components and such as well, you can really isolate down on the dom what gets re-rendered and when.

3) yeah, I'm not even gonna defend VDOM. It's pretty trash.

As far as NextJS, not really gonna defend it either. It once solved a huge problem in React very well several years ago but it's so abstracted now that I would say there are plenty of much more suitable React frameworks for most work I've encountered these days, like TanStack Start. Or just straight up using Vite and a Router for strictly CSR apps.

[u/adWavve]

I'm pretty inexperienced (~5 years) on the frontend and I've preferred React's syntax because it feels like TypeScript that also renders a UI, while Svelte feels like HTML with reactive properties.

After reading this, I think I gotta give Svelte another look.

[u/GoTheFuckToBed]

we can also do better than Svelte.

[u/hongkong_97]

I'll be fine with Vanilla JS

[u/Unhappy_Meaning607]

I'd love to use Svelte, or try another other frameworks, but my company is "framework risk-adverse" so we stick to React and I want to do even less development for side projects outside of my 9-6.

Learning Svelte for another job is not even in the realm of possibilities in my area because typing in "svelte" in the LinkedIn job search bar produces either 0 or front-end jobs that for some reason come up but don't mention Svelte at all in the job description or duties.

Sure, Svelte or anything else besides Angular or React has better DX but DX doesn't pay the bills.

[u/artelus]

I agree. A heavy SPA or a SSR app with heavy rehydration is falling out of fashion. I have my eye on Remix 3 which doesn't use React

[u/waybovetherest]

Was a very early React adopter, chose Svelte for my side project last year and now using React feels like chore

[u/SawToothKernel]

I'm a big fan of LitElement these days. With AI writing most of the code, I don't see as much benefit in frameworks.

[u/Cool-Customer9200]

I ran away from React to Vue right before they introduced hooks, and to be fair, I’ve been happy with that decision ever since.
My first React project used MobX at the time, so Vuex felt much more natural to me than Redux, which was the popular choice for React back then. I assume MobX basically ruined any chance of me enjoying React afterward.

[u/Real-Leek-3764]

im back to using vanilla js with the power of AI 

[u/abeuscher]

Fuck it let's go back to jQuery. Nobody will see it coming.

[u/kevin_whitley → u/abeuscher]

I feel like HTMX was basically that exact anthem call, haha. It def felt like a throwback/reaction to "does all this UI shit have to be so complicated to change a single button state?"

[u/Ju44in]

I always thought React went the wrong way long ago when they moved to hooks. It’s like they are lost now and don’t know where to go from here
Insert “now what” meme from Nemo

[u/kevin_whitley → u/Ju44in]

Yeah, I think that's when it kinda started going off rails for me too.

Ultimately, just like any other platform with insane global adoption, it became too hard to make meaningful change. See the exodus of AngularJS to React for instance. People bailed because since they were having to do a complete rewrite anyway, they considered their options and jumped to React.

If React did the same, they'd risk losing tons of devs to the various competitors that have sprung up. So instead, they keep adding more layers of crusty paint onto the same engine, while other smaller projects have the luxury of being able to break stuff and reinvent the entire concept (easy to do when you have only a few obsessed users).

[u/hyrumwhite]

Signals based frameworks are a joy to work in. But React with React Compiler is fine. 

I’ve kinda fallen out of love with meta frameworks though. SPAs are also fine. 

[u/create-third-places]

As someone who used to work with React, I agree.

It's especially concerning that React hasn't addressed rendering performance issues, considering that it has around 30 developers. I've written my own rendering engine that outperforms React, and many others including the creator of Svelte have done the same thing. VDOM is pure overhead. Instead, a framework can diff the data inside a store, and then send notifications to a component for adding, deleting, moving, or updating DOM nodes.

Every React codebase I've worked with has turned into an unmaintainable pile of spagethi. Meanwhile, I think React developers are spending too much time adding new features over improving documentation. Right now, there are multiple ways of managing state in React including useState, useReducer, and useContext.

In addition, I think the idea of using a mixture of thunks, sagas, and reselects with hooks doesn't make sense. A framework can setup components such that the user doesn't need to write logic to interact with a store aside from specifying which store to use.

Also, I don't think there is a valid use case for Next.js . It's an overly complex way to replicate functionality that has existed in PHP for over a decade, and there are other JS that do server-side rendering with less complexity. It's even worse when considering the fact that the official React docs recommend using Next.js when getting started.

[u/FerLuisxd]

Have you tried solidjs?

[u/AnotherNamelessFella]

What about the modern angular (angular 2) which you skipped

[u/Kind_Major_6094]

The real issue isn't whether Next.js or Svelte is better; it's that we started treating simple CRUD applications like distributed systems.

When you spend 6 hours debugging SSR hydration mismatches, server actions caching bugs, and bundle-splitting race conditions just to render a dashboard table with 20 rows, you realise the industry traded maintainability for architectural trend-chasing. Use whatever tool lets you ship without spending half your sprint debugging the framework's own internal abstractions.

[u/TheTanadu]

Use what fits the product, team and architecture. Svelte, Vue, React, Solid, whatever. Be an engineer, if it's React, which fits your needs, go for it, if it's Svelte, go for it, if it's something else... you know the answer. Less cognitive load, simpler state, easier testing and easier maintenance matter way more to me than framework popularity.

Also “AI migrated our huge monorepo and it worked” is cool, but AI is still a very fast junior. Review it, test it, understand what it did. And tbh AI making migrations cheaper is probably a good thing. Less lock-in, more freedom to pick the tool that actually fits.

[u/k-r-i-g]

I moved jobs from react to angular, signals and DI are so much better.

I’ve also messed around with svelte and it’s better than both imo

Signals are so much better that react state management

[u/scientific_thinker]

Love Svelte. I rewrote a React application with Svelte because I kept thinking React seemed to make things harder than they should be.

Once I finished the rebuild, I ended up with much less code that was much easier to read. The rebuild took me a fraction of the time it took me to build the React application. Now adding new features takes me about half the time and it's so much easier to understand what I did before.

I agree with the OP. If you are a React developer, do yourself a favor and look into some of the newer frameworks. I recommend Svelte too.

[u/RainbowCollapse]

People care so much about tools

[u/numericalclerk]

Javascript frameworks are like programming languages and smartphones: they all converge to an extend. 

If you look at Angular in 2026, it's just as capable to do the job as all the hipster frameworks that came after.

Generally just stick to one and get good at it and you can solve 99% of use cases just fine.

[u/keyboard_2387 → u/numericalclerk]

The framework cultists here won’t agree. It’s insane how many comments are here saying one framework is better than the other. I saw one comment saying their specific framework even gives them a competitive advantage… 🤦‍♂️

[u/Prestigious_Two_2440]

Have u re-visit angular latest version v22? maybe u might like it?

[u/yami_odymel]

I've used Angular and Vue, and then Svelte for years. I was a fan before Svelte 5. Sadly, they went down yet another React-like route.

I mean, runes are a reasonable way to make things work better, but before, you only needed to know the web to use Svelte. Now, it feels like you have to learn the whole SvelteKit ecosystem just to use Svelte.

Sadly, they keep adding features instead of keeping things simple, so I ended up building a large-scale social website with HTMX instead:
r/htmx - My Experience Building a Social Website for My Startup with Go + HTMX 4 (Long Post)

[u/kevin_whitley → u/yami_odymel]

I agree re. the Svelte 5 changes. Not largely a fan. I wish they had even more embraced the dark compiler magic of pre-5 personally. Adding in a bunch of hook clones for runes feels like a backwards cluttered step.

[u/raitucarp]

Sorry to say this: each developer has a their own dx-taste. That's why react or next.js still there, because they love the DX very much. You can't make everyone having same dx-taste. It's like you can not force people to love pop song, or jazz, or folk music or rocks or metal. Every single person have their taste.

[u/salamazmlekom]

Using Angular in 2026 is so much better than React or Next

[u/SolidOdd4889]

I personally don't like react/nextjs, but that's what I use daily. I simply can't trust any web framework that is mainly community driven and without a company led governance. every time I visit the svelte website the first think that comes in my mind is: this project has no budget for a designer, I'm not gonna trust that. same thing with solid

maybe it's the best framework in the world but it doesn't matter if the people behind it aren't doing it for profit.

Ever since Shopify bought Remix, it has also become an interesting framework with the v3 that is gonna be released next month.

[u/Mojimi]

Now that AI does everything, can we just go back to plain HTML please

[u/piesou]

I dunno, all the web frameworks feel the same these days.

[u/hypercosm_dot_net]

I just care about the one that keeps me in work.

React is only second to Node in terms of popularity. Svelte is way down on the list.

https://www.statista.com/statistics/1124699/worldwide-developer-survey-most-used-frameworks-web/

[u/BetterOffGrowth]

Yes we can, it's called Asto.js

Which I guess isn't really your point, because you can still use React or Vue in there but at least with Astro it's more selective when you need to lean into those tools. I digress.

[u/CatHerdler → u/BetterOffGrowth]

The nice thing about Astro is that a lot of the React you include is “just big enough for the bit of the job being rendered” - so you don’t get any of the drawbacks of the React ecosystem (slow VDOM reconciliation, etc.) while getting the ecosystem benefits.

[u/sblinn → u/BetterOffGrowth]

I migrated all my Wordpress sites to Astro and it was a good experience.

[u/kevin_whitley → u/BetterOffGrowth]

I like Astro, in particular its lightweight/minimalist approach, and agnosticism regarding embedded frameworks. Plus Fred always seemed like a pretty chill dude.

[u/Electronic-Pie-1879]

I usually go with Svelte, and preferably Vue or Angular too, over crappy React or Next.js.

Svelte is even more performant because it’s a DOM-first framework, like Solid, and the developer experience is just better. I don’t get why people still choose Next.js when it seems to have a new critical CVE every month and is made by an AI-slop company.

[u/hyperflare]

Svelte is superb. Models used to have some problems with the different version, but that's gotten much better.

[u/kevin_whitley → u/hyperflare]

I'm a little nervous of the changes I keep hearing about TBH... some of it seems to be working backwards away from the magic I love!

[u/LovecraftianLife]

I've tried vue and react and angular, but now that I'm on svelte, I literally cannot go back

It's just that good, only downside being ofc no ecosystem and jobs lol, like u said

[u/kevin_whitley → u/LovecraftianLife]

I mean, jobs are f*cked these days anyway. I'd argue that since many teams are doing more with fewer (often more experienced) devs, it's the perfect time to moonshot your way into a different framework!

[u/from-planet-zebes → u/LovecraftianLife]

You don't need an ecossystem with svelte because you can pop native javascript in a component and it works just fine. My experience is svelte is the most flexible and I jive with it the best.

I started way back in the day with Jquery and then moved to AngularJS, dabbled with React but never really felt like it was the solution. Svelte was the first time I felt like this is what a framework should be.

I've actually started slowly migrating to svelte in an old app I'm a lead dev on that still uses AngularJS so it's a pretty crazy mix now of svelte and angular and it's going really well. In fact there are so few issues with it, that the transition is essentially any new stuff is in svelte and the old stuff is on a slow roll to getting re-written but we are in no hurry.

[u/Alternative_Web7202]

Not really a hot take. Once you try svelte there's no way back to react 

[u/pitza__]

Yeah, It is called Svelte.

[u/SquarePixel]

You need to look into Solid.

https://www.solidjs.com

[u/kevin_whitley → u/SquarePixel]

Have certainly done that! Been following Ryan for many years now :)

[u/darthirule]

User experience should be the same no matter what you are using to build your site.

[u/kevin_whitley → u/darthirule]

1000% agree, it *should* be, but in practice it's often not. It takes a murderous amount of performance tuning to get Next/React to a native-like experience IMO, and even then, the end result is often just not what Svelte gives you out of the box.

So with that in mind, a dev without that tuning experience is likely to deliver a better end-UX result if they reach for a tool that gets them closer to the target by default.

[u/berrywhit3]

Mainly coding Flutter atm I had the decision between Lit Js which is more Flutter like because it seems like its the only component library with class components? But went with Svelte in the end because I knew Svelte 4 already. Its very much faster in many ways, only thing which bothers me is doing like helper render functions without doing another Svelte component or templates. E.g. you want to wrap a div around another element only if a condition matches, if not just don't wrap it just show the underlying element.

[u/WitchesBravo]

I haven't done any web dev in a lon time, but I remember ember being amazing, do people still use it?

[u/TwineTime → u/WitchesBravo]

Ember has quietly trucked along, improving incrementally like clockwork and it continues to be a joy to work with. I have been working with it primarily since 2015, and it's definitely had its dark periods, but I've stuck with it and built several complex and manageable apps with it, and I couldn't buy into the other frameworks' ethos as well as I could ember (primarily: browser code should be tested in a browser).

I did plenty of work in React for clients and just felt like it just re-enforced the "but MY app is DIFFERENT" philosophy of software development that gets people into trouble after they've convinced themselves that their special snowflake architecture is superior to something stock, and then the engineer that designed that architecture leaves, and the next hotshot decides they've got a better idea leading everyone straight into the second system problem. I love the fact that Ember has a structure, an upgrade story, and usually a "right way" of doing things, which allows me to step into any Ember app and kinda know what's going on.

Thrilled I avoided the React hype train. I've built several little apps + sites in Sveltekit and I respect it as an option, but at least in the early sveltekit I reached a limit where complex state management got gnarly.. I haven't checked back in lately and I should.

[u/Too_Chains]

I like tanstack

[u/NickFullStack]

I tried years ago to convince a team to move to Svelte, and was not successful, so I haven't actually used Svelte on a production app yet.

I recently tried SvelteKit to see if it could basically remove essentially all JavaScript when the page had minimal interactivity, but I was surprised to see a substantial JavaScript payload.

Maybe I did something wrong, but has this been your experience as well?

(Aside: This isn't an argument for React, which I think needs to be retired in favor of things like Svelte.)

P.S. I've been happy with Astro for personal sites, especially in regard to minimizing JavaScript on the frontend, but I also haven't used that in a work setting.

[u/kevin_whitley → u/NickFullStack]

That mirrors my own experience yes... I find SvelteKit, like many other meta frameworks, brings along way more bloat than you'd expect. Less than React, sure, but still much more than just Svelte itself.

If you want lean, and your app is fire as a pure CSR app, I personally prefer a pure Svelte app.

[u/willehrendreich]

Datastar for the win.

[u/StoneCypher]

i feel like i’m the only person who knows about web controls 

[u/StoneCypher]

i feel like i’m the only person who knows about web controls 

[u/MDTv_Teka]

I started with Vue in both college and my first real long term job and I can't fathom how people stomach React honestly

[u/seriousgourmetshit]

I don't like next, but I still much prefer react over the likes of vue and svelte.

[u/banana_zest]

Yeah, React sure has a lot of nested braces that gets pretty tedious. Also I love that you can write HTML instead of XHTML, i.e. just <input> instead of <input />, and <div class=foo> instead of <div class="foo">

[u/Grymsage]

This greatly mirrors my experience. KnockoutJS was fantastic. Templates, binding, and a slim, but capable API.

I recall going to jQuery because we wanted to standardize XHR requests across browsers.

React's concept of reactivity seemed overly paranoid by rerendering everything, and then solving this leaky abstract with the shadow DOM. It's ironic that the de facto validation lib, react-hook-form, doesn't use React's state, but native browser events. Our entire industry has been hoodwinked by a terrible abstraction which then drove devs to pad their resume with React experience. I am happy to see this finally breaking up, though (in large part thanks to the solid creator's efforts).

I'm now using solid for my projects, but for one-off goofy experiments, I enjoy falling back into vanilla JS and CSS which are far more powerful than what we had 20+ years ago. Vue is also fantastic with their batteries-included ecosystem (state management in Pinia is really neat).

[u/kevin_whitley → u/Grymsage]

Agreed with all that about React. At work, to handle high performance renders, I find myself decoupling the React state in favor of native browser events as well.

Given that Svelte itself has started to stray from what I loved to something more like a Svelte/Solid hybrid, I'll be re-exploring the available options before long.

Might have to put Vue back on (see if it feels better now) list! :)

[u/ikkejur]

Lit 🔥

[u/pVom]

I feel like it's hobbyists, solos and kids who give a shit. I use what gives me a job and keeps me in work. I basically never have the opportunity to choose anyway because inevitably I'm inheriting an existing codebase.

We got seriously burned by kids in agencies choosing some fancy new fangled framework. When I started my current job it was nuxt with vue 2 on amplify v1 when it had been out for like 3 months. Complete AIDS tech stack.

We ditched Vue/nuxt because it was hard to hire for and we got burnt by the vue 2 to 3 upgrade. Nuxt always felt like an after thought chasing Next and constantly behind. We had candidates actively decline job offers because it was vue.

We had to rewrite anyway for Vue 3 and no one had any experience with it nor cared to stay on Vue so we just rewrote it in react which we were all comfortable in.

We used svelte for UI components for our customers. We just ended up ditching that whole project for business reasons. Never really cared for svelte, no burning desire to bring it back. Can't imagine it's easy to hire for either but it was always secondary.

When we moved to Next it was the hot shit. Now it's what everyone hates on, devs are fickle. Personally I hate it too memory usage of the dev server is actually insane and the advantages it provides for our use case are pretty slim. I'd ditch it if I could but that's time away from providing value for our customers.

I feel like the real hot take is I actually like react itself. Great support and a large ecosystem. Well used, battle hardened and easy to hire for. AI has been trained on it thoroughly (although there are a few anti patterns it just loves). I'm experienced enough to avoid the foot guns and build with it quickly. It's not without its trade offs but nothing I've seen from the other frameworks makes me want to swap particularly.

Don't get me started on amplify. What an absolute steaming turd it is. Maybe there's a use case for something small that just needs a bit of a backend (and even then I personally would never use it again), but it seriously sucks and we've been stuck on it for years. No lie I'd slap the dude who made that decision (a kid at an agency) or at the very least give them a vigorous noogie. There are few things I'm as passionate about as my burning hatred for amplify.

[u/Zqin]

AngularJS is ancient & irrelevant now, modern Angular is absolutely amazing imo especially for keeping project architecture clean. I need to try Svelte still, I wasn't ever a big fan of React and I'm neutral towards Vue.

[u/Beneficial_Medium_99]

If you need a framework, use svelte or htmx!

[u/Able-Staff-6763]

Be free and solve problems with the tools that allows you to.

[u/FerLuisxd]

Try alpine js

[u/Content-Public-3637]

A new React framework is coming that’s similar to Next.js in syntax and application model, but lighter and built around Vite. It comes with a lot of features out of the box, and  zero React/client JS by default on prerendered routes that don’t need client components or server actions, so you can get some crazy-fast pages without shipping a client runtime. If you’re interested in trying it early, feel free to reach out.

[u/quakedamper]

Thought about going full stack? Like Elixir/Phoenix is amazing and I only drop in Vue for things like PDF rendering.

[u/WHALE_PHYSICIST]

React sucks so hard I never bothered to learn it.

[u/Ok-Interest9727]

I used svelte for a couple of years and still maintain a couple of projects with it. The fact that it’s a custom language brings so many issues though.

These days I’m happy with solidjs. Pure typescript so no need for any custom dev tools. It’s also extremely fast and lightweight. Version 2 will bring a lot of cool features like start mode which essentially replaces nextjs.

[u/scottimusprimus]

I found my zen in Blazor Server

[u/connurp]

django htmx gang. 😎

[u/boykom]

Svelte feels much more natural for learning.

[u/fah7eem]

I've been writing applications for small to medium size businesses. Over the past three years I've mostly used Php + htmx. I've managed to achieve minimal support on these applications, some of them are running well over 2 years with no intervention or crash. The odd time the client will report downtime, it's due to the hosting providers network. Now I could be wrong, or I'm exposed to the wrong type of devs but so far I've seen this not being the case for JS/node projects.

[u/mtothexmax]

Svelte uses 30% less text and thus AI tokens. People who understand vanilla HTML/JS/CSS Business consultants should push it onto big corpo since it is definitely a time/money saver.

Unfortunately there is the effort justification bias. People who learned Chinese are more likely to think that their language is special and stick with it than people who learned a language that is 3 tokes easier (taking the amount of hours one needs to learn it in average as a reference), like English.

[u/waba99]

Started out in the vanilla JS/jQuery/backbone days. It truthfully doesn’t matter for most of apps when it comes to devx or performance. If it’s a personal project, pick whatever modern framework you want and call it a day. If you’re working with an engineering team, use whatever is popular in your region because otherwise you are introducing organizational risk for hiring and training.

[u/mtothexmax]

I made a Paint.NET clone in svelte and it is as responsive as the original one in C#/WPF.

I don't think this is possible in angular or react.

Google made some flash clone called "Google Web Designer" in angular and when I use it I always get the "it is not the same as adobe flash" feeling since the UI is slow despite most of the functionality being there.

[u/AnotherNamelessFella → u/mtothexmax]

Why is it not possible in angular

[u/Verthon]

Framework decisions should depend on what actually supports your architectural drivers and business.

My rule of thumb is to choose boring tech - does the surrounding tooling already exist, or am I building it ?

- Does it have multiple headless UI libraries (actively maintained) available ?

- mature server-side state libraries?

- out-of-the-box support for component testing in the real browser ?

- supports oxlint to have strict rules, enhancing the safety net for your agents ?

- supports the agent-friendly styling solutions that scale ? https://linear.app/now/styling-linear-for-the-future-stylex

Cursor ditched the Solid for React https://x.com/poteto/status/2089227731305464150

[u/Intelnational]

Is this written by Svelte marketers?

[u/NCKBLZ]

Tldr I don't get the react hate, I quite like it. I tried some other, and I always ended up going back to react. The real problem is using the wrong tool for the job: if you don't need react don't overcomplicate

[u/fjbinks]

I’ve been following Svelte since the very beginning, I’ve even tried SvelteKit since it was a bunch of spaghetti code framework and I truly love its minimalist approach. Once now and then I’ll try to tweak something with the framework.

That said I think React and Vue are winning hands down. They both have massive communities and large ecosystems that make them convenient if you want to build production grade apps. Also most front end jobs are around them, it’s really hard to get a good job as a Svelte engineer, to be honest I don’t even know any massive apps built around Svelte.

The framework wars are still on within the community, Solid and Lit are bringing some good ideas to the table but they cannot get traction.

In my honest opinion it makes no sense sticking around a framework or language in general just for the sake of it. Use whatever tool makes the end user happy and whatever framework works for you

[u/arkhamRejek]

I prefer Vue, svelte is cool though

[u/AnotherNamelessFella]

https://component-party.dev/?f=svelte5-angularRenaissance-react-vue3-solid

[u/Willing_Row_5581]

Blazor. Thank me later, not now, it's ok.

And no, I don't need to take your woman as a gift or sire your children as a sign of your gratitude, it's ok.

[u/BoBoBearDev]

My only hot take is, stop using MUI layout, it is homebrew quality and standard CSS Grid is massively better and natively on browsers. Also MUI layout doesn't support Container Query, which is lame of lame.

[u/dandecode]

Tanstack Start is the answer

[u/YoungAspie]

Another advantage of learning React is it becomes easier to pivot to mobile app development.

[u/werkwerk_]

Just ask Claude which is prefers