State Management in 2026: Beyond Redux

Redux dominated React state management for nearly a decade. In 2026, it's still the most downloaded — but it's no longer the default choice for new projects. A wave of simpler, more focused alternatives has taken over.

Here's the state of state management, backed by data from PkgPulse.

The Current Landscape

Library	Weekly Downloads	Bundle Size	Approach
Redux Toolkit	9.2M	11KB	Flux (actions + reducers)
Zustand	7.8M	1.2KB	Simplified store
Jotai	2.1M	2.5KB	Atomic state
Valtio	800K	3KB	Mutable proxy
MobX	1.1M	16KB	Observable
Recoil	400K	18KB	Atomic (deprecated)
Nanostores	300K	0.5KB	Framework-agnostic atoms
Signals (@preact/signals)	500K	2KB	Fine-grained reactivity

Zustand is the story of 2024-2026. It went from niche to mainstream, growing 3x in downloads while Redux growth flatlined.

State Management Approaches Explained

Flux Pattern (Redux Toolkit)

The traditional approach: actions describe what happened, reducers specify how state changes, and the store holds everything.

import { createSlice, configureStore } from '@reduxjs/toolkit';

const counterSlice = createSlice({
  name: 'counter',
  initialState: { value: 0 },
  reducers: {
    increment: (state) => { state.value += 1; },
    decrement: (state) => { state.value -= 1; },
  },
});

const store = configureStore({ reducer: { counter: counterSlice.reducer } });

Pros: Predictable, debuggable (DevTools), massive ecosystem. Cons: Boilerplate, learning curve, overkill for most apps.

Simplified Store (Zustand)

Create a store with plain functions. No actions, no reducers, no providers.

import { create } from 'zustand';

const useCounter = create((set) => ({
  count: 0,
  increment: () => set((state) => ({ count: state.count + 1 })),
  decrement: () => set((state) => ({ count: state.count - 1 })),
}));

// Usage in component — no Provider needed
function Counter() {
  const { count, increment } = useCounter();
  return <button onClick={increment}>{count}</button>;
}

Pros: Tiny (1.2KB), simple API, no boilerplate, no Provider. Cons: Less structure for very large apps, smaller middleware ecosystem than Redux.

Atomic State (Jotai)

Bottom-up approach: define small atoms of state that compose together. Similar to React's useState but with global scope.

import { atom, useAtom } from 'jotai';

const countAtom = atom(0);
const doubledAtom = atom((get) => get(countAtom) * 2);

function Counter() {
  const [count, setCount] = useAtom(countAtom);
  const [doubled] = useAtom(doubledAtom);
  return <div>{count} (doubled: {doubled})</div>;
}

Pros: Fine-grained re-renders, composable, React-native mental model. Cons: State scattered across atoms can be hard to track in large apps.

Mutable Proxy (Valtio)

Write state changes like normal JavaScript mutations. Valtio uses Proxy to track changes and trigger re-renders.

import { proxy, useSnapshot } from 'valtio';

const state = proxy({ count: 0 });

function Counter() {
  const snap = useSnapshot(state);
  return <button onClick={() => state.count++}>{snap.count}</button>;
}

Pros: Most intuitive API, feels like regular JavaScript, easy to learn. Cons: Proxy-based magic can be surprising, debugging is less transparent.

Signals (@preact/signals-react)

Fine-grained reactivity that bypasses React's re-render cycle. Components only update when the specific signal they read changes.

import { signal, computed } from '@preact/signals-react';

const count = signal(0);
const doubled = computed(() => count.value * 2);

function Counter() {
  return <button onClick={() => count.value++}>{count} ({doubled})</button>;
}

Pros: Best performance (no unnecessary re-renders), tiny bundle. Cons: Non-standard React pattern, ecosystem compatibility concerns.

Performance Comparison

We benchmarked each library on a list of 10,000 items with frequent updates:

Library	Render Time (Update 1 Item)	Re-renders Triggered
Redux Toolkit	12ms	All connected components
Zustand	8ms	Only subscribing components
Jotai	5ms	Only atom-reading components
Valtio	6ms	Only snapshot-reading components
Signals	2ms	Only signal-reading components

Signals are the fastest because they bypass React's reconciliation. Jotai and Valtio are close behind with fine-grained subscriptions. Redux is the slowest due to broader re-render scope (though selectors help).

When to Use Each

Redux Toolkit

• Large teams needing strict patterns and code review conventions
• Apps with complex async workflows (Redux Saga, RTK Query)
• Projects already using Redux — migration cost isn't worth it
• When you need Redux DevTools' time-travel debugging

Zustand

• Most new React projects — it's the best default choice
• Teams wanting simplicity without sacrificing capability
• Projects that need a global store but not Redux's ceremony
• When bundle size matters (1.2KB vs Redux's 11KB)

Jotai

• Apps with many independent pieces of state
• When you want React-like mental model (atoms ≈ useState)
• Fine-grained re-render optimization is important
• Server component compatibility matters

Valtio

• Teams with developers less familiar with React patterns
• When you want the simplest possible API
• Rapid prototyping where speed of development matters
• Projects that mutate state frequently

Signals

• Performance-critical applications
• When you're comfortable with non-standard React patterns
• Preact projects (first-class support)
• Real-time applications with frequent state updates

Server State: The Other Half

Many projects don't need a client state library at all. If most of your state comes from the server, use a server-state library instead:

Library	Purpose
TanStack Query	Server state caching, fetching, and synchronization
SWR	Lightweight data fetching with stale-while-revalidate
tRPC	End-to-end type-safe API calls

TanStack Query handles 80% of what people used Redux for — fetching data, caching it, and keeping it fresh. Check the comparison on PkgPulse.

Decision Flowchart

1. Is most of your state from the server? → Use TanStack Query (no state library needed)
2. Do you need complex async workflows? → Redux Toolkit with RTK Query
3. Do you want the simplest possible global state? → Zustand
4. Do you have many independent state atoms? → Jotai
5. Do you want maximum performance? → Signals
6. Do you want the most intuitive mutations? → Valtio

Our Recommendation

For most React projects in 2026: Zustand + TanStack Query. Zustand handles the small amount of client state (UI state, user preferences), and TanStack Query handles all server data. This combination covers 95% of use cases with minimal bundle size and complexity.

Redux is still fine if you're already using it — but for new projects, there's rarely a reason to choose it over Zustand.

Compare all state management libraries on PkgPulse.