How do lightweight stores like Zustand and Jotai differ from Redux?

Question

Accepted Answer

**Zustand** and **Jotai** are minimal state libraries that achieve global state with far less boilerplate than Redux, and with built-in **selective subscriptions** to avoid unnecessary re-renders. They take different mental models: Zustand is a single store; Jotai is atomic. ## Zustand — a simple, hook-based store ```jsx import { create } from "zustand"; // define a store: state + the actions that update it, all in one place const useStore = create((set) => ({ count: 0, increment: () => set((s) => ({ count: s.count + 1 })), // no actions/reducers/dispatch reset: () => set({ count: 0 }), })); function Counter() { const count = useStore((s) => s.count); // SELECT — re-renders only when count changes const increment = useStore((s) => s.increment); return ; } ``` No provider, no actions, no reducers, no dispatch — you call setter functions directly. The selector (`s => s.count`) means the component re-renders *only* when that slice changes. ## Jotai — atomic state ```jsx import { atom, useAtom } from "jotai"; const countAtom = atom(0); // a tiny piece of state const doubleAtom = atom((get) => get(countAtom) * 2); // derived atom function Counter() { const [count, setCount] = useAtom(countAtom); // works like useState, but GLOBAL return ; } ``` Jotai builds state from small **atoms** you compose; components subscribe to individual atoms and re-render only when those specific atoms change. ## Comparison with Redux ```text Redux (classic) Zustand Jotai Boilerplate high (actions/reducers) very low very low Provider required none minimal Mental model single store + dispatch single store, hooks atomic (useState-like) Re-renders needs selectors selector built-in per-atom (granular) Devtools excellent good good Bundle size larger tiny (~1KB) tiny ``` ## When to choose what ```text Zustand → simple global state, minimal ceremony (most apps' global needs) Jotai → bottom-up/granular state, lots of independent pieces, derived values Redux(RTK) → very large apps, strict structure, rich devtools/middleware ecosystem ``` ## Why it matters Zustand and Jotai represent the modern trend away from Redux's boilerplate toward **minimal, ergonomic** global state with built-in selective subscriptions (solving Context's re-render problem). Knowing they exist — and that Zustand offers a tiny single-store model while Jotai offers composable atoms — lets you pick a lightweight tool fitting most apps' global-state needs, reserving heavier Redux Toolkit for genuinely large, complex applications. The key shared advantage over Context is granular subscriptions that prevent over-rendering.