RxJava is a Java Virtual Machine implementation of Reactive Extensions that enables developers to compose asynchronous and event-based programs using observable sequences. The library extends the observer pattern to support sequences of data and events, providing operators that allow declarative composition while abstracting away concerns about low-level threading, synchronization, thread-safety, and concurrent data structures.
The repository is currently at version 4.x, which represents a significant modernization effort. Version 4 is built as a native Java 26 implementation with plans to support Java 27 depending on timing and available features. A key advantage is that it requires no third-party libraries at runtime while maintaining JPMS and OSGi support. The implementation is based on java.util.concurrent.Flow, providing native support for the Reactive Streams specification. Version 4 introduces virtual thread support through methods like virtualCreate() and virtualTransform(), along with a new Schedulers.virtual() option. A new Streamable<T> type is under development, built around virtual threads and virtual blocking, conceptually similar to IAsyncEnumerable for Java.
RxJava provides five primary base classes for different use cases. Flowable handles 0 to N flows with full Reactive Streams support and backpressure capability. Observable also handles 0 to N flows but without backpressure support, making it suitable for short sequences and GUI interactions. Single represents exactly one item or an error. Completable represents a flow without items but with completion or error signals. Maybe represents either no items, exactly one item, or an error. The library uses a fluent API builder pattern where each method call returns a new immutable reactive type with added behavior.
The repository overlaps with contributors from github/gh-aw, solo-io/gloo, and longhorn/longhorn, indicating integration within a broader ecosystem.
Version 4 incorporates modern Java features including the Java Cleaner API for detecting resource leaks and adaptive cleanups. The implementation uses sealed interfaces to reduce Javadoc bloat in base types and record-based configurations to reduce overload complexity. Internal optimizations have been applied now that the primary maintainer has full control. Future possibilities include scoped variables for context and per-item resource management, inclusion of second and third-party operators, and potentially the Iterable Extensions library.
The library includes comprehensive scheduler support for managing concurrency. Standard schedulers include computation() for CPU-intensive work on dedicated threads, io() for blocking operations on dynamic thread pools, single() for sequential FIFO execution, and trampoline() for testing. Platform-specific schedulers are available for Android, Swing, and JavaFX. Developers can also wrap existing Executor instances into schedulers via Schedulers.from(Executor).
RxJava 3.x support will be phased down over the coming months with continued support for one year after the official 4.x release. Android compatibility depends on API level and available desugaring. The repository is actively addressing anomalies and bugs in operators such as groupBy, window, and concat.
