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, 1:56:48 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

20 sources
Hi, I'm a Redux maintainer. There's been a lot of reasons for a shift in opinions over the last few years: - Redux is well past the initial burst of enthusiasm in the "hype cycle" - As you mentioned, there are a number of common concerns expressed by a lot of folks, most of which revolve around "boilerplate" - There are now a wider variety of other options that overlap with ways you'd use Redux: React's Context and Hooks APIs, MobX, GraphQL / Apollo Client, etc. These don't completely replace Redux, but they do overlap enough that there's not as much _need_ to choose Redux for everything. - And, frankly, Redux _has_ been overused in a number of cases. Folks assume you _have_ to use Redux with React, sometimes because a senior dev told them so, because they saw yet another tutorial that pairs them together, or because it was asked for in
Read the rest
a job listing. Now, Redux is definitely not dead or dying. My own estimates are that around 50% of React apps are using Redux, and the overall total download trends are still increasing. But, it's also true that the market share will continue to spread out a bit over time. I talked about these aspects in my Reactathon 2019 talk on "The State of Redux" [0] and my post "Redux - Not Dead Yet!" [1]. Besides all that, we're doing a lot of work to make it easier for folks to learn and use Redux. - We have a new official Redux Toolkit package [2] [3]. It includes utilities to simplify several common Redux use cases, including store setup, defining reducers, immutable update logic, and even creating entire "slices" of state at once. It's now our recommended approach for writing Redux logic, and the feedback from folks who have adopted it has been amazingly positive. - We are currently working on a major rewrite of the Redux core docs [4]. As part of that, we've already added a new "Style Guide" page [5] with our recommended best practices and guidelines for writing good Redux code, like structuring files as "feature folders" or "ducks", modeling actions as "events" instead of "setters", and so on. We're also going to completely redo all the tutorials and examples to show easier patterns to work with, drop outdated references to concepts and terms like "Flux" and "container components", and emphasize use of Redux Toolkit as the standard way to write Redux apps. - Our new React-Redux hooks API [6] makes it a lot easier to work with Redux data in React components compared to the standard `connect` API, especially if you're using TypeScript. So yeah, there are some repeated waves of annoyance with Redux that pop up on social media every so often, but there's also a ton of folks still using and learning Redux. My goal is to continue to make it easier for Redux users of all levels to use Redux. [0] https://blog.isquaredsoftware.com/2019/03/presentation-state... [1] https://blog.isquaredsoftware.com/2018/03/redux-not-dead-yet... [2] https://redux-toolkit.js.org [3] https://blog.isquaredsoftware.com/2019/10/redux-starter-kit-... [4] https://github.com/reduxjs/redux/issues/3592 [5] https://redux.js.org/style-guide/style-guide [6] https://react-redux.js.org/api/hooks
In State of JavaScript 2019
This reminds me of this commit in Redux: https://github.com/reduxjs/redux/commit/9276ff0af6400633d673.... "Simple" is always a relative term. I agree, if "simple" looks like the complication in the post, then I'm turned off from the language because I don't really want to see what "complex" can become. I have no doubt if I had context of Haskell, I would be able to read that with no trouble - even without Haskell context I think I can grok it pretty well. But imagine a newbie to the industry as a whole? It stops being simple at various stages, very quickly.
In A Dead-Simple Web Stack in Haskell
FWIW, we have a new official addon package called Redux Starter Kit [0]. It includes utilities to simplify several common Redux use cases, including store setup, defining reducers, immutable update logic, and even creating entire "slices" of state at once without writing any action creators or action types by hand. We're starting on a major rewrite of the Redux core docs [1], and as part of that we'll be encouraging folks to use RSK as the default way to write Redux code. (Note that we're also discussing possibly renaming RSK [2] to avoid confusion over the word "Starter" - a lot of folks are mistaking this to mean that it's only good for beginners or that it's some kind of project CLI tool.) [0] https://redux-starter-kit.js.org [1] https://github.com/reduxjs/redux/issues/3592 [2] https://github.com/reduxjs/redux-starter-kit/issues/246
In Static Types in SwiftUI
Hi, folks. I'm a Redux maintainer. Wanted to let everyone know about the two major things we're working on at this point. First, we have a new official package called Redux Starter Kit [0], which is our recommended toolset for writing Redux apps with less boilerplate. It includes utilities to simplify several common Redux use cases, including store setup, defining reducers, immutable update logic, and even creating entire "slices" of state at once without writing _any_ action creators or action types by hand. RSK is useful for both folks who are new to Redux and experienced users, and can be used day 1 in a new project or incrementally added to an existing project. I'd strongly encourage anyone who's using Redux to try it out. In particular, I'd suggest reading through the "Advanced Tutorial" page [1], which demonstrates how to use R
Read the rest
SK with TypeScript, thunks for async data fetching, and our new React-Redux hooks API. You might also want to read through the issue comment that lays out my "Vision for Redux Starter Kit" and the problems it's meant to solve [2] I just published RSK v0.8 this evening [3] which has a couple small breaking changes (primarily renaming a `slice` field to `name` and making it required). After that, I'm hoping to nail down a couple last bits of configuration, and then push it to 1.0 within the next week or two. After that, we're going to start working on a major revamp of the Redux core docs. You can see my planned outline here [4]. The goals for the docs revamp include: - Updating the tutorials, including removing outdated concepts like references to "Flux", distracting mentions of terms or warnings that beginners don't need to worry about, adding diagrams, and finding ways to improve the explanations (like changing the "Middleware" page to explain how to _use_ middleware, rather than why they work this way). We will also add a tutorial section that shows how to use Redux Starter Kit, and recommend that people use it as the "default way to use Redux". - Adding a "Real World Usage" docs section. This would include topics like choosing async middleware, debugging, folder structures, performance, and so on. - Adding a "Style Guide" page. The Redux docs are deliberately unopinionated about things like folder structures, async middleware, structuring actions and reducers, and so on. However, we'd like to provide some official guidance on our current recommended best practices. The Vue docs have a great page with their recommendations, why they recommend certain patterns, and how strongly they recommend them, and we'd like to do the same thing here. For example, we'd recommend using a "feature folder" or "ducks" pattern for structuring files, treating actions as "events" instead of "setters", and trying to put as much logic as possible in reducers. - Adding a "Thinking in Redux" section. This would include concepts like mentally modeling actions, the history of Redux and its inspirations, how it's meant to be used, and why it works the way it does. I'd love to have additional help from the community in working on this docs revamp - I certainly can't do it all myself :) Finally, I'd encourage folks to watch my Reactathon 2019 talk on "The State of Redux" [5], where I talked about Redux's market share and how it compares to other tools, as well as future directions for the library. In addition, my post "Redux - Not Dead Yet!" [6] addresses some common questions about how things like hooks and GraphQL relate to Redux. If anyone's got questions, feel free to ask! [0] https://redux-starter-kit.js.org [1] https://redux-starter-kit.js.org/tutorials/advanced-tutorial [2] https://github.com/reduxjs/redux-starter-kit/issues/82#issue... [3] https://github.com/reduxjs/redux-starter-kit/releases/tag/v0... [4] https://github.com/reduxjs/redux/issues/3313#issuecomment-45... [5] https://blog.isquaredsoftware.com/2019/03/presentation-state... [6] https://blog.isquaredsoftware.com/2018/03/redux-not-dead-yet...
In I created the same app with React and Redux
Hi, I'm a Redux maintainer. FWIW, there's apparently a ton of ways to handle typing Redux with TS (and that's even reflected in the discussion for the PR that added that page [0]). A large part of it seems to revolve around whether or not you're trying to apply action types to `dispatch` to limit what actions can be dispatched. I'm comfortable with TS at a general level (declaring interfaces for API types, reducers, and React component props), but a lot of folks seem to go crazy trying to get 100% type coverage. I personally aim for more of an "80%" sweet spot for typing - trying to trade off overall benefit with not trying to tie myself in knots adding ridiculous type declarations. I actually just wrote a tutorial page for Redux Starter Kit that shows how to use it with TS and `useDispatch` [1], but had someone point out that one of t
Read the rest
In TypeScript vs. ReasonML
> I'd like to see that presentation. Got a link to the slides? If you're willing to wait a week, I could share. I'm really not ready to share it as is (still working on the code). > Could you leave a comment at https://github.com/reduxjs/redux/issues/3313 with some notes on how the current docs examples are too verbose? Yes, I could do that, but again I'll need at least a couple of days. It's a crazy week for me. If you want a _quick_ example, here's one from the 'actions' section of the basic tutorial: ------ function addTodo(text) { return { type: ADD_TODO, text } } ------ I would advocate writing this as: const addTodo = (payload) => ({ type: ADD_TODO, payload, }); ------- 4 lines instead of 6, just as readable to me. And frankly, I'd consider doing that as a 1-liner since there's only two attribut
Read the rest
es in the action anyway. Where I work, we have a semi-official rule of 'newlines for attributes if there are more than 3, or if the line length > 80', so our policy would write this action creator as a single line. export const addTodo = payload => ({ type: ADD_TODO, payload });
In XSM: State management for Angular, React, and Vue
I know that popular opinion in the Twitterverse is that "Redux is dead", but I note that both Twitter and Slack just released major rewrites that use Redux heavily. I talked about Redux usage stats and comparison with other alternatives in my "State of Redux" talk at Reactathon earlier this year [0], and my post "Redux - Not Dead Yet!" also addresses some of these aspects [1]. Also, quick plug for our current focus. I'm working on some tutorials for our new Redux Starter Kit package [2], and then will be working on tackling additional functionality to push it towards a 1.0 release [3]. After that, we'll get started on a major revamp of the Redux docs [4] to improve the learning flow, better organize the content, cover more real-world usage topics, and teach using Redux Starter Kit as the "default way to write Redux". [0] https://blog.isq
Read the rest
In When a rewrite isn’t: rebuilding Slack on the desktop
I'll pitch in with my own intuition; the easiest way to understand it is to view it as a call stack. Using this example function: function RecFunc(n, max) { let result; // intialize the return variable if (n < max) { result = RecFunc(n + 1, max) // the recursion } else { result = n; // the exit condition } return result; } RecFunc(0, 3); When you call the function, we descend down the stack until it hits the exit condition. Notice that `result` is undefined in the upper levels of the stack; when `n` is equal to `max`, the function is finally able to assign a value to `result` and exit: | RecFunc v n: 0, max: 3, result: undefined | RecFunc v n: 1, max: 3, result: undefined | RecFunc v n: 2, max: 3, result: undefined | RecFunc v n: 3, max: 3, result: 3 N
Read the rest
ow that the exit condition has been met, we go back up the stack, returning the result at each step: ^ RecFunc | n: 0, max: 3, result: 3 ^ RecFunc | n: 1, max: 3, result: 3 ^ RecFunc | n: 2, max: 3, result: 3 ^ RecFunc | n: 3, max: 3, result: 3 Notice how the call stack resembles stepping through a for-loop: var result = 0; for (var i=0; i++; i<=3) { result += 1; } If you really want to see a mind-blowing example of recursion, step through an implementation of the `compose`[0] function some time. :) [0] https://github.com/reduxjs/redux/blob/master/src/compose.js
In How to do hard things
Yep, this is absolutely the case. As an example, see the "Middleware" tutorial page in the Redux docs [0], which Dan wrote. It walks through the process of "how and why did we end up at the final middleware API?", by demonstrating several "failed" attempts at solving the problem of logging. The page itself is well-written, and definitely demonstrates Dan's standard teaching style. But, it's also true that it's not obvious from glancing at the page how to _use_ middleware, because that doesn't come until the "failed" attempts. Another good example is his "Redux tutorial" videos on Egghead [1], where he walks through basically building Redux as the process for teaching how to use it and how it works. For some people, that teaching style is great. For others, they just want to know _how_ to use something, not necessarily how it _works_ ri
Read the rest
ght now. (We're planning to revamp the Redux docs soon-ish [2], and I do plan to change the contents of that "Middleware" tutorial to be an actual explanation of how to _use_ middleware correctly, and then move the "why does it work this way?" explanation to a different section of the docs.) [0] https://redux.js.org/advanced/middleware [1] https://egghead.io/courses/getting-started-with-redux [2] https://github.com/reduxjs/redux/issues/3313
In Name It, and They Will Come
FWIW, I'm a Redux maintainer, and I built this specifically in response to how I've seen people _want_ to use Redux, and the concerns they've raised about using Redux. [0] Almost everyone uses `redux-thunk` [1]. Adding that to a plain Redux store takes a few steps. Adding middleware _and_ setting up the Redux DevTools Extension adds another couple steps [2] So, RSK's `configureStore()` does that by default [3]. Accidental mutation is the #1 mistake folks make when writing Redux apps [4]. So, `configureStore()` adds a middleware by default that warns about that mistake [5]. Writing immutable update logic can be difficult, and especially painful if the updates are nested [6]. Also, many folks don't want to use switch statements for some reason [7]. So, we ship a `createReducer()` utility that lets you write "mutative" immutable updates,
Read the rest
and define the reducers as a lookup table [8]. Many people don't like writing action types and action creators by hand. So, RSK includes a `createSlice` utility that generates those automatically. [9] None of these are incredibly ground-breaking. There's lots of existing Redux addons that do similar things. But, we're including all these utilities in an "official" package, and recommending that folks use it. No one's being forced to use RSK. But, I can say that just about everyone who's seen this has said something similar to "this looks awesome, I can't wait to use this!". [0] https://github.com/reduxjs/redux/issues/2295 [1] https://blog.isquaredsoftware.com/presentations/2017-09-migh... [2] https://redux.js.org/recipes/configuring-your-store#integrat... [3] https://redux-starter-kit.js.org/api/configureStore [4] https://redux.js.org/faq/react-redux#why-isnt-my-component-r... [5] https://redux-starter-kit.js.org/api/getDefaultMiddleware [6] https://redux.js.org/recipes/structuring-reducers/immutable-... [7] https://blog.isquaredsoftware.com/2017/05/idiomatic-redux-ta... [8] https://redux-starter-kit.js.org/api/createReducer [9] https://redux-starter-kit.js.org/api/createSlice
In Scheduling in React

Showing the 15 most recent of 20 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.