Something changed in the React state management world. Zustand, a 1.2KB library with an API that fits on a sticky note, overtook Redux in weekly npm downloads. Redux Toolkit, the modern rewrite of Redux that eliminated most of the boilerplate complaints, is now the second-most-downloaded option for new projects[reference:4][reference:5].
That's a significant shift. Redux was the default answer to "how do I manage state in React" for nearly a decade. It had the ecosystem, the DevTools, the tutorials, the job listings. Zustand started as a niche alternative and is now the library most new React projects pick.
But downloads aren't a decision framework. Redux is still the right choice for a real set of problems, and Zustand is the wrong choice for a different set. This comparison is about which problems each library actually solves, and where the tradeoffs land in 2026.
Quick answer: which should you use?
| Your situation | Use this |
|---|---|
| Most new React apps | Zustand |
| Large team, complex async flows, need enforced structure | Redux Toolkit + RTK Query |
| You need time-travel debugging and action replay | Redux Toolkit |
| Small-to-medium app with a few global values | Zustand |
| Already on Redux Toolkit and it's working | Stay on Redux Toolkit |
| You need a huge middleware ecosystem | Redux Toolkit |
Default recommendation: Zustand. For most new React projects, it's the better default — smaller, simpler, and fast enough without any configuration. Choose Redux Toolkit if you have a large team, complex async data flows, or need enforced conventions so that code written by ten different developers still looks like it was written by one.
If you've been working through our React useState vs useReducer guide, you already understand the local-state-versus-global-state decision. This post is about what to do once you've decided you need global state.
The philosophical difference: library vs framework
The simplest way to understand the two libraries is this: Zustand is a library. Redux is a framework.
Zustand gives you a store and a hook. You define state and the functions that update it, and you consume the state in components. There are no actions, no reducers, no dispatch, no provider. The store is a plain JavaScript object with functions on it.
import { create } from "zustand";
const useStore = create((set) => ({
count: 0,
increment: () => set((state) => ({ count: state.count + 1 })),
decrement: () => set((state) => ({ count: state.count - 1 })),
}));
function Counter() {
const count = useStore((state) => state.count);
const increment = useStore((state) => state.increment);
return <button onClick={increment}>{count}</button>;
}
That's the entire library. No provider, no boilerplate, no ceremony.
Redux Toolkit requires more structure. You define a slice with a name, initial state, and reducers. You configure a store with that slice. You wrap your app in a Provider. You dispatch actions and read state with useSelector.
import { createSlice, configureStore } from "@reduxjs/toolkit";
import { Provider, useSelector, useDispatch } from "react-redux";
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 } });
function Counter() {
const count = useSelector((state) => state.counter.value);
const dispatch = useDispatch();
return (
<button onClick={() => dispatch(counterSlice.actions.increment())}>
{count}
</button>
);
}
Redux Toolkit is dramatically better than plain Redux — Immer lets you write mutating-looking reducers, createSlice generates action creators, and configureStore sets up sensible defaults. But it's still a structured framework with more moving parts than Zustand.
The tradeoff: Zustand's freedom is a feature for small teams and a risk for large ones. Redux's structure is overhead for small apps and a safety net for big ones.
Bundle size: 1.2KB vs 11KB
The numbers are stark, and they're published in multiple 2026 comparisons.
| Library | Gzipped size | Source |
|---|---|---|
| Zustand | ~1.2 KB | tech-insider.org, pkgpulse |
| Redux Toolkit | ~11 KB | pkgpulse |
Zustand's core is roughly 9x smaller than Redux Toolkit. One analysis described the bundle gap as 37x when comparing Zustand against the full Redux ecosystem[reference:6][reference:7].
Does 10KB matter? On its own, not much — it's less than a single image on most sites. But state management is infrastructure, and infrastructure costs compound. Every kilobyte of library code is a kilobyte your users download before they see anything. If you're optimizing for reducing JavaScript bundle size, Zustand is the lighter choice.
The bigger point isn't the raw kilobyte count. It's that Zustand's small size reflects a small conceptual surface. You can read the whole library in an afternoon. Redux Toolkit has more concepts to learn, more documentation to absorb, and more places for a new developer to get confused.
Boilerplate: the complaint that built Zustand
The "Redux has too much boilerplate" complaint is almost a cliché at this point. Redux Toolkit addressed most of it, but the comparison still favors Zustand.
Here's the same feature — a todo list with add and toggle — in both libraries.
Zustand:
import { create } from "zustand";
const useTodoStore = create((set) => ({
todos: [],
addTodo: (text) =>
set((state) => ({
todos: [...state.todos, { id: Date.now(), text, done: false }],
})),
toggleTodo: (id) =>
set((state) => ({
todos: state.todos.map((t) =>
t.id === id ? { ...t, done: !t.done } : t,
),
})),
}));
That's the whole store. No slice, no action creators, no dispatch.
Redux Toolkit:
import { createSlice } from "@reduxjs/toolkit";
const todoSlice = createSlice({
name: "todos",
initialState: { items: [] },
reducers: {
addTodo: (state, action) => {
state.items.push({ id: Date.now(), text: action.payload, done: false });
},
toggleTodo: (state, action) => {
const todo = state.items.find((t) => t.id === action.payload);
if (todo) todo.done = !todo.done;
},
},
});
export const { addTodo, toggleTodo } = todoSlice.actions;
export default todoSlice.reducer;
Then you wire it into the store, wrap the app in a Provider, and dispatch actions from components. It's not terrible — Redux Toolkit genuinely improved this — but it's more files, more concepts, and more indirection for the same behavior.
When the boilerplate is worth it: In a large team, the structure is the point. When ten developers are adding features to the same store, having a single slice file with named reducers makes the codebase predictable. You can't accidentally mutate state from a component. Every state change is traceable to a dispatched action. That's not overhead — that's a feature.
DevTools and debugging: Redux still wins
This is the dimension where Redux's structure pays off most clearly.
Redux DevTools is one of the best debugging tools in the entire JavaScript ecosystem. You get:
- Time-travel debugging — step backward and forward through every state change
- Action log — see every dispatched action with its payload and the resulting state diff
- State inspector — browse the entire store at any point in time
- Action replay — replay a sequence of actions to reproduce a bug
- Import/export — save a session and load it later to debug offline
Zustand DevTools is available, but it's opt-in and less powerful. You connect the store to the Redux DevTools extension, and you get action logging and state inspection. But the library doesn't give you the same level of structure around actions, so time-travel debugging is less useful — Zustand state changes aren't necessarily dispatched actions with names and payloads.
If debugging complex state transitions is a core part of your workflow, Redux still has the better story. If you mostly debug with console.log and the React DevTools, Zustand's simpler model is easier to reason about and the DevTools gap won't matter.
Async patterns: Redux Toolkit has RTK Query
Redux Toolkit ships with RTK Query, a full data-fetching and caching layer built into the same package. You define an API slice with endpoints, and RTK Query handles caching, invalidation, refetching, loading states, and optimistic updates.
import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
const api = createApi({
baseQuery: fetchBaseQuery({ baseUrl: "/api" }),
endpoints: (builder) => ({
getPosts: builder.query({ query: () => "/posts" }),
addPost: builder.mutation({
query: (body) => ({ url: "/posts", method: "POST", body }),
}),
}),
});
export const { useGetPostsQuery, useAddPostMutation } = api;
RTK Query gives you a complete client-side data layer in one package. For applications with complex server-state requirements — dashboards, admin panels, anything with heavy caching and invalidation — that's a significant advantage over assembling the same functionality from Zustand plus TanStack Query plus custom code.
Zustand's async story is simpler. You call an API in an action, update state when the response arrives, and handle errors yourself. For simple cases, this is fine. For complex caching and invalidation, you'd typically pair Zustand with TanStack Query, which is a common and effective combination.
The practical read: if your app is data-heavy and you want the data-fetching layer integrated with your state layer, Redux Toolkit + RTK Query is a stronger package deal. If your app has simpler data needs or you're already using TanStack Query, Zustand is the leaner choice.
TypeScript: Zustand is friendlier, Redux is stricter
Both libraries have good TypeScript support, but the developer experience differs.
Zustand requires very little type annotation. The store type is inferred from the object you pass to create. You can add explicit types for clarity, but you don't have to.
interface TodoStore {
todos: Todo[];
addTodo: (text: string) => void;
}
const useTodoStore = create<TodoStore>((set) => ({/* ... */}));
Redux Toolkit has more TypeScript surface area. You type the root state, you type the dispatch, you type hooks with useSelector and useDispatch. The createSlice types are good, but the setup requires more annotations and the generic types can get complex as the app grows.
For teams new to TypeScript, Zustand's lighter typing is more approachable. For teams that want the compiler to enforce the shape of every state change, Redux Toolkit's stricter types catch more mistakes. Our TypeScript error handling best practices guide covers the narrowing patterns that make either library safer.
When Redux Toolkit is still the right choice
I've been recommending Zustand for most of this post, so let me be clear about when Redux Toolkit wins.
Large teams with many contributors. When ten developers are working on the same codebase, conventions matter. Redux Toolkit enforces a structure: every state change is a named action, every reducer is in a slice, every async flow goes through a thunk or RTK Query. New developers can read the slice file and understand what the state does. Zustand's freedom means every developer might structure their store differently.
Complex async data flows. If your app has heavy caching requirements, complex invalidation rules, optimistic updates, and polling, RTK Query is a genuinely better solution than assembling the same behavior from Zustand and TanStack Query. The integration between the state layer and the data layer is the point.
You need time-travel debugging. Redux DevTools is still the best state debugging tool in the ecosystem. If reproducing state bugs is a regular part of your workflow, Redux's action log and time-travel debugging are worth the boilerplate.
You need the middleware ecosystem. Redux has a large ecosystem of middleware for logging, persistence, analytics, and side effects. Zustand has middleware too — persist, devtools, immer — but Redux's ecosystem is larger and more mature.
You're already on Redux and it's working. Don't migrate a working Redux codebase to Zustand just because Zustand is trending. Migration is expensive and the benefit is smaller than the internet suggests. Our guide on preventing unnecessary re-renders covers the optimization patterns that make Redux apps fast without changing libraries.
When Zustand is the clear winner
Small to medium apps with a handful of global values. A theme, a user session, a sidebar toggle, a few filters. Zustand's minimal API is the right amount of abstraction. Redux's structure is overkill for this.
You want to move fast. Zustand's learning curve is measured in minutes. Redux Toolkit's is measured in hours. For a small team or a solo project, that difference matters.
You're optimizing bundle size. Zustand's 1.2KB core vs Redux Toolkit's 11KB is a real difference, especially if state management is one of several dependencies you're evaluating.
You're already using TanStack Query. If you handle server state with TanStack Query, you don't need RTK Query, and Zustand pairs naturally with TanStack Query for the client state that remains.
You want a library that stays out of the way. Zustand doesn't prescribe how you structure your app. You can put a store next to the components that use it, or centralize everything in a stores/ directory. The library doesn't care.
A real story: the migration that wasn't worth it
A team I worked with had a Redux Toolkit codebase for a mid-sized SaaS dashboard. About 30 slices, heavy RTK Query usage, and a team of eight developers. It worked. The codebase was predictable, new developers could read any slice and understand what it did, and the DevTools made debugging straightforward.
A new senior developer joined and proposed migrating to Zustand. The pitch was familiar: less boilerplate, smaller bundle, faster development. The team spent six weeks on the migration.
The result was mixed. The bundle shrank by about 10KB. Development velocity on simple features improved slightly. But the team lost RTK Query's caching and invalidation logic, which had to be rebuilt with TanStack Query. They lost the time-travel debugging that had saved them more than once. And they gained a new problem: without Redux's enforced structure, three different developers structured their Zustand stores three different ways, and the codebase became less predictable.
Six months later, the team had partially migrated back to Redux Toolkit for the data-heavy parts of the app, keeping Zustand for the simple client state.
The lesson: the migration was technically successful and practically a wash. The right choice depends on the shape of your app and your team, not on which library is trending. If you're on Redux Toolkit and it's working, the migration is rarely worth it.
Decision framework
Here's how I'd choose for a new project.
Choose Zustand if:
- You're building a new app and want the simplest thing that works.
- Your global state is mostly client-side (UI state, preferences, session).
- You're handling server state with TanStack Query or similar.
- Your team is small or you're working solo.
- Bundle size matters to you.
Choose Redux Toolkit if:
- You have a large team and need enforced conventions.
- Your app has complex async data flows that benefit from RTK Query.
- You need time-travel debugging and action replay.
- You want the larger middleware ecosystem.
- You're already using Redux and it's working.
If you're genuinely unsure: Start with Zustand. It's easier to add structure later than to remove it. A small Zustand store can grow into a set of stores; a small Redux app can shrink into a set of slices. Both directions are manageable, but starting simple is easier.
Frequently asked questions
Is Zustand better than Redux?
For most new React projects, yes — it's simpler, smaller (1.2KB vs 11KB gzipped), and fast by default. But "better" depends on your context. Redux Toolkit is better for large teams that need enforced structure, complex async flows that benefit from RTK Query, and time-travel debugging.
Why did Zustand overtake Redux in downloads?
Zustand's growth came from developers frustrated with Redux's boilerplate. Redux Toolkit fixed much of that boilerplate, but Zustand's minimal API — no actions, no reducers, no provider — was simpler still. Zustand crossed 50% usage in State of React 2025 while Redux's usage declined[reference:8].
Should I migrate from Redux to Zustand?
Only if you have a specific reason. Migration is expensive, and the benefits are smaller than the internet suggests. If your Redux codebase is working, the cost of migrating usually outweighs the bundle savings. Migrate if you're rewriting the app anyway, or if the boilerplate is genuinely slowing your team down.
Can I use Zustand and Redux together?
Technically yes, but it's rarely a good idea. Mixing two state management libraries in one app makes the codebase harder to reason about. If you're migrating incrementally, run the two side by side during the transition and remove one when you're done.
What's the bundle size difference?
Zustand's core is about 1.2KB gzipped. Redux Toolkit is about 11KB gzipped. The full Redux ecosystem — Toolkit plus React-Redux plus middleware — is larger still. For a small app, Zustand's footprint is negligible; for a large app, the difference is measurable but rarely the deciding factor.
Does Zustand work with React Server Components?
Zustand is a client-side state library. It works in client components, but it doesn't run on the server. If you're building with React Server Components, keep server state on the server and use Zustand for the client state that remains. For mutations, see our guide on Next.js API Routes vs Route Handlers vs Server Actions.
Which is better for TypeScript?
Zustand requires less type annotation because the store type is inferred from the object you pass to create. Redux Toolkit's types are stricter but require more setup. For teams new to TypeScript, Zustand is more approachable; for teams that want the compiler to enforce every state change, Redux Toolkit catches more mistakes.
Need help choosing a state management architecture or migrating a Redux codebase without losing what made it work? Red Surge Technology builds maintainable React applications at scale. Get in touch to discuss your project.