[FEE-607] State Management Libraries
INFO
State management libraries are tools with opinions. Each one embeds a philosophy about how state should be structured, updated, and observed. Redux treats state changes as recorded events. MobX treats state as a living spreadsheet. Jotai builds state from the bottom up, one atom at a time. The paradigm you adopt sets how state is debugged, tested, and refactored for as long as the library stays in the codebase, and swapping it out later means rewriting store logic and retraining the team. This article compares seven libraries at the paradigm level first, the API surface second.
Context
The problem these libraries address, keeping multiple views consistent with shared data, predates React. Knockout shipped observables with automatic dependency tracking in July 2010, and Backbone followed that October with models and collections that emit change events for views to subscribe to. AngularJS (2010) organized shared state through scopes and injectable services. Elm the language shipped in 2012; the model-view-update pattern of computing new state from an action and the previous state emerged from early Elm programs and was formalized by the community around 2015. Redux's own "Prior Art" documentation credits Elm, noting that Elm updaters "serve the same purpose as reducers in Redux."
Since then, the work has run on parallel tracks rather than a single timeline:
- React. Flux (2014) introduced unidirectional data flow, and Redux (2015) distilled it into a single store updated by pure reducers. React Hooks (2019) covered many cases that previously required a store; Redux co-creator Dan Abramov had written "You Might Not Need Redux" back in 2016, and Hooks made that advice practical for more applications. Recoil (2020, repository archived January 2025) and Jotai added atomic, bottom-up state. React Server Components and the Next.js App Router (2023) moved data fetching to the server, shrinking what remains on the client.
- Vue. Vuex (2015) adapted the Flux pattern to Vue's reactivity system. Pinia, first released in 2019, became Vue's official recommendation in 2022 when Vuex entered maintenance mode, removing the mutation layer in favor of direct writes inside actions.
- Angular. Angular applications share state through injectable services and RxJS observables with no extra library. NgRx (first
@ngrx/storerelease in December 2015) layers a Redux-style store on top for teams that want an explicit event log. - Framework-agnostic. MobX (2015, initially released as Mobservable) offers mutable observables with automatic dependency tracking. XState (2017) models state as explicit machines. Nanostores (2021) provides atomic stores under a kilobyte that work across frameworks. Zustand (2019) and Valtio (2020), both from the Poimandres collective, are minimal React-first stores that also run outside React, so they straddle the React and framework-agnostic tracks.
These tracks accumulated; none replaced another. Adoption has always been partial: at any given time, most applications manage state with framework built-ins or component-local state and use none of these libraries. Among the libraries, Redux is still widely used (Redux Toolkit modernized its API), and MobX still powers large applications. npm's registry shows the current shape of that coexistence: as of July 2026, Zustand logs roughly 176M downloads per month against roughly 98M for @reduxjs/toolkit, a signal of where new projects are leaning. Download counts measure adoption, not quality.
A cross-framework convergence is underway: Solid, Vue, Preact, and Angular each ship a signal-style fine-grained reactive primitive, and the TC39 Signals proposal (Stage 1 since April 2024) aims to standardize the shared core across frameworks. See FEE-611 for the API comparison and the tracking algorithm underneath; this article stays focused on the store-level libraries above it.
This article examines the design philosophy of seven libraries spanning those tracks: Redux, Zustand, Pinia, Jotai, MobX, Nanostores, and Valtio. The goal is to help you recognize which mental model fits your context.
Visual
State Management Paradigm Comparison
The four paradigms differ in how state flows. Flux enforces a strict cycle through actions and reducers. Atomic stores compose small independent pieces. Observable/proxy systems allow direct mutation with automatic tracking. Vue-native stores integrate with the framework's built-in reactivity.
Example
A shopping cart shows where the paradigms actually diverge: an items array, a total derived from it, and an asynchronous price refresh. A counter cannot show this, because a counter has no derived value and nothing to await. The same cart is implemented below in Redux Toolkit, Jotai, and Valtio, covering the Flux, atomic, and proxy paradigms; a Pinia setup-store example (without the derived total or async refresh) appears in Common Mistakes #3.
1. Redux Toolkit (Flux / Event Sourcing)
// store/cartSlice.ts
import { createSlice, createAsyncThunk, createSelector, type PayloadAction } from '@reduxjs/toolkit';
interface CartItem {
id: string;
name: string;
price: number;
qty: number;
}
interface CartState {
items: CartItem[];
priceUpdateStatus: 'idle' | 'loading' | 'failed';
}
const initialState: CartState = { items: [], priceUpdateStatus: 'idle' };
export const refreshPrice = createAsyncThunk(
'cart/refreshPrice',
async (itemId: string) => {
const response = await fetch(`/api/prices/${itemId}`);
const { price } = await response.json();
return { itemId, price };
}
);
const cartSlice = createSlice({
name: 'cart',
initialState,
reducers: {
addItem(state, action: PayloadAction<CartItem>) {
state.items.push(action.payload);
},
},
extraReducers: (builder) => {
builder
.addCase(refreshPrice.pending, (state) => {
state.priceUpdateStatus = 'loading';
})
.addCase(refreshPrice.fulfilled, (state, action) => {
const item = state.items.find((i) => i.id === action.payload.itemId);
if (item) item.price = action.payload.price;
state.priceUpdateStatus = 'idle';
});
},
});
export const { addItem } = cartSlice.actions;
export default cartSlice.reducer;
// Derived state lives outside the slice, memoized so it recomputes
// only when `items` changes.
export const selectCartTotal = createSelector(
(state: { cart: CartState }) => state.cart.items,
(items) => items.reduce((sum, item) => sum + item.price * item.qty, 0)
);// Cart.tsx
import { useSelector, useDispatch } from 'react-redux';
import { refreshPrice, selectCartTotal } from './store/cartSlice';
function Cart() {
const items = useSelector((state) => state.cart.items);
const total = useSelector(selectCartTotal);
const dispatch = useDispatch();
return (
<div>
{items.map((item) => (
<div key={item.id}>
{item.name}: ${item.price} x {item.qty}
<button onClick={() => dispatch(refreshPrice(item.id))}>Refresh price</button>
</div>
))}
<strong>Total: ${total}</strong>
</div>
);
}Derived state is a memoized selector built with createSelector. Async state is a thunk with three lifecycle actions (pending, fulfilled, rejected); the reducer here handles pending and fulfilled explicitly.
2. Jotai (Atomic / Bottom-Up)
// store/cartAtoms.ts
import { atom } from 'jotai';
interface CartItem {
id: string;
name: string;
price: number;
qty: number;
}
export const itemsAtom = atom<CartItem[]>([]);
// Derived atom: recomputes automatically when itemsAtom changes.
export const totalAtom = atom((get) =>
get(itemsAtom).reduce((sum, item) => sum + item.price * item.qty, 0)
);
// Async atom: a write-only atom whose function body awaits a fetch,
// then updates itemsAtom.
export const refreshPriceAtom = atom(null, async (get, set, itemId: string) => {
const response = await fetch(`/api/prices/${itemId}`);
const { price } = await response.json();
set(
itemsAtom,
get(itemsAtom).map((item) => (item.id === itemId ? { ...item, price } : item))
);
});// Cart.tsx
import { useAtomValue, useSetAtom } from 'jotai';
import { itemsAtom, totalAtom, refreshPriceAtom } from './store/cartAtoms';
function Cart() {
const items = useAtomValue(itemsAtom);
const total = useAtomValue(totalAtom);
const refreshPrice = useSetAtom(refreshPriceAtom);
return (
<div>
{items.map((item) => (
<div key={item.id}>
{item.name}: ${item.price} x {item.qty}
<button onClick={() => refreshPrice(item.id)}>Refresh price</button>
</div>
))}
<strong>Total: ${total}</strong>
</div>
);
}Derived state is a read atom that depends on itemsAtom directly, with no selector to configure. Async state is a write atom whose setter function happens to be async; there is no separate pending/fulfilled/rejected vocabulary. A component that only reads totalAtom does not re-render while refreshPriceAtom is in flight.
3. Valtio (Observable / Proxy)
// store/cartStore.ts
import { proxy } from 'valtio';
interface CartItem {
id: string;
name: string;
price: number;
qty: number;
}
class CartStore {
items: CartItem[] = [];
// A plain getter is Valtio's derived-state mechanism: it re-evaluates
// against current proxy state on every read, with no separate wiring.
get total() {
return this.items.reduce((sum, item) => sum + item.price * item.qty, 0);
}
}
export const cartState = proxy(new CartStore());
// Async state: a plain async function that mutates the proxy directly.
export async function refreshPrice(itemId: string) {
const response = await fetch(`/api/prices/${itemId}`);
const { price } = await response.json();
const item = cartState.items.find((i) => i.id === itemId);
if (item) item.price = price;
}// Cart.tsx
import { useSnapshot } from 'valtio';
import { cartState, refreshPrice } from './store/cartStore';
function Cart() {
const snap = useSnapshot(cartState);
return (
<div>
{snap.items.map((item) => (
<div key={item.id}>
{item.name}: ${item.price} x {item.qty}
<button onClick={() => refreshPrice(item.id)}>Refresh price</button>
</div>
))}
<strong>Total: ${snap.total}</strong>
</div>
);
}Derived state and async state use the same mechanism: mutate the proxy, and every subscriber that read the mutated property re-renders. There is no reducer, no selector, and no separate vocabulary for "this update happens to be asynchronous." refreshPrice reads like an ordinary async function because it is one.
Best Practices
Match the library to actual complexity; do not add Redux for simple cases. SHOULD evaluate whether your application actually has the problems a library solves before adding one. Redux earns its overhead when you need a complete audit trail, middleware pipelines, and time-travel debugging for a large, multi-developer codebase. For a small app where local state and useContext are sufficient, Redux adds indirection without benefit. As the library's own co-creator wrote: "Don't use Redux until you have problems with vanilla React."
Colocate state with the feature that owns it. SHOULD organize store state by feature domain, not by data type. State that belongs to the product listing feature should not be spread across a global monolithic store slice accessed by unrelated modules. When a feature is deleted, its state should be deletable too. Colocated state reduces the blast radius of changes and makes the relationship between features and their data explicit.
Avoid putting server state in a global store. MUST NOT mix server-fetched data (user lists, product catalogs, API responses) with client-owned state (theme, sidebar open/closed, form drafts) in the same store. Server state has distinct concerns: staleness, background refetching, deduplication, cache invalidation. A client store is not equipped to handle these automatically. Use TanStack Query or SWR for server state and reserve the client store for data the client genuinely owns.
Use selector memoization to prevent excess re-renders. When a component subscribes to a store, SHOULD pass a selector that returns only the minimal slice the component needs. Zustand selectors use referential equality by default; Redux Toolkit selectors via createSelector (Reselect) memoize derived values. A component that reads the full store object re-renders on every store change. A component that reads a single derived value re-renders only when that value changes.
Design Thinking
Redux: State Changes as Recorded Events
Redux is built on three principles borrowed from Flux and event sourcing:
- Single source of truth. The entire application state lives in one store, a single JavaScript object tree. This makes serialization, debugging, and server-side rendering straightforward.
- State is read-only. The only way to change state is to dispatch an action: a plain object describing what happened. Views and network callbacks never write to state directly.
- Changes are made with pure functions. Reducers take the previous state and an action, and return a new state object. No mutations, no side effects.
This architecture makes state changes predictable and traceable. Every change is an action object that can be logged, serialized, replayed, and inspected in DevTools. Time-travel debugging (stepping backward and forward through state history) is a natural consequence of this design.
The tradeoff is verbosity. A single feature in raw Redux requires an action type constant, an action creator function, and a reducer case. Redux Toolkit (RTK) was created to eliminate this boilerplate while preserving the philosophy. RTK's createSlice generates action creators and reducers from a single declaration. Immer runs under the hood, allowing "mutative" syntax that produces immutable updates.
Redux is strongest when you need: a complete audit trail of state changes, middleware pipelines (logging, analytics, optimistic updates), time-travel debugging, or a large team that benefits from the enforced structure.
Zustand: Redux Without the Ceremony
Zustand strips Flux down to its essentials. It keeps the concept of a centralized store with immutable updates but removes the boilerplate:
- No Provider required. The store is a module-level singleton accessed via a hook. No React context, no wrapper components.
- No action types or dispatchers. State updates are plain functions defined inside the store.
- Works outside React. The store can be read and updated from vanilla JavaScript, event handlers, or WebSocket callbacks.
- Minimal API surface. The core API is
create(to define a store) and the returned hook (to consume it). Selectors prevent unnecessary re-renders.
Zustand's philosophy is that the Flux pattern is sound but the ceremony around it is not. State should still be updated immutably, but developers should not need to define action types, wire up dispatchers, or wrap their app in a Provider. Zustand's own comparison of state libraries frames the split as where state lives and how it changes: Zustand keeps a single, immutable store outside the component tree, Valtio's proxy is mutable, and Jotai distributes state across composable atoms instead of one store. The result is a library that feels like "Redux for people who find Redux too heavy."
Middleware support (persist, devtools, immer) is available but optional. You add complexity only when you need it.
Pinia: Leverage the Framework
Pinia is Vue's official state management library, replacing Vuex. Its philosophy is straightforward: if you are using Vue, your state management should feel like Vue.
Key design decisions:
- No mutations. Vuex required explicit mutation functions to change state. Pinia eliminates this layer entirely. Actions can be synchronous or asynchronous, and state can be modified directly.
- Two store styles. Options API stores (state, getters, actions as an object) feel familiar to Vuex users. Composition API stores (using
ref,computed, and plain functions inside a setup function) leverage Vue's reactivity primitives directly. - Vue DevTools integration. Pinia provides a timeline of actions, visual store relationships, and time-travel debugging through the Vue DevTools panel.
- HMR support. Stores can be hot-reloaded during development without losing state.
- SSR-safe. Pinia handles per-request state isolation, preventing cross-request pollution in server-rendered applications.
- Flat architecture. No nested modules. Stores are independent and can import from each other, even circularly.
Pinia's philosophy is that state management should not fight the framework. Vue's reactivity system already tracks dependencies, triggers updates, and provides computed properties. Pinia wraps this system in a thin layer that adds DevTools, SSR safety, and organizational structure. It does not add more than that.
Jotai: Bottom-Up Composition
Jotai takes the opposite approach from Redux. Instead of a single top-down store, state is built from the bottom up using atoms, tiny, independent units of state.
Core concepts:
- Atoms are primitives. An atom holds a single value: a number, a string, an object. It is the smallest possible unit of state.
- Derived atoms. An atom can be defined as a function of other atoms. When a source atom changes, derived atoms recompute automatically. This is similar to computed properties but at the store level.
- No Provider needed (optional). Jotai works with or without a Provider. Without one, atoms use a default global store. With one, you can scope atoms to a subtree (useful for testing or multiple instances).
- Fine-grained re-renders. A component that reads atom A does not re-render when atom B changes. React only re-renders the components that subscribe to the specific atoms that changed.
Jotai's philosophy is inspired by Recoil, whose repository Meta archived in January 2025; Jotai is its actively maintained successor in the React ecosystem. State composes like functions: small atoms combine into larger structures through derivation, not through a monolithic store object. This makes Jotai particularly effective for applications with many independent pieces of state that occasionally need to interact.
The minimal core API (atom, useAtom) is around 2KB. Extensions like atomWithStorage, atomWithQuery, and atomWithMachine add persistence, data fetching, and state machine capabilities without bloating the core.
MobX: The Spreadsheet Model
MobX's philosophy is captured in one sentence from its documentation: "Anything that can be derived from the application state should be. Automatically."
MobX uses transparent functional reactive programming (TFRP):
- State is mutable. You define observable objects and modify them with plain JavaScript assignments, for example
store.count++. There is no reducer to write and no dispatch step. - Automatic dependency tracking. MobX records which observable properties each component reads during rendering. When those specific properties change, only those specific components re-render, without a selector function to write by hand.
- Computed values. Like a spreadsheet cell that references other cells, computed values derive from observables and recompute only when their dependencies change.
- Reactions. Side effects (logging, network requests, localStorage writes) run automatically when their observed dependencies change.
The mental model is a spreadsheet: cells (observables) hold raw data, formulas (computed values) derive from cells, and when you change a cell, all dependent formulas recalculate automatically.
MobX requires less code than Redux for the same functionality, and its mutable API feels natural to developers coming from object-oriented backgrounds. The tradeoff is less visibility: without an explicit action log, tracking down "what changed this value and when?" can be harder. MobX does support actions (via action and flow decorators) to provide structure when needed.
Nanostores: Minimal and Portable
Nanostores takes minimalism to its logical conclusion:
- Framework-agnostic. The same store works with React, Vue, Svelte, Solid, Lit, Angular, and vanilla JavaScript. You import a framework-specific binding (e.g.,
@nanostores/react) that weighs almost nothing. - Tiny footprint. As of the project's current README, the core library measures between 340 and 864 bytes minified and brotlied. That byte budget is a design constraint: every API addition is measured against it.
- Atomic stores. Like Jotai, state is organized as small independent stores. Unlike Jotai, stores are framework-agnostic objects with
.get()and.set()methods, not React-specific atoms. - Lazy lifecycle. Stores can define
onMountcallbacks that run only when a component subscribes. When the last subscriber disconnects, cleanup runs automatically. This is useful for WebSocket connections, timers, or other resources that should only exist while in use.
Nanostores' philosophy: state management should be a thin, portable layer that does not lock you into a framework. If you switch from React to Svelte, or need to share state logic between a React app and a vanilla JS widget, your stores should work unchanged. The cost is fewer features: there is no built-in DevTools panel, so debugging relies on plain console logging or manual instrumentation. You get a minimal primitive and build what you need on top.
Valtio: Write JavaScript Naturally
Valtio bridges the gap between mutable and immutable worlds using JavaScript Proxies:
- Mutable writes. You create a proxy object and mutate it directly, for example
state.count++orstate.todos.push(item), the same syntax you would use on a plain object. - Immutable reads. The
useSnapshot()hook returns an immutable snapshot of the proxy. React uses this snapshot for rendering and can efficiently detect which properties changed. - Module-scope state. Like Zustand, the store lives outside React. You can update it from anywhere: event handlers, WebSocket callbacks, timers, other modules.
Valtio's philosophy is that the immutability requirement of React should be the library's problem, not the developer's. You write state updates in the most natural JavaScript possible, and the proxy layer translates mutations into immutable snapshots behind the scenes. The result is an API that feels like plain JavaScript but integrates cleanly with React's rendering model.
The Decision Matrix
Choosing a library depends on context. These are the dimensions that matter:
| Dimension | Redux/RTK | Zustand | Pinia | Jotai | MobX | Nanostores | Valtio |
|---|---|---|---|---|---|---|---|
| Paradigm | Flux / event sourcing | Simplified flux | Vue-native reactive | Atomic / bottom-up | Observable / proxy | Atomic / portable | Proxy / mutable |
| Framework | React (primarily) | React (primarily) | Vue (exclusively) | React (primarily) | Any (React, Vue, etc.) | Any | React (primarily) |
| Bundle size (min+gzip, bundlephobia, 2026-07) | ~17.4KB (RTK 2.12 + react-redux 9.3) | ~0.5KB (v5.0) | ~6.6KB (v4.0) | ~4KB (v2.20, full package) | ~18.4KB (v6.16) | 340-864 bytes (core, min+brotli per README) | ~2.6KB (v2.3) |
| Boilerplate | Medium (RTK) / High (raw) | Low | Low | Low | Low | Low | Low |
| DevTools | Excellent (time-travel) | Good (Redux DevTools compatible) | Excellent (Vue DevTools) | Basic | Good (browser extension plus trace/spy utilities) | None built-in | Basic |
| New concepts to learn | actions, reducers, dispatch, middleware, selectors (5) | store hook, selector (2) | store, state, getters, actions (4) | atoms, derived atoms, write atoms (3) | observable, computed, reaction/action (3) | store, .get()/.set(), onMount (3) | proxy, useSnapshot (2) |
| Best for | Large teams, audit trails | Small-medium React apps | Vue applications | Fine-grained React state | Complex derived state | Multi-framework, micro-frontends | Devs who prefer mutation |
Common Mistakes
1. Using Raw Redux Instead of Redux Toolkit
// OUTDATED -- manual action types, action creators, switch statements
const INCREMENT = 'counter/increment';
function increment() {
return { type: INCREMENT };
}
function counterReducer(state = { count: 0 }, action) {
switch (action.type) {
case INCREMENT:
return { ...state, count: state.count + 1 };
default:
return state;
}
}
// MODERN -- Redux Toolkit handles all of the above
const counterSlice = createSlice({
name: 'counter',
initialState: { count: 0 },
reducers: {
increment(state) {
state.count += 1;
},
},
});Redux Toolkit is the official, recommended way to write Redux. It eliminates the boilerplate that gave Redux its bad reputation. If you are writing switch statements in reducers, you are writing legacy Redux.
2. Mixing Multiple State Libraries Without Clear Boundaries
// CONFUSED -- Redux for auth, Zustand for UI, Jotai for forms, MobX for a dashboard
// Every developer must know four APIs, four mental models, four sets of DevTools
// DISCIPLINED -- one primary library, clear reasons for exceptions
// "We use Zustand for all client state.
// We use TanStack Query for server state.
// No exceptions without a documented reason."Each library introduces a mental model. Mixing multiple models in the same application multiplies cognitive load and makes onboarding difficult. Pick one library for client state and one for server state. Add a second client-state library only with a documented justification.
3. Not Using Framework-Native Solutions First
// WRONG (Vue app) -- installing Zustand or Redux for Vue
// These libraries are React-first and do not leverage Vue's reactivity
// CORRECT (Vue app) -- use Pinia, the official Vue state management
import { ref } from 'vue';
import { defineStore } from 'pinia';
export const useCounterStore = defineStore('counter', () => {
const count = ref(0);
function increment() { count.value++; }
return { count, increment };
});Pinia for Vue, signals for Angular, Svelte stores for Svelte. Framework-native solutions integrate with the framework's reactivity system, DevTools, and SSR pipeline. Cross-framework libraries (Zustand, Redux) are excellent for React but lose their advantages when forced into other ecosystems.
4. Choosing Based on Hype Instead of Actual Needs
// HYPE-DRIVEN
"Jotai is trending on Twitter, let's migrate from Redux."
// NEEDS-DRIVEN
"Our app has 200+ Redux actions and time-travel debugging is critical for QA.
Migrating to Jotai would lose action history and require rewriting all tests.
The current Redux Toolkit setup works well. We stay."New libraries solve real problems, but they also introduce migration costs, retraining, and new edge cases. Evaluate against your actual pain points: Is your current solution too verbose? Too slow? Too hard to test? If the answer is "it works fine, but I saw a cool demo," the migration cost is not justified.
Related Topics
- FEE-600 State Management Overview — the taxonomy that classifies state categories and when each matters
- FEE-601 Local Component State — the simplest alternative that eliminates the need for a library entirely
- FEE-603 Context & Prop Drilling — why context is not a state manager, and when a library is actually needed
- FEE-604 Server State & Data Synchronization — TanStack Query, SWR, and the separation of server state from client state
- FEE-611 Framework Signals — the 2024+ signals convergence across Solid, Vue, Preact, and Angular, and the TC39 proposal standardizing the shared primitive
References
- Dan Abramov and Andrew Clark, "Redux: Motivation," Redux documentation (2015). https://redux.js.org/understanding/thinking-in-redux/motivation
- Dan Abramov and Andrew Clark, "Redux: Three Principles," Redux documentation (2015). https://redux.js.org/understanding/thinking-in-redux/three-principles
- Redux Toolkit team, "Redux Toolkit: Quick Start," Redux Toolkit documentation (2026). https://redux-toolkit.js.org/tutorials/quick-start
- Poimandres (pmndrs), "Zustand," GitHub (2026). https://github.com/pmndrs/zustand
- Poimandres (pmndrs), "Comparison," Zustand documentation (2026). https://zustand.docs.pmnd.rs/learn/getting-started/comparison
- Eduardo San Martin Morote, "Pinia: Introduction," Pinia documentation (2026). https://pinia.vuejs.org/introduction.html
- Daishi Kato, "Jotai: Introduction," Jotai documentation (2026). https://jotai.org/docs
- Michel Weststrate, "MobX: README," MobX documentation (2026). https://mobx.js.org/README.html
- Andrey Sitnik, "Nanostores," GitHub (2026). https://github.com/nanostores/nanostores
- Daishi Kato, "Valtio: Getting Started," Valtio documentation (2026). https://valtio.dev/docs/introduction/getting-started
- Dan Abramov, "You Might Not Need Redux," Medium (2016). https://medium.com/@dan_abramov/you-might-not-need-redux-be46360cf367
- Mark Erikson, "Why React Context is Not a 'State Management' Tool," blog.isquaredsoftware.com (2021). https://blog.isquaredsoftware.com/2021/01/context-redux-differences/
- Meta Platforms (facebookexperimental), "Recoil," GitHub, archived January 1, 2025. https://github.com/facebookexperimental/Recoil
- TC39, "Proposal: Signals," GitHub, Stage 1 since April 2024. https://github.com/tc39/proposal-signals
- npm, Inc., "Download counts for zustand," npm Registry API, accessed July 2026. https://api.npmjs.org/downloads/point/last-month/zustand
- npm, Inc., "Download counts for @reduxjs/toolkit," npm Registry API, accessed July 2026. https://api.npmjs.org/downloads/point/last-month/@reduxjs/toolkit