HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
reduxjs
redux
TypeScript2015–2024
reduxjs / redux

redux

A JS library for predictable global state management

65Distinct people
151Mentions
4Explicit recommenders
61.4KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

A JS library for predictable global state management

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

Thanks for doing what you do. I contributed some of the initial documentation [1] for testing middleware back in the day. Wondering if there are any areas in particular you'd…

daveidol used a recommendation phrase. 4 indexed comments match. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 6:28:55 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year151 dated mentions

Observed mentions: 2015-06-04 14:48:56 UTC to 2024-12-05 20:12:54 UTC.

01020302015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 34 mentions; 7 submissions, 27 comments20152016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 16 mentions; 2 submissions, 14 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 24 mentions; 1 submissions, 23 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 27 mentions; 4 submissions, 23 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 20 mentions; 2 submissions, 18 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 23 mentions; 0 submissions, 23 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2024

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC34727
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC16214
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC24123
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC27423
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC20218
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC23023
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC404
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC000
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC202
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC101

What Hacker News says

23 sources
Sorry to hear that :( I get what some of what you're saying here, but I also feel a couple of these complaints are misguided. For one thing, the Redux team has never intentionally tried to make Redux "the main state management tool for React". We've never deliberately sold it that way, and goodness knows the React team has said "React is the only official state management tool for React". Redux got popular because it solved the problems people were dealing with when it came out, better than the existing tools in the ecosystem, at a time when React was taking off. We've done our best to clarify in the docs when it does actually make sense to use Redux. Redux Toolkit is still Redux. You're still writing reducers, creating a store, dispatching actions, and updating the UI based on state. RTK just allows you to do so with less code. So, th
Read the rest
e "Essentials" tutorial starts by introducing those terms, concepts, and data flow, because you need to understand those regardless of how you're writing Redux logic. While Redux _is_ normally used with React, it's also UI-agnostic, hence the separation from React-Redux, and using it with other UI frameworks is a valid use case that we support. We had some long debates about whether to add these additional APIs into the Redux core [0] [1], and concluded that there was too much inertia around the existing Redux ecosystem to build those into the core `redux` package. As it is, even though RTK isn't required, we've had folks say they didn't like some of the opinions we've built into RTK (like using Immer for writing reducers). So, combining all three of those packages into a single super-package is not feasible at this point. I've tossed around the idea of trying to merge the Redux core, React-Redux, and RTK docs into one site, but that would likely require merging all three libs into a monorepo. Not impossible, but not something that's likely to happen any time soon, if only because my own time is very limited and I have a lot of other docs work I need to focus on [2]. Which specific docs page are you referring to? You said "intermediate" and "advanced" - sounds like you're referring to the RTK docs site tutorials [3]? FWIW, I wrote those a year ago, and at the time the main Redux docs were frankly very out of date. I've spent much of this year rewriting the Redux core tutorials, as listed above, and those Redux tutorials are where I would direct anyone who's new to Redux or really wants to know about RTK. We do also have an open issue to discuss what tutorial content should be on the RTK docs site [4], and tbh I'm really not sure _what_ tutorial content should actually be on the RTK site now that the "Essentials" and "Fundamentals" tutorials exist in the core docs. You're right that the actual Redux core itself isn't very complicated, but the biggest issue is trying to teach people to "think in Redux". In fact, it's kind of _because_ the core is so small that there's a lot of documentation needed - so much of this is actually in the patterns around how to use Redux effectively. Anyway, if you can point to some more concrete concerns or have specific suggestions on how we can improve things, I'm very interested - please feel free to comment over in the issues. [0] https://github.com/reduxjs/redux/issues/3321 [1] https://blog.isquaredsoftware.com/2019/10/redux-starter-kit-... [2] https://github.com/reduxjs/redux/issues/3592 [3] https://redux-toolkit.js.org/tutorials/intermediate-tutorial [4] https://github.com/reduxjs/redux-toolkit/issues/371
In How I write Elm applications
Thank you, it's really great to hear that feedback! Totally agree that RTK works best if you already know how to write Redux code "by hand", so that you're familiar with the concepts and can see what the abstractions are doing for you. That said, my goal for that "Essentials" tutorial is that folks who have never used Redux before (like, say, someone in the middle of a typical bootcamp) would hopefully be able to start writing real Redux code using RTK and be productive with it, even if they don't understand everything that's going on under the hood. The feedback we've gotten on this new tutorial, as well as on RTK in general, tell me we've mostly managed to hit that goal. FWIW, my next task is to rewrite the existing "Basics/Advanced" tutorial sequence. It will still be a "bottom-up" explanation that teaches the underlying mechanics an
Read the rest
d shows how to do things "by hand", but I want to clean it up considerably to remove outdated references and show simpler patterns. If you're interested, my notes on how I want to redo it are here: https://github.com/reduxjs/redux/issues/3855 If you've got any feedback on the contents of the existing tutorial and what you'd like to see improved, please feel free to leave a comment there.
In React is becoming a black box
Strictly speaking, nothing says a reducer even _has_ to have a switch statement. A reducer can use _any_ conditional logic it wants inside: `if`, `for`, `while`, lookup tables, etc. It's just that the most obvious conditional construct for "checking multiple possible values of a single field" is a `switch` statement [0]. Having said that, we now officially teach our new Redux Toolkit package as the default way to write Redux code [1], and its `createSlice` API [2] does actually use a lookup table approach instead. On a related note: my next task is rewriting that existing Redux "Basics/Advanced" tutorial to modernize it, and I'm currently taking notes on what I do and don't like about it [3]. If you've got any relevant feedback on things you don't like or ways to improve that tutorial sequence, please feel free to comment and let me know
Read the rest
In In Defense of a Switch
I certainly get where you're coming from, and agree that all of the questions you listed are things we didn't express opinions on previously and had to decide for yourself. Still, the bulk of the concerns I've seen over time fall into the categories I've listed - I just really don't remember seeing many comments from folks who were concerned that they "weren't using it effectively" as a particular pain point. Perhaps that was being felt, but expressed in different ways? (I definitely think a lot of people _haven't_ been using it effectively, but didn't necessarily realize it.) In any case, the highly positive response to RTK and the docs work tells me we're headed in the right direction. My next task is to rewrite the existing low-level "Basics/Advanced" tutorial sequence to remove outdated references, show simpler patterns, and improve
Read the rest
explanations. I've got my notes on things I want to change here: https://github.com/reduxjs/redux/issues/3855 If you or anyone else has any particular feedback on things you don't like with that existing tutorial or would like to see covered better, please comment and let me know!
In Why we decided against GraphQL for local state management
Hey, I wrote this! Neat to see that someone else submitted here. I spent a _lot_ of time and effort trying to put this together [0]. The existing tutorial sequence has been read by a lot of people over the years, but it takes a "bottom-up" approach: it teaches how each of the Redux pieces work in isolation, and builds up from there. That tutorial is also one of the oldest parts of our docs, and it was written in a much different era for a different audience: when "Flux" was still a thing, and people were looking at migrating away from Backbone. This new "Redux Essentials" tutorial has several goals: - It takes a "top-down" approach, with a focus on "how to use Redux, the right way", rather than "how it works". - It teaches our latest recommended patterns and practices, like using our official Redux Toolkit package [1] for writing your
Read the rest
Redux logic, and using the React-Redux hooks API [2] instead of the earlier `connect` API. - It shows how to build a somewhat more realistic example app, and explains various Redux concepts and APIs as we add new features. - Improve explanations and make it more clear how Redux integrates into a typical React app, and how data flows through a Redux application. I'm hopeful that this new tutorial will make it easier for people to jump right into learning Redux and building something useful with it, and they can look more into "how does it work inside?" later. The new tutorial is part of my ongoing effort to rewrite most of the Redux docs [3]. I'd previously written the new "Redux Style Guide" docs page [4], which lists our recommended best practices. My next task is to rewrite the existing "Basics/Advanced" tutorial sequence [5]. My plans for that section are: - Drop all outdated references ("Flux", "containers", etc) - Show simpler patterns (inline action types like `{type: "todos/addTodo"}` vs `const ADD_TODO = "ADD_TODO"`, single-file Redux logic) - CodeSandbox examples - Show React-Redux hooks - Improve explanation flow If anyone's got any feedback, suggestions, or questions, let me know! [0] https://github.com/reduxjs/redux/pull/3740#issuecomment-6508... [1] https://redux-toolkit.js.org [2] https://react-redux.js.org/api/hooks [3] https://github.com/reduxjs/redux/issues/3592 [4] https://redux.js.org/style-guide/style-guide [5] https://github.com/reduxjs/redux/issues/3595#issuecomment-55...
In Redux Overview and Concepts – Reimagined Redux Tutorial
> E.g. I couldn’t for the life of me annotate the return value of the pipe function Don't feel bad, no one can do that (yet! I think it should be possible with Variadic Tuple Types, coming in TS 4). There are a couple of attempts[1][2], but they all lack in some way. Redux does it with a boatload of overloads [3]. 1: https://dev.to/ascorbic/creating-a-typed-compose-function-in... 2: https://stackoverflow.com/a/53066700/1586229 3: https://github.com/reduxjs/redux/blob/686d29b5d4e2dcb6709c16...
In Svelte and TypeScript
I find it interesting the blog post mentioned Kent Dodds article recommending everyone rewrite fetch. I just argued adamantly against Redux docs about writing tests being switched off of Enzyme to his library because it’s “more trendy”. https://github.com/reduxjs/redux/pull/3708 Unfortunately, the community overruled me and the docs no longer show how to test Redux apps with enzyme. It only shows Kent’s “react testing library”. The library authors are complicit in this. Rather than showing the pros and cons of both, the trends are being pushed, leading people to falsely believe they must rewrite their whole code base in my experience. The troubling part for me is often those creating these trends may be working on a very different type of app. When you’re writing something complicated, and the ecosystem is dominated by patterns (also prea
Read the rest
ched by Kent) that work best in simpler apps like “only write integration tests” it can be frustrating. If Kent thought enzyme promoted anti patterns he could have technically made a docs PR or just written a thin layer on top of enzyme. Now we have yet another divisive issue. Getting him early access to new react apis and officially recommending RTL in the react docs (while he sells his training videos) make it sit worse with me. It doesn’t feel like the trends are always based on the merits, it feels more like “not invented here” and “nepotism” driving some of these trends for sure.
In Do Not Follow JavaScript Trends
I'm a Redux maintainer. As I said over on Reddit when this was posted: The biggest issue is that it goes directly against the principles I listed in the Redux Style Guide [0], particularly: - put as much logic as possible in reducers [1] - reducers should own the state shape [2] - model actions as "events", not "setters" [3] Also, Dan pointed out early on in Redux's development that "cursor"-style approaches to state updates are not how he intended people to use Redux [4]. Will it run? Sure. Is it something I'd actually recommend? Definitely not, and especially given the existence of our official Redux Toolkit package [5] and the React-Redux hooks API [6]. [0] https://redux.js.org/style-guide/style-guide [1] https://redux.js.org/style-guide/style-guide#put-as-much-log... [2] https://redux.js.org/style-guide/style-guide#reducers-should...
Read the rest
In Show HN: Redux with a UseState Hook
Note that our new official Redux Toolkit package [0] simplifies most Redux use cases and logic, including eliminating the need to write action creators and action types by hand and allowing "mutating" immutable update logic in reducers. The React-Redux hooks API [1] is also generally simpler to use than `connect`. We're now recommending that people use RTK as the default approach for Redux apps [2], and I'm working on a new set of tutorials that will teach RTK and React-Redux hooks as the standard approach [3]. [0] https://redux-toolkit.js.org [1] https://react-redux.js.org/api/hooks [2] https://redux.js.org/style-guide/style-guide#use-redux-toolk... [3] https://github.com/reduxjs/redux/pull/3740
In A Critique of React Hooks Addendum
Oh hey, that's my post. I first wrote it back in 2018, and just updated it yesterday with some additional links and comparisons. (Actually was considering retitling it after getting some feedback last night, but given that the link just got submitted here, I'll leave it as-is for now.) A few quick notes: - If you haven't looked at Redux in a while, please try out our official Redux Toolkit package [0], which is now our recommended approach for writing Redux logic, and the React-Redux hooks API [1]. We're going to be teaching both of those as the default approach for using Redux going forward. - We have a new "Style Guide" docs page that gives our official guidance on suggested usage patterns [2] - On that note, I'm working on an ongoing major rewrite of the Redux core docs [3]. My current task is creating a new "Quick Start" tutorial, w
Read the rest
hich will be a "top-down" intro to using Redux to stand alongside the existing "bottom-up" tutorial sequence. The goal of the Quick Start section is to quickly introduce Redux concepts, and show RTK and hooks as the "right way to write Redux code", without going into the details of how it works under the hood, so that folks can get started now and learn the underlying aspects later. I've an early partial WIP draft PR up [4], and hope to finish the first draft in the next few days. Once the Quick Start page is done, I'll be turning my attention to rewriting the main tutorial sequence in order to remove outdated terms, clarify explanations, and teach simpler patterns (like using "ducks" files instead of splitting code across multiple files). If anyone's got questions on anything I wrote in the article or otherwise Redux-related, ask away! [0] https://redux-toolkit.js.org [1] https://react-redux.js.org/api/hooks [2] https://redux.js.org/style-guide/style-guide [3] https://github.com/reduxjs/redux/issues/3592 [4] https://github.com/reduxjs/redux/pull/3740
In Redux – Not Dead Yet (2018)
I'm not sure what you mean by "it's not Redux". It's still 100% Redux. You create reducers, add them to a store, dispatch actions, and read that data in your components. None of that has changed. You're just writing less code to do it. What RTK does is eliminate the "incidental complexity" that came along with the original Redux usage patterns: writing action types and action creators by hand, writing complex nested immutable update logic by hand, making a mistake in that immutable update logic and causing accidental mutations, etc [0]. I do understand the suggestion to "replace the Redux core with RTK", and I take it as a great compliment that people suggest that. However, it can't happen, because a lot of people are already using Redux with their own customizations and abstractions. Changing the Redux core to suddenly include a bun
Read the rest
ch of other dependencies would not be what they want. The other aspect is that the Redux core was designed from the beginning to be unopinionated, while RTK is _deliberately_ opinionated. Not all Redux users want RTK's opinions. As it is, we've had folks who didn't like the fact that RTK _is_ opinionated and requires use of Immer in our `createReducer` and `createSlice` APIs. We had a long discussion issue about whether it made sense to add things like this to the Redux core (which was actually part of what prompted us to create RTK in the first place) [1]. FWIW, we explicitly recommend RTK as the standard way to write Redux logic [2], and now that Redux Toolkit 1.3 is out with some new APIs [3], my next task is to create a new "Quick Start" tutorial page for the Redux core docs [4] that does actually teach Redux using RTK as the default syntax, ie, "this _is_ how you write Redux code", in the same way that the Apollo docs teach Apollo-Boost as the default way to use Apollo. [0] https://blog.isquaredsoftware.com/2019/10/redux-starter-kit-... [1] https://github.com/reduxjs/redux/issues/3321 [2] https://redux.js.org/style-guide/style-guide#use-redux-toolk... [3] https://github.com/reduxjs/redux-toolkit/releases/tag/v1.3.0 [4] https://github.com/reduxjs/redux/issues/3674
In How I became a better programmer (2017)
Yeah, that's actually something I'm planning to add to the Redux docs shortly - a "Quick Start" tutorial page that shows things in a "top-down/how-to" approach (specifically using our new Redux Toolkit package [0] and the React-Redux hooks API [1]), vs the existing tutorial that teaches concepts "bottom-up". I started an initial attempt to write that page [2], wasn't happy with where it was going, and stepped back to do some analysis on other docs sites first so I could nail down how i want to tackle explaining things. I'm hoping to try writing that again after I get this next version of Redux Toolkit out the door. [0] https://redux-toolkit.js.org [1] https://react-redux.js.org/api/hooks [2] https://github.com/reduxjs/redux/pull/3675
In Socratic vs. Euclidean Forms of API Documentation
One of the best articles I've seen on writing documentation is "What Nobody Tells You About Documentation" [0]. It divides docs into four categories: Tutorials, How-To Guides, Discussions, and References. I'm currently working on a major rewrite of the Redux core docs [1], and I've been taking notes on that post and various other docs writing resources [2] so I can apply them to the rewrite. [0] https://www.divio.com/blog/documentation/ [1] https://github.com/reduxjs/redux/issues/3592 [2] https://github.com/reduxjs/redux/issues/3609
In Socratic vs. Euclidean Forms of API Documentation

Showing the 15 most recent of 23 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.