Comparisons

When choosing a state management library, it's common to compare several popular options like Context API, Redux, Zustand, Jotai, or Recoil. Here's how @bentoo/state-man stacks up against them based on practical criteria.

Overview

Library	Boilerplate	Performance	Simple API	Fine-grained reactivity	Persistence	Size
Context API	High	Medium	Medium	❌	❌	Native
Redux	Very high	High	❌	❌	🔄 via libs	~10kb
Zustand	Medium	High	✅	✅	✅	~2kb
Jotai	Low	High	✅	✅	❌	~3kb
Recoil	Medium	High	✅	✅	🔄	~8kb
State-Man	Low	High	✅✅	✅	✅	~1.3kb gzip

Context API

React's native solution for state sharing, but it can trigger global re-renders even on small state changes.

Common issue:

<MyContext.Provider value={{ count }}>
  <ComponentA />
  <ComponentB />
</MyContext.Provider>

➡ Any change to count may re-render both ComponentA and ComponentB, even if only one uses the value.

Advantages of state-man:

• Only updates components that read the value.
• No dependency on Provider.
• Much simpler and cleaner API.

Redux

Powerful and battle-tested, but:

• Very verbose.
• Requires setup with reducers, actions, dispatch.
• Manual immutability.
• Not reactive by default.

Redux basic:

dispatch({ type: 'INCREMENT' })

State-man:

setState(prev => prev + 1)

With state-man:

• Work directly with values.
• No actions, reducers, or boilerplate.

Zustand

Zustand and state-man share similar philosophies: hooks, reactivity, simplicity.

Differences:

• Zustand is more opinionated: uses selectors, middleware, devtools.
• state-man focuses on the essentials and is lighter (~1.3kb vs 2kb+).
• state-man offers an even more minimal API.

Zustand:

const useStore = create(set => ({ count: 0, inc: () => set(state => ({ count: state.count + 1 })) }));

State-man:

const useCount = create(0);
const { state, setState } = useCount();

Recoil

Built by Facebook for React, atom/selector-based, very powerful for complex apps.

Drawbacks:

• Heavier, more conceptual API.
• Uses providers.
• Less intuitive for small apps.

State-man: as simple as useState, with scalable reactive power.

Jotai

Jotai focuses on atom-based reactivity, similar to Recoil.

Similarities:

• Direct value access.
• Local reactivity.

Differences:

• Jotai depends on providers.
• Recoil-like with more complex concepts (atoms, selectors, etc).
• state-man doesn't require special structure — just a hook.

Conclusion

@bentoo/state-man is ideal for those who want:

• Extreme simplicity
• High performance
• Zero dependencies
• Hook-based reactive API

Without giving up power or scalability — with built-in persistence and state sharing.

When to use

Use @bentoo/state-man if you want:

• Simple global/local state management
• To avoid Context and Redux
• Performance without the hassle
• Built-in persistence without plugins
• A useState-like API that you can share anywhere in your app

When it might not be ideal

Avoid if you:

• Need advanced middleware like redux-saga
• Depend on specific devtools
• Require deep integration with tracking libraries (as of now)