kittinunf/fuel

This release delivers a comprehensive multiplatform overhaul, introducing native HTTP loader implementations for Apple, JVM, and WebAssembly targets, alongside new Server-Sent Events support. The library's architecture has been significantly refactored to use a common \HttpLoader\ abstraction, replacing previous default client implementations and internal HTTP handling classes. Additionally, the project upgrades to Kotlin 2.0 and Gradle 9.3.1, while adding JSON deserialization extensions for Jackson, Moshi, and kotlinx-serialization, with corresponding test suite updates.

A new \toJson\ extension function is added to \HttpResponse\, allowing users to deserialize HTTP response bodies into typed Kotlin objects using kotlinx-serialization. The function accepts a \Json\ configuration and a \DeserializationStrategy\, returning a \Result\ wrapping the deserialized object or a \Throwable\.

fuel-kotlinx-serialization/src/commonMain · high confidence

New extension functions are added to convert HTTP responses into Kotlin objects using Jackson and Moshi. For Jackson, a \toJackson\ function parses the response body using a Jackson \ObjectMapper\. For Moshi, \toMoshi\ functions allow parsing the response into a specified class or type using a \JsonAdapter\. Both implementations leverage \kotlinx-io\ for reading the response source.

fuel-jackson-jvm/src/main, fuel-moshi-jvm/src/main · high confidence

A new Gradle plugin (publication.gradle.kts) has been added to the build system, enabling Maven repository publishing for JVM libraries. This includes configuration for Sonatype staging and snapshot repositories, automatic inclusion of Javadoc artifacts, and PGP signing of published artifacts using environment variables or local properties for credentials.

plugins/src · high confidence

A new sample application for the mockbin-native project has been introduced, demonstrating a native Kotlin HTTP client setup. The sample utilizes the Fuel library for network requests and Kotlinx-io for reading the response body, providing a concrete example of how to integrate these libraries in a native environment.

samples/mockbin-native · high confidence

The library now supports HTTP requests on Apple platforms (iOS, macOS, etc.) via a new \AppleHttpLoader\ implementation. This adds native support for standard HTTP methods (GET, POST, PUT, DELETE, HEAD, PATCH) and introduces Server-Sent Events (SSE) support on Apple platforms, allowing users to consume streaming responses using Kotlin Flows.

fuel/src/appleMain · high confidence

The library introduces a new \Fuel\ singleton object in the common module that serves as the primary entry point for HTTP methods (get, post, put, patch, delete, head, method, and sse). This object manages an \HttpLoader\ via a new \HttpLoaderFactory\ interface, allowing platform-specific implementations to be injected. The \Request\ class and its \Builder\ are now defined in common, supporting parameters, headers, and body. Additionally, extension functions on \String\ (e.g., \httpGet\, \httpPost\) are provided for convenience. The \HttpLoader\ interface and \HttpResponse\ class are also moved to common, standardizing the HTTP execution model across platforms.

fuel/src/commonMain · high confidence

The library now provides concrete HTTP loader implementations for the JVM and WebAssembly (Wasm) platforms. On the JVM, the new \JVMHttpLoader\ and \HttpUrlFetcher\ leverage OkHttp to execute requests, supporting standard HTTP methods and Server-Sent Events (SSE). For WebAssembly, \WasmHttpLoader\ and \HttpUrlFetcher\ implement the same interface using the browser's native \fetch\ API. This change introduces the underlying network execution layer for these platforms, enabling HTTP functionality on JVM and Wasm targets.

fuel/src/jvmMain · high confidence

The httpbin-wasm sample now runs in WebAssembly-enabled browsers. A new Kotlin entry point (Main.kt) and an HTML template (index.html) have been added to the wasmJsMain source set, enabling the sample to execute on the Wasm platform.

samples/httpbin-wasm · high confidence

The sample code demonstrating how to track download progress using OkHttp's interceptor and custom response body wrappers has been removed from the project.

fuel-samples/progress · high confidence

The \ResponseExtension\ logic has been moved from the shared \fuel-forge\ module to the \fuel-forge-jvm\ module. This change updates the \toForge\ function to accept a \fuel.HttpResponse\ and use \kotlinx.io\ for reading the response body, replacing the previous \okhttp3.Response\-based implementation.

fuel-forge-jvm/src/main · medium confidence

The Kotlin-based weather sample application, which demonstrated synchronous and asynchronous HTTP requests using the Moshi library for JSON parsing, has been removed from the repository. This eliminates the example code that previously showcased the library's capabilities for fetching and parsing weather data.

fuel-samples/weather · high confidence

The file ResponseExtension.kt, which provided convenience functions to convert HTTP responses into Moshi objects, has been removed. Users relying on these extension methods will need to handle Moshi serialization manually or use alternative conversion utilities.

fuel-moshi/src/main · high confidence

The build configuration no longer uses a centralized Kotlin object to define library versions and dependencies. This change removes the \Library.kt\ file from \buildSrc\, which previously managed versions for Kotlin, Coroutines, OkHttp, Forge, Serialization, Moshi, and JUnit. This aligns with the migration away from Gradle extra properties in favor of more explicit dependency management.

buildSrc · high confidence

The default HTTP client implementation has been removed from the \fuel-default\ module. This includes the \Fuel\ singleton object for configuring the default \HttpLoader\, the \Fuels\ object containing top-level extension functions for HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, and generic METHOD), and string extension functions for making requests. Users will no longer have access to these default convenience methods and must explicitly configure or provide their own HTTP loader implementation.

fuel-default · high confidence

The internal implementation classes for HTTP loading and request handling have been removed from the fuel-base module. Specifically, the \ContinuationCallback\, \Extensions\, \HttpException\, \HttpLoader\, \HttpLoaderBuilder\, \HttpLoaders\, \HttpUrlFetcher\, \RealHttpLoader\, and \Request\ classes are no longer present in the codebase. This change eliminates the previous internal architecture for handling HTTP requests and responses, likely as part of a broader refactoring or migration of the HTTP client implementation.

fuel-base/src/main · high confidence

The ResponseExtension.kt file, which provided a toJson() function to parse HTTP responses into kotlinx-serialization objects, has been removed. This eliminates the convenience method for converting response bodies into serialized types within the fuel-kotlinx-serialization module.

fuel-kotlinx-serialization/src/main · high confidence

The sample application demonstrating the synchronous blocking style interface has been removed. This change eliminates the dependency on Kotlin Coroutines for this specific example, aligning with the broader project shift to strip Coroutines from the core library.

fuel-samples/simple-client · high confidence

The project now targets Kotlin 2.0, requiring Java 8+ bytecode, and upgrades the Gradle wrapper from 8.10.2 to 9.3.1. The README has been updated to reflect the new Kotlin version and the new Maven Central artifact coordinates. Additionally, the repository has adopted Renovate for automated dependency updates and switched from the ktlint Gradle plugin to using super-linter, with corresponding changes to .editorconfig, .gitignore, and the removal of ktlint.gradle.kts.

(repo-wide) · high confidence

Add JVM tests for kotlinx-serialization integration; Added Apple-specific serialization tests; Added tests for Moshi JSON deserialization; Expanded test coverage for HTTP client and utility functions; Removed Kotlinx Serialization test suite; Removed obsolete HTTP loader tests; Removed obsolete Moshi test file; Updated Fuel-Forge JVM tests to use the new Result-based API.

The project has been restructured to use Gradle Version Catalogs for dependency management, centralizing all library versions (such as Kotlin 2.3.0, Jackson 2.21.1, and Moshi 1.15.2) in a single configuration file. This change introduces a new multiplatform build configuration for the core 'fuel' module, enabling support for JVM, iOS, macOS, and WasmJS targets. Additionally, the build system has been updated to target Java 1.8 for JVM modules and Java 17 for the plugins module, while removing legacy build scripts and properties.

(dependencies) · high confidence

The Gradle wrapper has been upgraded from version 6.3 to 9.3.1, which will cause the project to use the newer Gradle version for builds. Additionally, network timeout and distribution validation settings have been added to the wrapper configuration.

gradle · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 44 → 60 (+16.1)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 99 (+0.2)
• Architecture 94 → 100 (+5.9)
• Maturity 51 → 49 (-2.5)
• Readiness 33 → 60 (+27.4)
• Security 37 → 65 (+28.4)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (11 lines × 2) (fuel/src/appleMain/kotlin/fuel/AppleHttpLoader.kt)
• Duplicated block (11 lines × 2) (fuel/src/wasmJsMain/kotlin/fuel/WasmHttpLoader.kt)
• Duplicated block (14 lines × 2) (fuel/src/jvmMain/kotlin/fuel/JVMHttpLoader.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No artifact signing
• No exposed public API
• No tests found
• …and 1 more

• Ambiguous setter overloads. setHttpLoader accepts both a concrete instance and a factory. While technically distinct signatures, it is unclear if the factory is invoked immediately or stored for later use, leading to potential confusion about when the loader is instantiated.
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicate HTTP GET operations with different naming conventions and parameter structures. FuelsKt uses a URL-first approach with optional parameters/headers, while StringsKt implies string-based routing but lacks a URL parameter in the signature provided (likely relying on extension context or implicit state), and uses http prefix. This creates confusion on which entry point to use for simple requests.
• Duplicate SSE operations. FuelsKt.sse requires a URL, while StringsKt.httpSSE does not. This mirrors the inconsistency found in standard HTTP methods.
• Duplicate custom HTTP method operations. FuelsKt.method takes a URL, while StringsKt.httpMethod does not (in the signature shown). This inconsistency in required arguments for the same logical operation (sending a custom HTTP verb) is confusing.
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Inconsistent factory access patterns. Fuel.loader() is a static method on the main class, while platform-specific loaders are accessed via their Companion object's invoke. This forces users to know which platform-specific loader to instantiate or rely on the generic Fuel class, but the API surface exposes multiple ways to get an HttpLoader without a unified strategy.
• …and 4 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

kittinunf/fuel was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.