kittinunf/fuel
59.9
Adequate · 13 November 2026
1.2k
lines of production code
Kotlin
primary language
7
measurements over time
What this system is
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.
Features
Add JSON deserialization extension for HttpResponse
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
Add JSON deserialization extensions for Jackson and Moshi
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
Add Maven publication and signing support for JVM libraries
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
Add mockbin-native sample using Kotlinx-io and Fuel
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
Added Apple platform HTTP loader with SSE support
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
New common API entry point and HTTP loader abstraction
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
Platform-specific HTTP loaders for JVM and WebAssembly
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
WebAssembly (Wasm) support for the httpbin-wasm sample
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
Removals
Removed OkHttp progress tracking sample
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
Behavioural changes
Migrated HTTP response handling to JVM-specific implementation
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
Removal of Kotlin-based weather sample application
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
Removal of Moshi response extension functions
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
Removal of centralized library version definitions
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
Removal of default HTTP client implementation
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
Removal of internal HTTP loader and request handling classes
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
Removal of kotlinx-serialization Response extension
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
Removed Kotlin sample using Coroutines
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
Updated Kotlin to 2.0 and upgraded Gradle wrapper to 9.3.1
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
Test coverage
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.
Dependencies
Migrate to Gradle Version Catalogs and Multiplatform Structure
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
Upgrade Gradle wrapper to version 9.3.1
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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 57 → 60 (+3.0)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 98 → 97 (-1.2)
- Architecture 99 → 99 (-0.2)
- Maturity 43 → 43 (+0.0)
- Readiness 55 → 62 (+6.5)
- Security 64 → 74 (+10.0)
- Performance 100 → 100 (+0.0)
Resolved (9)
- Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
- Duplicate HTTP GET operations with different signatures and naming conventions. FuelsKt functions take a URL string as the first argument, while StringsKt functions take parameters and headers but no URL, implying the URL is derived from the receiver or context not shown here (likely extension functions on String). This creates confusion about which entry point to use for a simple GET request.
- High secret: WD-SECRET-0005 (sample-java/src/main/java/com/example/fuel/MainActivity.java)
- High secret: WD-SECRET-0005 (sample/src/main/kotlin/com/example/fuel/MainActivity.kt)
- High secret: WD-SECRET-0005 (sample/src/main/kotlin/com/example/fuel/MainActivity.kt)
- High secret: WD-SECRET-0005 (sample/src/main/kotlin/com/example/fuel/MainActivity.kt)
- Inconsistent API for custom HTTP methods. FuelsKt exposes a simple function method(url, method, ...) that takes the HTTP method as a String argument. However, the underlying HttpLoader implementations (Apple, JVM, Wasm) and the interface HttpLoader require a Function1<Builder, Unit> lambda to configure the request, including the method. This forces users to use a different pattern for custom methods depending on whether they use the top-level FuelsKt helper or the loader directly.
- Redundant implementation classes. AppleHttpLoader, JVMHttpLoader, and WasmHttpLoader expose identical method signatures to the HttpLoader interface. While this is necessary for platform-specific implementations, the public API surface exposes three distinct concrete types with identical method names and signatures, which can be confusing for users trying to instantiate a loader. The Companion.invoke() methods suggest a factory pattern, but the direct type exposure is redundant.
- Rotate the exposed credentials — git history can't be un-committed
New (118)
- Edited copies of one member (3 members, 5+ corresponding lines) (fuel/src/appleMain/kotlin/fuel/AppleHttpLoader.kt)
- Edited copies of one member (3 members, 5+ corresponding lines) (fuel/src/appleMain/kotlin/fuel/AppleHttpLoader.kt)
- Edited copy of a member (5 corresponding lines) (fuel/src/appleMain/kotlin/fuel/AppleHttpLoader.kt)
- Edited copy of a member (5 corresponding lines) (fuel/src/appleMain/kotlin/fuel/AppleHttpLoader.kt)
- Outdated (compile): com.fasterxml.jackson.core:jackson-annotations
- Outdated (compile): com.fasterxml.jackson.core:jackson-core
- Outdated (compile): com.fasterxml.jackson.core:jackson-databind
- Outdated (compile): com.fasterxml.jackson.module:jackson-module-kotlin
- Outdated (compile): com.fasterxml.jackson:jackson-bom
- Outdated (compile): com.github.ben-manes.caffeine:caffeine
- Outdated (compile): com.github.kittinunf.result:result
- Outdated (compile): com.google.auto.service:auto-service-annotations
- Outdated (compile): com.google.devtools.ksp:symbol-processing
- Outdated (compile): com.google.devtools.ksp:symbol-processing-api
- Outdated (compile): com.google.errorprone:error_prone_annotations
- Outdated (compile): com.google.guava:failureaccess
- Outdated (compile): com.google.guava:guava
- Outdated (compile): com.google.j2objc:j2objc-annotations
- Outdated (compile): com.squareup.okhttp3:mockwebserver
- Outdated (compile): com.squareup.okhttp3:mockwebserver3
- …and 98 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 57aa89126e0d488dd54cfc2d0d9215ade2a578a9 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.64+preprod-569132d3dfbe.