Redux 5.0: The Core Library Settles Into a Maintenance Role

What Redux 5.0 Actually Is

Redux is a JavaScript library for predictable global state management. The core package, which this repository contains, is a small store implementation: the README states it is 2kB including dependencies. It works with React but also with any other view library. The v5.0.0 release, published in December 2023, is the first major version in years. The repository's own documentation, however, is explicit that the core is no longer the recommended entry point. Redux Toolkit is described as the official recommended approach for writing Redux logic. This is a significant positioning shift. The core library is now a foundation, not a starting point. If you are evaluating this package, you are likely either maintaining an existing Redux codebase or you have a specific need for a minimal, framework-agnostic store. For greenfield projects, the README points you elsewhere.

The Single Store and Pure Reducer Mechanism

The core mechanism is straightforward and unchanged in its essentials. The entire global state is stored in a single object tree inside one store. The only way to change that state is to dispatch an action, which is a plain object describing what happened. Reducer functions, which must be pure, take the previous state and an action and return a new state. This design makes state transitions deterministic and testable in isolation. The README gives a basic example using Redux Toolkit, but the core itself works without it. The data flow is unidirectional: dispatch an action, the store runs the reducer, the new state replaces the old, and subscribers are notified. The emphasis on pure functions and a single source of truth is what gives Redux its predictability. There is no built-in support for async actions, side effects, or middleware beyond the basic store API. Those are added through the ecosystem, which is a deliberate constraint.

Getting Started: Commands and Templates

Installation is a single npm command. For the core library alone, the README gives: npm install redux. For a React app with Redux Toolkit, it gives: npm install @reduxjs/toolkit react-redux. The recommended way to start a new React app is to clone a template. For Vite, the command is: npx degit reduxjs/redux-templates/packages/vite-template-redux my-app. For Next.js, it is: npx create-next-app --example with-redux my-app. There are no official React Native templates, but the README links to community templates for standard React Native and Expo. The core package itself has no configuration files or build steps. You import createStore and write reducers. The README does not show a full core-only example, which is telling. The documentation assumes you will use Redux Toolkit for anything beyond the simplest store. If you want to see the raw core API, you would need to consult the API reference at redux.js.org, which is not reproduced here.

Where Redux Core Is the Wrong Tool

The README itself warns against using Redux without a reason. It lists three situations where it makes sense: you have reasonable amounts of data changing over time, you need a single source of truth, or keeping all state in a top-level component is no longer sufficient. Those are subjective, as the README admits. The core library is the wrong tool for small applications where local component state suffices. Adding Redux introduces boilerplate: action types, action creators, reducers, and store setup. For a simple counter or a form, that overhead is unjustified. The core is also wrong if you need async logic. The core has no built-in handling for API calls or side effects. You would need to add middleware like thunk or sagas, which are separate packages. If you are starting fresh, the core is the wrong tool because Redux Toolkit exists. The README says it all: Redux Toolkit 'simplifies most Redux tasks, prevents common mistakes, and makes it easier to write Redux applications.' Using the core directly means you forgo those benefits.

Redux Toolkit vs. the Core: The Actual Difference

The alternative to using the core directly is Redux Toolkit, which wraps the core. The difference is not just convenience. Redux Toolkit includes configureStore, which sets up the store with sensible defaults, and createSlice, which generates action creators and reducer logic in one place. The README shows a slice example where a reducer appears to mutate state directly: state.value += 1. That works because Redux Toolkit uses the Immer library to translate mutating code into immutable updates. The core does not do that. With the core, you must write reducers that return new state objects explicitly. Redux Toolkit also includes thunk middleware by default, so async logic is handled out of the box. The core is a smaller dependency, but you lose all of that. If you are evaluating the core, you are choosing a lower-level tool. The README's basic example is written with Redux Toolkit, not with the core API, which is a strong signal about what the maintainers recommend.

Maintenance, Upgrade Cost, and License

The repository is actively maintained, with the last push on December 23, 2023, and version 5.0.1 released on that date. The project adheres to Semantic Versioning, and the README states that every release includes migration instructions in the GitHub Releases section. That is important for upgrade cost. Moving from v4 to v5 likely requires changes, but the migration notes are documented. The license is MIT, which allows commercial use, modification, and redistribution without restriction, though you should read the full license text for any conditions. The core package is small, so maintenance burden is low. However, the ecosystem around it, such as middleware and devtools, may have its own release cycles. If you adopt the core, you are committing to a pattern that the maintainers themselves are steering users away from. That is not a fatal issue, but it means the core is unlikely to gain new features. Expect bug fixes and maintenance, not innovation.

Editorial conclusion

Redux 5.0.1 is for engineers who need a tiny, framework-agnostic state container and are willing to write boilerplate manually, or who are maintaining existing Redux code. It is not for new applications: the README itself directs you to Redux Toolkit, which is the recommended approach. Before adopting the core directly, verify that you truly need a global store, that you can manage the reducer and action boilerplate, and that you do not expect built-in async handling. If you want minimal setup and best practices out of the box, use Redux Toolkit instead.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes