Open-source alternatives to RxJava

This project is a sample library and implementation guide for using RxJava to manage asynchronous data streams and concurrent tasks in Android applications. It provides a collection of reference implementations for reactive programming, focusing on functional operators to transform and combine asynchronous data flows. The library demonstrates specific Android architectural patterns, such as implementing decoupled event buses for component communication and coordinating parallel network requests. It includes concrete examples of mobile-specific patterns including search input debouncing, list

The .NET Reactive Extensions Library is a framework for composing, querying, and transforming asynchronous data streams. It provides a non-blocking implementation of the observer pattern to manage notifications and data flows between producers and consumers, functioning as an event stream processing library. The project applies LINQ-style querying and filtering operators to asynchronous sequences. This allows for the handling of event-driven programming patterns by utilizing composable operators to process notifications as they occur. The library covers asynchronous data streaming and non-bl

ReactiveCocoa is a functional reactive programming framework and Cocoa UI binding layer. It provides a library for composing asynchronous data streams and managing application state through signals and functional operators. The framework functions as an Objective-C data binding library that links object properties and method calls to reactive streams using runtime dynamism and swizzling. It includes a utility to convert traditional key-value observation notifications into composable streams for synchronized state tracking. The project covers reactive UI programming by connecting interface el

Bacon.js is a JavaScript functional reactive programming library used for coordinating complex asynchronous data flows. It functions as an observable event stream framework and an asynchronous data flow orchestrator, allowing developers to model events as declarative streams and properties. The library distinguishes itself through its ability to manage reactive state and synchronize timing across multiple sources. It provides specialized mechanisms for atomic state synchronization to prevent glitches in derived properties and offers advanced coordination strategies such as asynchronous stream

Kotlinx.coroutines is a library for managing non-blocking background tasks and structured concurrency within the Kotlin programming language. It provides a framework for executing concurrent operations and synchronizing shared state, replacing traditional thread management and complex callback chains with lightweight primitives. The library utilizes a structured concurrency hierarchy to organize hierarchical background tasks, ensuring that lifecycle management, cancellation, and timeout handling propagate automatically to prevent resource leaks. It employs continuation-passing style transform

RxJS is a library for reactive programming that provides a framework for composing asynchronous and event-based programs. It utilizes observable sequences to model data flows, allowing developers to manage complex sequences of events through a declarative programming interface. The library implements the observer pattern to facilitate decoupled communication between data producers and subscribers. By employing a lazy execution model, streams remain dormant until a consumer explicitly subscribes, at which point data production is triggered. This approach enables the construction of predictable

This project provides a formal specification and a set of standard Java interfaces for asynchronous stream processing. It defines a standardized protocol for passing sequences of elements between publishers and subscribers across different threads, centering on a reactive streams specification for the JVM. The project focuses on interoperability by providing a common API that allows different asynchronous streaming libraries to work together. This is achieved through a standard set of interfaces and bridging mechanisms that translate between incompatible streaming specifications. The specifi

RxBinding is an Android UI binding library that transforms standard view listeners into RxJava observables. It serves as a bridge and reactive wrapper, converting user interactions and widget states into reactive data flows. The project enables the implementation of reactive programming patterns across Android system interactions. By treating UI interactions as data streams, it allows for the asynchronous handling of events to decouple the view layer from business logic. The library covers the conversion of UI events into streams, the management of widget states to trigger application update

Vector is a high-performance observability data pipeline designed to collect, transform, and route logs, metrics, and traces across distributed infrastructure. It functions as a modular engine that decouples data ingestion from processing and transmission, utilizing a component-based architecture to connect diverse sources to multiple destinations. The project distinguishes itself through a focus on reliability and flow control. It implements backpressure-aware data movement to prevent data loss during traffic spikes and utilizes disk-backed event buffering to ensure durability during network

Bolts-Swift is a concurrency control framework designed to manage asynchronous workflows in native mobile applications. It provides a collection of primitives that allow developers to orchestrate background operations through a promise-based model, replacing deeply nested callback structures with chainable task sequences. The library distinguishes itself by offering granular control over task lifecycles and execution environments. It enables developers to define custom executors for specific threading contexts and provides mechanisms to manually signal the completion, error, or cancellation o

Rayon is a data parallelism library for Rust that provides a framework for converting sequential computations into parallel operations. It enables the transformation of standard data structures and loops into parallel iterators, allowing workloads to be distributed across multiple processor cores. By utilizing a work-stealing scheduler, the library dynamically balances tasks to maximize throughput and minimize execution time. The library distinguishes itself through its focus on safe, scoped task synchronization, which ensures that all spawned operations complete before a scope exits to preve

CAP is a .NET distributed transaction framework and event bus designed to manage asynchronous communication in microservices. It implements the outbox pattern to ensure eventual consistency and reliable message delivery by persisting messages in local database tables until transactions commit. The framework includes a distributed message monitor and web dashboard for tracking the status of sent and received messages. It provides tools for event traffic visualization, distributed request tracing, and the ability to manually trigger retries for failed delivery attempts. The system supports var

NATS Server is a high-performance, lightweight messaging system designed for cloud-native applications, edge computing, and distributed microservices. It functions as a distributed publish-subscribe broker that routes messages using hierarchical, dot-separated subject strings, enabling decoupled communication between services without requiring centralized broker lookups. The system supports core messaging patterns including asynchronous publish-subscribe, request-reply, and load-balanced queue processing. The platform distinguishes itself through a decentralized architecture that eliminates t

android-gif-drawable is a rendering library for displaying and controlling animated GIF images within Android image views and drawables. It provides a custom drawable implementation for frame-based animations, a playback system for seeking and looping, and a metadata extractor for retrieving technical properties such as frame counts and loop settings. The library enables the synchronization of a single animation instance across multiple views to ensure consistent playback. It supports loading GIF data from various sources, including assets, resources, URIs, byte arrays, files, and input strea

cloc is a codebase metrics tool and multi-language code analyzer designed to count blank lines, comment lines, and physical lines of code. It serves as a source code line counter and report generator that identifies file types to calculate source volume across a wide variety of programming languages. The tool distinguishes itself by providing codebase version comparison to measure relative changes in source and comment lines between two versions of a directory or archive. It also supports the definition of custom languages and the extension of language recognition by loading custom comment fi

Picasso is an Android image loading library designed for downloading, caching, and displaying images in applications. It provides an automated system for memory and disk management to reduce network requests and improve load times. The library includes a bitmap transformation tool for resizing, cropping, and modifying assets before they are rendered. It also functions as a bridge for Jetpack Compose, converting image requests into painter objects for use within declarative Android user interfaces. The system manages image retrieval from multiple sources, including web URLs, local files, and

Wire is a cross-platform code generator and implementation of gRPC and Protocol Buffers. It transforms schema definitions into type-safe native language bindings for Kotlin, Swift, and Java to ensure consistent data exchange and communication between distributed systems. The project provides specialized tools for protocol buffer schema management, including the ability to prune unused types and filter fields by version to reduce final binary sizes. It also handles namespace management and allows for the creation of custom schema handlers to execute user-defined logic during the compilation ph

RxAndroid is a reactive programming library and binding layer that integrates RxJava with the Android runtime environment. It provides a framework for composing asynchronous data streams and managing event-driven workflows specifically tailored for Android's threading requirements. The library functions as an Android thread scheduler, routing reactive operations to the main UI thread or specific Android loopers. This ensures that asynchronous task outcomes are dispatched to the primary interface thread for safe updates of visual components while preventing background processing from blocking

Gson is a Java library designed for the serialization and deserialization of objects into structured text formats. It functions as a reflection-based data mapper, inspecting class structures at runtime to automatically convert memory-resident objects into data representations and reconstruct them back into typed language objects. The library distinguishes itself through a modular type-adapter pattern that allows for custom conversion rules for complex or nested structures. It also provides robust support for production environments by generating build-time metadata and configuration rules, wh

Dagger is a compile-time dependency injection framework for Java and Android that automates object creation and lifecycle management. It functions as a static dependency injector and graph validator, resolving object requirements during the build process to avoid runtime reflection and prevent crashes caused by missing bindings. The framework distinguishes itself by using static analysis and code generation to produce factory classes at build time. It employs qualifier-based type differentiation to manage multiple implementations of the same type and provides scope-based lifecycle management

Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated memory compartments, enforcing security policies that prevent unauthorized access to system resources. The project distinguis

Apache Flink is a distributed processing engine designed for both high-throughput, low-latency data streams and finite batch workloads. It functions as a stateful stream processor and a SQL stream processing engine, providing a unified runtime to execute relational queries and event-based transformations. The system is distinguished by its ability to manage persistent operator state to ensure exactly-once processing guarantees and consistency during failures. It features specialized capabilities for complex event processing to detect temporal patterns and handles out-of-order events using eve

RxGo is a functional reactive programming library and an implementation of ReactiveX for the Go language. It serves as an asynchronous stream processing toolkit designed to coordinate event-based programs and data flows using the observable pattern. The library enables the construction of asynchronous processing pipelines that transform, filter, and combine event sequences. It distinguishes itself through the use of functional operators to compose these pipelines and provides mechanisms for managing concurrent execution. The toolkit covers a broad range of stream orchestration capabilities,

Deepagents is an LLM agent orchestration platform and stateful application server designed for deploying and managing AI agents built with computational graphs. It provides a containerized runtime environment that handles agent execution, state persistence, and the versioning of AI assistants. The platform distinguishes itself through deep integration with the Model Context Protocol, allowing agents to function as servers that expose tools and capabilities to external clients. It features a sophisticated observability suite for capturing execution traces, performing LLM-based evaluations agai

Lodash is a JavaScript utility library and data manipulation toolkit. It provides a collection of modular functions for transforming, filtering, and validating arrays, objects, strings, and numbers. The project functions as a functional programming toolkit, offering capabilities for function composition, currying, and lazy evaluation. It includes mechanisms for execution control, such as debouncing and throttling, to manage the timing and frequency of function invocations. The library covers a broad surface of data operations, including deep cloning and merging of complex nested structures,

Ramda is a functional JavaScript standard library and toolset for immutable data transformation and composition. It provides a comprehensive suite of pure utility functions designed to enable declarative data processing pipelines. The library is distinguished by its use of automatic function currying and a data-last argument order. These design patterns allow multi-argument functions to be partially applied, simplifying the construction of processing chains where data is passed through a sequence of operations. The toolkit covers broad data manipulation capabilities, including list processin

This project is a Go shell scripting library and framework designed for writing automation scripts and CLI tools. It provides a concurrent data pipeline system for chaining sources, filters, and sinks to process text and JSON streams. The library distinguishes itself through a comprehensive toolkit for shell-like operations, including a text processing engine for regular expression filtering and frequency analysis, a filesystem utility toolkit for recursive search and path manipulation, and an integrated HTTP client wrapper for building data pipelines that fetch web content. The capability s