vue-svelte-size-analysis VS jotai

but that's not true. see https://krausest.github.io/js-framework-benchmark/current.html. There is also a break-even point in bundle size where svelte gets larger compared to vue. see https://github.com/yyx990803/vue-svelte-size-analysis

i did not ignore it. You can read about it here. There is break-even point where svelte falls off compared to vue as the application grows.

The first version of React was released on 2013, it took almost 10 years for Suspense to exist (we _just_ got it now with React 18), that's what I'm talking about. Even functional components and hooks took a lot of time from them get and implement the idea after they tried to use ES classes and made everything much harder to manage. Context also isn't perfect, I like it but the redraw performance is not amazing and doesn't scale at all to bigger applications.

> https://github.com/yyx990803/vue-svelte-size-analysis

This is an interesting comparison I haven't seen before, I wonder if it's true for a complete application using some lib for state management, routing, etc. and if this isn't just a kind of cherry picked example. Thanks for showing this though.

probably only true for small projects

You are citing this: https://github.com/yyx990803/vue-svelte-size-analysis

There isn't only the size of the runtime but the size of the component code. Not all components are equal. Templates in each framework compile differently. Evan You, creator of Vue put together a comparison between Svelte and Vue which was pretty illuminating.

Daishi Kato, creator of Zustand and Jotai, says there are a few things we need to support RSC serialization:

I've just published jotai-wrapper, a super tiny and simple utility library that makes using jotai even simpler. It comes from the necessity to migrate a project with react-context-slices to jotai. Both libraries share a similar API. While in react-context-slices you have the useSlice hook, in jotai you have the useAtom, useSetAtom, and useAtomValue hooks. In react-context-slices you define either React Context or Redux slices, while in jotai you define atoms. The need for the migration from the first to the second was a high memory usage by react-context-slices when using React Context slices.

Atom-based: splits states into tiny pieces of data called atoms, which can be written to and read from using React hooks. In this group, we have Recoil and Jotai.

jotai Is the signal based state manager I recommended, offering the best developer experience (in my opinion) as it eliminates the necessity to define and update a global store

Jotai 🧙‍♂️

Atomic libs include Recoil, Jotai, and the one I maintain: Zedux. Zedux especially was designed to work well with sockets and RxJS observables and has been getting some traction recently, so of course I recommend checking it out. Feel free to hmu with any questions.

Global State Machine: Jotai (great for any state that needs to be stored globally for your application)