Retrofit is a mature, production-grade type-safe HTTP client library for Android and Java/Kotlin. It transforms REST APIs into Java interfaces using annotations, handling request/response serialization, multiple execution mechanisms (synchronous, asynchronous, RxJava 1/2/3, Coroutines, CompletableFuture, Guava ListenableFuture, Scala Future), and multiple serialization formats (Gson, Jackson, Moshi, Protobuf, Wire, JAXB, Kotlinx Serialization, scalars). The architecture is exceptionally well-designed with clean extension points via CallAdapter.Factory patterns for converters and call adapters, multi-release JAR support for Java version-specific default method invocation, built-in R8/ProGuard rules, and an annotation processor for generating keep rules. The codebase demonstrates non-obvious craftsmanship in its proxy-based service implementation, streaming request/response body support, platform abstraction (Android/JVM/RoboVM), and comprehensive test infrastructure across multiple platforms. Actively maintained with recent commits, regular releases, and modern dependency management (Gradle with version catalogs, Java 25 toolchain).
RxJava 4 is a reactive programming library for the JVM, implementing the Reactive Streams specification via `java.util.concurrent.Flow` (Publisher/Subscriber). It provides six core reactive types: `Flowable` (backpressured), `Observable` (unbounded), `Single` (single value), `Maybe` (optional value), `Completable` (completion signal), and the new `Streamable` (pull-based streaming with `CompletionStage`). The library offers a comprehensive set of operators (map, filter, flatMap, concat, merge, window, buffer, etc.) for composing asynchronous data flows, along with schedulers for threading control (`Schedulers.computation()`, `Schedulers.io()`, `Schedulers.virtual()` for virtual threads). It includes advanced features like operator fusion (`QueueFuseable`), backpressure strategies, and configurable operator parameters via immutable records. The architecture is modular: each operator is a final class extending the base reactive type with an inner observer/subscriber class managing state. External dependencies are minimal (only JDK standard library), and the library is designed for embedding in applications, frameworks, and Android. Key entry points are the static factory methods on `Flowable`, `Observable`, `Single`, `Maybe`, `Completable`, and `Streamable`. Data flows are constructed by chaining operators that transform and combine reactive streams, with lifecycle managed through `Disposable` and `Subscription` contracts.
Fuel is a Kotlin Multiplatform HTTP networking library built on kotlinx.coroutines, providing suspend-style HTTP verbs (GET, POST, PUT, PATCH, DELETE, HEAD, arbitrary methods) plus Server-Sent Events streaming across JVM, Apple (iOS/macOS), and WasmJS targets. The core fuel module uses an expect/actual split: a common HttpLoader interface and FuelBuilder are backed by OkHttp on JVM, NSURLSession on Apple, and the browser fetch API on WasmJS. A global Fuel object supports plugging in a custom loader or loader factory, and extension functions on String (httpGet(), httpPost(), etc.) provide concise request entry points. A FuelRouting interface lets applications model typed API endpoints as sealed classes. Four optional serialization modules — fuel-jackson-jvm, fuel-moshi-jvm, fuel-kotlinx-serialization, and fuel-forge-jvm — each add a small extension on HttpResponse (toJackson, toMoshi, toJson, toForge) that decodes the body and returns a Result from the companion Result library. The core response model is deliberately minimal: a mutable HttpResponse holding a status code, a kotlinx.io Source body stream, and headers. JVM request handling is semantically correct about HTTP (e.g., consulting OkHttp's HttpMethod.permitsRequestBody before attaching a body). The project is published as 3.0.0-alpha04, uses Kotlin 2.3 / Gradle 9.3 / OkHttp 5 alpha, and is actively maintained with CI, Renovate, Dependabot, and ktlint. JVM has solid unit coverage using MockWebServer for all verbs, routing, custom OkHttp configurations, and each serialization adapter. Apple and Wasm targets are implemented but largely untested outside manual samples, and the Apple SSE implementation is a naive full-body line splitter rather than true incremental streaming. Overall this is a clean, modern, well-organized library with a couple of genuinely reusable pieces (notably the Android-derived UriCodec port) and some pre-1.0 rough edges. This is a pure application/library repository, not a data project.
This is an Android application that serves as a learning resource for RxJava 2. It contains over 30 example activities demonstrating various RxJava operators (map, flatMap, zip, filter, take, skip, buffer, concat, merge, etc.), Subjects (Publish, Behavior, Replay, Async), and practical patterns like caching with multiple data sources, pagination with PublishProcessor, search with debounce/switchMap, an event bus (RxBus), and networking with AndroidNetworking. The code is written in Java and targets Android API 28 (Android 9). It uses old dependencies (Gradle 3.2.0, RxJava 2.2.2, AndroidX alpha versions) and the build system relies on the deprecated jcenter() repository. The architecture is straightforward: each example is a self-contained Activity that creates an Observable and logs results to a TextView. While the code is functional and educational, it is not production-grade and exhibits significant technical drift due to outdated libraries and practices.