Redux Observable

It helps you write applications that behave consistently, run in different environments (client, server, and native), and are easy to test. t provides a great experience, such as live code editing combined with a time traveling debugger.

RxJS is a library for reactive programming using Observables, to make it easier to compose asynchronous or callback-based code. This project is a rewrite of Reactive-Extensions/RxJS with better performance, better modularity, better debuggable call stacks, while staying mostly backwards compatible, with some breaking changes that reduce the API surface.

Vuex is a state management pattern + library for Vue.js applications. It serves as a centralized store for all the components in an application, with rules ensuring that the state can only be mutated in a predictable fashion. It also integrates with Vue's official devtools extension to provide advanced features such as zero-config time-travel debugging and state snapshot export / import.

Akka is a toolkit and runtime for building highly concurrent, distributed, and resilient message-driven applications on the JVM.

Redux Thunk middleware allows you to write action creators that return a function instead of an action. The thunk can be used to delay the dispatch of an action, or to dispatch only if a certain condition is met. The inner function receives the store methods dispatch and getState as parameters.

MobX is a battle tested library that makes state management simple and scalable by transparently applying functional reactive programming (TFRP). React and MobX together are a powerful combination. React renders the application state by providing mechanisms to translate it into a tree of renderable components. MobX provides the mechanism to store and update the application state that React then uses.

An alternative side effect model for Redux apps

Simple “selector” library for Redux (and others) inspired by getters in NuclearJS, subscriptions in re-frame and this proposal from speedskater.

Small, fast and scaleable bearbones state-management solution. Has a comfy api based on hooks, that isn't boilerplatey or opinionated, but still just enough to be explicit and flux-like.

Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. It greatly simplifies and streamlines network programming such as TCP and UDP socket server.

It is an open source library providing an asynchronous, event driven platform for building fast, reliable, and lightweight network applications. It leverages Rust's ownership and concurrency model to ensure thread safety.

It is an experimental state management library for React apps. It provides several capabilities that are difficult to achieve with React alone, while being compatible with the newest features of React.

It is a library for creating, interpreting, and executing finite state machines and statecharts. It's a really powerful package that can be used to manage state in React Apps.

Finagle is an extensible RPC system for the JVM, used to construct high-concurrency servers. Finagle implements uniform client and server APIs for several protocols, and is designed for high performance and concurrency.

It takes an atomic approach to global React state management. Build state by combining atoms and renders are automatically optimized based on atom dependency. This solves the extra re-render issue of React context, eliminates the need for memoization, and provides a similar developer experience to signals while maintaining a declarative programming model.

Orleans is a framework that provides a straightforward approach to building distributed high-scale computing applications, without the need to learn and apply complex concurrency or other scaling patterns. It was created by Microsoft Research and designed for use in the cloud.

It is full-featured reactive state management without the boilerplate. Technically speaking, mobx-state-tree (also known as MST) is a state container system built on MobX, a functional reactive state library.

It provides reactive state management for Angular apps inspired by Redux. Unify the events in your application and derive state using RxJS.

It is an effective multi-store state manager for Javascript apps, that allows you to manage data in complex applications.

It is a type-safe composable asynchronous and concurrent programming library for Scala that is based on pure functional programming.

State so simple, it goes without saying

Originally inspired by the now seemingly abandoned library - bey. Although substantially different now - with Server-side rendering and Async Actions built in.

Convex is a Backend Application Platform that keeps you focused on building your product. Convex Functions, Realtime Database, File Storage, Job Scheduling, Text Search, Vector Search, and much more, as one cohesive product.

It is a Next generation Actor Model framework. It introduces "Actor Standard Protocol", a predefined contract of base primitives which can be consumed by different language implementations. This is a game changer in the field of actor systems, you are now free to pick and choose languages for your different actor based microservices in a way never seen before.

It is a lightweight solution to state management that takes advantage of hooks. You can write local state using React Hooks and lift it up to React Context only when needed with minimum effort.

RxJS and ImmutableJs powered nested state management for Angular 2+ applications inspired by @ngrx/store. It is simple, fast, reliable with no boilerplate.

It is a tiny, reactive JavaScript library for structured state and tabular data. Tiny by name, tiny by nature, it only costs 3.0kB - 6.0kB when compressed, and has zero dependencies.

redux-dynamic-modules is a library that aims to make Redux Reducers and middleware easy to modular-ize and add/remove dynamically.

It is a javascript library that combines the new ESNEXT javascript language with Functional Programming and old principles of front-end development, such as Separation of concerns, Progressive Enhancement, Single Responsibility Principle, and Functional Oriented.

Scramjet is a fast, simple, free and open source functional reactive stream programming framework written on top of node.js streams with multi-threadding support. The code is written by chaining functions that transform data easily with ES7 async/await syntax. It is built upon the logic behind three well known javascript array operations: map, filter and reduce. Scramjet transforms are so standard and natural that we're sure you can start writing your code straight away.

It is your toolbelt for structured concurrency in go, making common tasks easier and safer. It handles panics gracefully and makes concurrent code easier to read.

It is an open-source concurrency/parallelism library for Java and Groovy that gives you a number of high-level abstractions to write good logic.

It is RxJS and ImmutableJs powered nested state management for React applications inspired by @ngrx/store. It is simple, fast, reliable and no boilerplate.

It is a modern alternative to Redux, Mobx, Formik without boilerplate. It is simple to learn but very flexible to use. It has got impressive performance and predictable behavior.

It is a library to load and manage data inline in React components that work on both client and server.

Automatically completes the merge process from the small Reducers to the main Reducer by explicitly expressing the dependencies between components.

It manages synchronous and asynchronous code easily, using nothing more than standard JavaScript and Node-like Streams. You may be familiar with Promises, EventEmitters and callbacks, but moving between them is far from seamless.