# Kotlin

Kotlin is a programming language for multiplatform, backend, and Android development.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Migrating a Real Android App to Kotlin Multiplatform 4/4 -- Shipping WebAssembly to Productio

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 4/4 -- Shipping WebAssembly to Productio](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-4-4-shipping-webassembly-to-productio-140455.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-4-4-shipping-webassembly-to-productio-e863738a8151?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-11-17T19:49:30Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [multiplatform](<https://devfeed.tech/topics/multiplatform.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [compose-for-web](<https://devfeed.tech/topics/compose-for-web.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [sqldelight](<https://devfeed.tech/topics/sqldelight.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [production](<https://devfeed.tech/tags/production.md>), [splash-screen](<https://devfeed.tech/tags/splash-screen.md>), [the-web](<https://devfeed.tech/tags/the-web.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

A Kotlin Multiplatform app that builds for WebAssembly still needs browser-specific production work. The excerpt describes an inline HTML splash screen for a roughly 19 MB bundle, a spinner with visible timeout and error states instead of a misleading byte-based progress bar, and browser-history navigation whose fragment routes must stay synchronized with backend redirects. It also covers a server-side image proxy needed because Strava's CDN lacks CORS headers, with requests tagged by client so native apps keep using original URLs. In the browser, SQLDelight uses sql.js with a hand-maintained schema mirror, creating a risk that schema changes break web only. A deployed-origin `blob:` media issue required a custom Coil mapper and fetcher. These examples show how browser loading, routing, security, storage and media behavior can affect architecture and maintenance.

### Source excerpt

The wasm build runs locally in minutes. ./gradlew wasmJsBrowserDevelopmentRun, a browser tab opens, the app is there. It feels finished. It isn't, and the reason is the subject of this article. The browser isn't a fourth target that happens to render the same Compose code. It's a host with its own rules about what paints when, who owns navigation, what a page is allowed to fetch, and what a database even is. Compose Multiplatform hides none of that -- it just gets your UI onto the canvas, and then you're in someone else's house. Getting a multiplatform app to build is different from making it production-ready. Everything below is a thing that worked locally and didn't work for users. Nothing paints until the bundle arrives On Android, the launcher draws your icon the instant the user taps it. The OS owns that moment, and you get it for free. On the web you get nothing. A blank page, for as long as it takes to fetch a wasm bundle -- around 19MB -- uncompressed, and around 6.5MB Brotli transfer size -- and compile it. Users don't read that as "loading", they read it as broken, and they leave before the first frame. So the first thing I had to write for the web was something Android had given me for a decade: a splash screen. It lives inline in index.html, CSS and all, specifically so it costs no request of its own -- a splash that waits on a stylesheet defeats the purpose. The color values are a hand-copied duplicate of the theme tokens in core:designsystem, so the canvas takes over without a colour change. It's duplication I'd normally reject, and here there's no alternative: the theme lives in Kotlin inside the bundle that hasn't downloaded yet. It also has a known flaw I decided to keep. The splash follows the OS colour scheme, while the app also honours a theme the user picked by hand in settings. Someone who forced the theme against their OS gets one flash at the handover. Reading their choice would mean parsing the stored settings JSON from plain JavaScript, and coup

## Kotlin Toolchain 0.14: Agentic Development and iOS Publishing

DevFeed: [Kotlin Toolchain 0.14: Agentic Development and iOS Publishing](<https://devfeed.tech/articles/kotlin-toolchain-0-14-agentic-development-and-ios-publishing-140895.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/kotlin/2026/11/kotlin-toolchain-0-14-agentic-development-and-ios-publishing/>)

Author: Kirill Likhodedov

Published: 2026-11-17T15:25:05Z

Content type: release

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>), [Kotlin](<https://devfeed.tech/sources/kotlin-a-concise-multiplatform-language-developed-by-jetbrains-the-jetbrains-blog.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [mobile devops](<https://devfeed.tech/topics/mobile-devops.md>), [IntelliJ IDEA](<https://devfeed.tech/topics/intellij-idea.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ios](<https://devfeed.tech/tags/ios.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-toolchain](<https://devfeed.tech/tags/kotlin-toolchain.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [publishing](<https://devfeed.tech/tags/publishing.md>), [releases](<https://devfeed.tech/tags/releases.md>)

### AI overview

Kotlin Toolchain 0.14 adds `kotlin publish testflight`, which guides first-time TestFlight setup and supports publishing later updates with the same command. It uses an App Store Connect access token and requires Apple Developer Program membership; the tool says it neither stores the private key nor requests Apple ID credentials. Xcode projects remain available for manual signing and advanced options. For agentic workflows, the CLI wizard generates project guidance such as MCP configuration and `AGENTS.md`, and Kotlin agent skills can be installed with `npx skills add kotlin/kotlin-agent-skills`; the article says internal evaluations found these skills reduce token use. Other changes include IDE visibility for template errors and warnings, configurable Android API desugaring in `module.yaml`, overridable external-tool download URLs for internal mirrors, and a dependency resolver benchmarked at over 3x faster for importing the Kotlin Toolchain project without caches.

### Source excerpt

The Kotlin Toolchain helps you build and ship multiplatform apps faster, with less setup and configuration. Its CLI provides a unified workflow for building, running, testing, and publishing apps for Android, iOS, desktop, and web, whether you're developing with AI agents or writing code yourself. Kotlin Toolchain 0.14 makes it easier to publish iOS apps [...]

## Kotlin Multiplatform Networking with Native Android and iOS ViewModels

DevFeed: [Kotlin Multiplatform Networking with Native Android and iOS ViewModels](<https://devfeed.tech/articles/kotlin-multiplatform-networking-with-native-android-and-ios-viewmodels-134271.md>)

Original publisher: [Read original article](<https://proandroiddev.com/kmp-networking-native-viewmodels-cf6fb357b012?source=rss----c72404660798---4>)

Author: Ravi Rawal

Published: 2026-11-14T14:49:33Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Ktor](<https://devfeed.tech/topics/ktor.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [REST API](<https://devfeed.tech/topics/rest-api.md>), [coroutine-testing](<https://devfeed.tech/topics/coroutine-testing.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [cancellation](<https://devfeed.tech/tags/cancellation.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [domain](<https://devfeed.tech/tags/domain.md>), [error](<https://devfeed.tech/tags/error.md>), [http](<https://devfeed.tech/tags/http.md>), [http-client](<https://devfeed.tech/tags/http-client.md>), [ios](<https://devfeed.tech/tags/ios.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [native](<https://devfeed.tech/tags/native.md>), [networking](<https://devfeed.tech/tags/networking.md>), [published](<https://devfeed.tech/tags/published.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

The article recommends sharing Ktor networking, serialization, repositories, domain models, and meaningful use cases in Kotlin Multiplatform while Android and iOS retain native ViewModels and presentation state. Callers own coroutine or task lifecycles: Android can launch through `viewModelScope`; iOS can bridge Kotlin suspend functions to Swift `async`/`await` with KMP-NativeCoroutines or SKIE and cancel its Swift `Task`. Ktor requests are suspending and need no automatic dispatcher switch when they are main-safe; truly blocking or CPU-heavy work should use an appropriate injected dispatcher. Preserve cancellation, reuse the HTTP client, and keep DTO-to-domain and domain-to-UI mapping at their respective boundaries. The article notes that Swift interop adds generated types and conversions, and shared unit tests do not verify platform HTTP engines or the Kotlin-to-Swift bridge.

### Source excerpt

Share Ktor networking, repositories, and use cases while Android and iOS keep control of their native ViewModels, UI state, threading, and cancellation. Kotlin Multiplatform allows us to share networking and business logic between Android and iOS. When an API call is made from the shared Kotlin module to the native app there are a number of things we need to make a decision on. Who creates the coroutine? Who handles where the work is executed? Will the ViewModel be the same for Android and iOS? How do we get the use cases from the shared module onto each platform? The decisions here are more important than the actual HTTP client. A good KMP architecture will not have all the layers shared between both platforms. We can leave the repositories and use cases in Kotlin, have Android use its Jetpack ViewModels and iOS use SwiftUI with its native Swift ViewModels. Both platforms will call the same business functions but each will have control over their own presentation lifecycle. It's important to make sure the work that needs to be consistent is shared. Let's look at how we can create this architecture using a simple example of fetching articles from a REST API. 1. Decide what belongs in shared code Lets start with two native applications and one shared KMP module. The Android and iOS applications will not need or have identical ViewModels. But they should access to the same business operation. The shared module can own: HTTP client configuration and API requests. DTOs and serialization. Repository implementations and data-to-domain mapping. Use cases that represent application operations. Shared validation, business rules, and error classification. Android can use using Jetpack ViewModel, viewModelScope, and StateFlow. iOS may use SwiftUI, ObservableObject, @Published, and Swift concurrency. This is one of the architecture options described in the Kotlin Multiplatform ViewModel documentation: sharing the repository and data layers while keeping platform-specific ViewMo

## Migrating a Real Android App to Kotlin Multiplatform 3/4 -- Sharing the UI without losing safety net

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 3/4 -- Sharing the UI without losing safety net](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-3-4-sharing-the-ui-without-losing-safety-net-124797.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-3-4-sharing-the-ui-without-losing-safety-net-f74a6bf408ae?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-11-09T14:53:26Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [robolectric](<https://devfeed.tech/topics/robolectric.md>), [Android](<https://devfeed.tech/topics/android.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [about](<https://devfeed.tech/tags/about.md>), [all](<https://devfeed.tech/tags/all.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-library](<https://devfeed.tech/tags/android-library.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [animation](<https://devfeed.tech/tags/animation.md>), [app](<https://devfeed.tech/tags/app.md>), [application](<https://devfeed.tech/tags/application.md>), [article](<https://devfeed.tech/tags/article.md>), [away](<https://devfeed.tech/tags/away.md>), [build](<https://devfeed.tech/tags/build.md>), [classes](<https://devfeed.tech/tags/classes.md>), [code](<https://devfeed.tech/tags/code.md>), [code-smell](<https://devfeed.tech/tags/code-smell.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [safety](<https://devfeed.tech/tags/safety.md>), [sharing](<https://devfeed.tech/tags/sharing.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

Most BikeHub composables moved to Kotlin Multiplatform's commonMain with few code changes; the harder work was adapting Android-centered tooling. The author had first moved UI state and logic into plain Kotlin through Ouroboros-Compose, avoiding Android ViewModel dependencies across 38 feature modules. Android-specific seams were limited and isolated behind expect/actual or an ExternalNavigator interface. Of 13,843 androidMain lines, 9,653 were previews; Compose Preview Screenshot Testing did not work in a KMP module, so the project uses Roborazzi under Robolectric in androidHostTest. A convention plugin enables screenshot tests across 40 modules and copies centralized Compose Multiplatform resources into host-test assets, relying on a reflective workaround to expose their generated location. The setup checks Android rendering only, leaves iOS and web unverified, and stores 55 MB of PNG baselines; half-scale captures limit their size. The account emphasizes auditing previews, resources, plugins and tests before changing module types.

### Source excerpt

Migrating a Real Android App to Kotlin MultiplatformPart 3: Sharing the UI without losing the safety net Part 2 ended on a pattern: the code that moved most easily was the code that knew nothing about Android. By that logic the UI layer should have been the worst part of the migration. It touches the screen, the system bars, the keyboard, the back gesture -- everything that is unmistakably a platform. And, much to my amazement, it wasn't. The composables moved about as easily as the domain models did. What didn't move was everything around them. The resource system, the build plugins, the preview tooling and the screenshot tests were all built on the assumption that a Compose module is an Android library module. Once that stopped being true, the application code was fine and the ecosystem around it wasn't. Sharing application code turned out to be easier than sharing the ecosystem around it. That's the whole article. What moved easily Most composables moved to commonMain unchanged. Layout, state, theming, animation -- Compose Multiplatform covers the surface BikeHub uses, and the diff for a typical screen was mostly imports. Two things made this smoother than it would otherwise have been. The UDF layer went first. Every feature module in BikeHub uses Ouroboros-Compose, a small unidirectional-data-flow library (influenced by Spotify's Mobius, that I used back then, when views and fragments ruled the android UI). It abstracts the ViewModel away and keeps the UI logic in plain, testable classes. I refactored it to KMP as step 0 of the whole migration, before touching a single feature module. That ordering mattered more than it looks. Because the UI logic doesn't sit inside an Android ViewModel, there was no androidx.lifecycle dependency threaded through 38 feature modules waiting to be unpicked. The state holders were already just Kotlin. Android platform code in the UI layer was already a code smell. I'd treated it that way for years, so there wasn't much of it to find.

## Compose Multiplatform: Why You Shouldn't Build Your Whole iOS App in Compose

DevFeed: [Compose Multiplatform: Why You Shouldn't Build Your Whole iOS App in Compose](<https://devfeed.tech/articles/compose-multiplatform-why-you-shouldn-t-build-your-whole-ios-app-in-compose-122709.md>)

Original publisher: [Read original article](<https://proandroiddev.com/compose-multiplatform-why-you-shouldnt-build-your-whole-ios-app-in-compose-9e1e8c978a5b?source=rss----c72404660798---4>)

Author: Anatolii Frolov

Published: 2026-11-09T00:22:32Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [liquid glass](<https://devfeed.tech/topics/liquid-glass.md>), [bottom-navigation](<https://devfeed.tech/topics/bottom-navigation.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [ios](<https://devfeed.tech/tags/ios.md>), [ios-app-development](<https://devfeed.tech/tags/ios-app-development.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [liquid-glass](<https://devfeed.tech/tags/liquid-glass.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [operating-system](<https://devfeed.tech/tags/operating-system.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [swiftui](<https://devfeed.tech/tags/swiftui.md>), [uikit](<https://devfeed.tech/tags/uikit.md>)

### AI overview

The article's ClariMeal example keeps product screens and business logic shared in Kotlin and Compose while UIKit owns iOS navigation and system controls. A UIKit tab bar can adopt Apple's appearance changes, including the iOS 26 detached Add control; on iOS 17-25, the app draws the Add circle itself. Compose screens are hosted in native view controllers, and navigation events go to the native stack, avoiding a competing Compose back stack. Android uses Compose for screens, navigation, and its bottom bar. Product-specific cards and charts remain shared, while copied iOS measurements in Compose design tokens still require review as iOS changes. Native integration still involves SDK updates, integration work, and testing; a full SwiftUI rewrite is presented as unnecessary for this app's goals.

### Source excerpt

How to keep your screens shared while letting iOS handle navigation and system controls. Compose Multiplatform lets Android developers reuse Kotlin and Compose screen code on iOS. You keep the language and the UI toolkit you already know, and the same screens run on an iPhone. But a screen that runs on iOS does not automatically follow iOS. You can build the whole app in Compose, including the tab bar and navigation, and Compose Multiplatform supports the back gesture and iOS-style transitions. What it cannot do is redraw your own tab bar when Apple redesigns the system one. A Compose copy of a system control stays the way you drew it. I faced this choice while building ClariMeal, a calorie tracker for iOS and Android. I wanted the product screens shared, and I wanted the navigation and system controls to come from iOS itself. The reason was maintenance. Liquid Glass in iOS 26 is a system material, and Compose cannot draw it. On Android, ClariMeal has its own glass tab bar built in Compose, and it looks good there. On iOS it would still be an imitation: it looks different and does not behave like the system bar. Only the system bar follows iOS when Apple changes it. That did not require a SwiftUI rewrite. Screen content stayed in Compose and the logic stayed in Kotlin, while native iOS components took over navigation and system interactions. This article explains which parts of your iOS app are better left to the system when you want them to follow iOS, where I drew that boundary, and what it still cost. 1. The tab bar belongs to the operating system Start with one comparison: the same tab bar on Android, iOS 18 and iOS 26. On Android, Compose draws the whole bar, including the + button in the middle. On iOS, the tab bar comes from UIKit, and the + button shows where the line between the system and the app runs. The app supports iOS 17 and later. Before iOS 26, the + button is a circle in the middle of the system tab bar, and that circle is my code. On iOS 26, I rep

## Clear your Kotlin's code mutation report using Jev

DevFeed: [Clear your Kotlin's code mutation report using Jev](<https://devfeed.tech/articles/clear-your-kotlin-s-code-mutation-report-using-jev-122572.md>)

Original publisher: [Read original article](<https://le0nidas.gr/2026/11/08/clear-your-kotlins-code-mutation-report-using-jev/>)

Author: Leonidas Partsas

Published: 2026-11-08T16:21:55Z

Content type: tutorial

Language: en

Sources: [le0nidas](<https://devfeed.tech/sources/le0nidas.md>)

Topics: [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [bytecode](<https://devfeed.tech/tags/bytecode.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [csv](<https://devfeed.tech/tags/csv.md>), [java](<https://devfeed.tech/tags/java.md>), [jev](<https://devfeed.tech/tags/jev.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [noul](<https://devfeed.tech/tags/noul.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [report](<https://devfeed.tech/tags/report.md>), [system](<https://devfeed.tech/tags/system.md>), [test](<https://devfeed.tech/tags/test.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

Kotlin's compiler-generated bytecode can make PIT reports noisy, since PIT may report mutations in code that was not present in the original source. The described cleanup filters PIT's report to surviving mutations, optionally simplifies entries, and removes mutations in compiler-inserted methods by checking whether the method appears in the source file. For mutations inside existing methods, scripts prepare the method and mutation description for Jev, which scores whether the change could apply to the original code; scores below 0.5 are discarded. An agent then uses the remaining valid surviving mutations to add or strengthen regression tests, without changing production semantics. The excerpt describes this process but does not provide the scripts or their implementation details.

### Source excerpt

Mutation testing is making a come back and rightfully so. Now that we have agents doing all the testing for us we need to make sure that they've written all necessary tests, making our test suite stronger and our project better. Mutation testing In a nutshell, mutation testing is a way to check if the ... Continue reading Clear your Kotlin's code mutation report using Jev ->

## Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities

DevFeed: [Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities](<https://devfeed.tech/articles/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2-s-new-boolean-nullable-utilities-122284.md>)

Original publisher: [Read original article](<https://proandroiddev.com/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2s-new-boolean-nullable-utilities-7854207156ea?source=rss----c72404660798---4>)

Author: Nav Singh

Published: 2026-11-07T16:39:54Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>), [if statement](<https://devfeed.tech/topics/if-statement.md>), [Null-Safety](<https://devfeed.tech/topics/null-safety.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [scope function](<https://devfeed.tech/topics/scope-function.md>)

Tags: [also](<https://devfeed.tech/tags/also.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [annotation](<https://devfeed.tech/tags/annotation.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [apply](<https://devfeed.tech/tags/apply.md>), [boilerplate](<https://devfeed.tech/tags/boilerplate.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [chaining](<https://devfeed.tech/tags/chaining.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [condition](<https://devfeed.tech/tags/condition.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [functions](<https://devfeed.tech/tags/functions.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-2](<https://devfeed.tech/tags/kotlin-2.md>), [lambda](<https://devfeed.tech/tags/lambda.md>), [let](<https://devfeed.tech/tags/let.md>), [receiver](<https://devfeed.tech/tags/receiver.md>), [scope-functions](<https://devfeed.tech/tags/scope-functions.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>)

### AI overview

Kotlin 2.5.0-Beta2 introduces experimental standard-library helpers for conditional work: `onTrue` and `onFalse` run a supplied block when a Boolean matches, then return that Boolean unchanged; `ifOrNull` lazily computes and returns a value when its condition is true, or returns null when false. The excerpt shows using the Boolean helpers for authentication side effects and `ifOrNull` to produce a phone number only when contact information is available. Use requires opting in to `ExperimentalStdlibApi`, either at the function or file level or through Gradle language settings. The excerpt does not establish broader API availability or stability.

### Source excerpt

AI generated image Ditch redundant if-else boilerplate and awkward scope chaining with the newly introduced onTrue(), onFalse(), and ifOrNull() functions. Kotlin has always excelled at eliminating boilerplate. From concise data classes and standard scope functions (apply, also, let, takeIf) to smart casting, the language consistently seeks ways to make everyday idioms more expressive. Kotlin 2.5.0-Beta2 adds standard library functions that let us inspect a value before returning it, or return a nullable result based on that value. https://kotlinlang.org/docs/whatsnew-eap.html?utm_campaign=kotlin-releases&utm_content=2-5-0-beta2 Boolean.onTrue(action: () -> Unit): Boolean Boolean.onFalse(action: () -> Unit): Boolean ifOrNull(condition: Boolean, action: () -> T): T? Implementation Because these functions are introduced as experimental APIs in the standard library, we need to opt in to use them. File/Function Annotation OptIn(ExperimentalStdlibApi::class) Module-wide via Gradle config kotlin { sourceSets.all { languageSettings.optIn("kotlin.ExperimentalStdlibApi") } }onTrue() & onFalse() Both functions invoke a supplied block when the receiver matches the condition and return the original boolean unmodified. Example data class User(val id: String, val email: String) class AuthService() { // Before: fun authenticateLegacy(user: User, token: String): Boolean { val isValid = verifyToken(user.email, token) if (isValid) { "Auth.success" } else { "Auth.failure" } return isValid } // Now: @OptIn(ExperimentalStdlibApi::class) fun authenticate(user: User, token: String): Boolean = verifyToken(user.email, token) .onTrue { "Auth.success" } .onFalse { "Auth.failure" } }ifOrNull() When shaping API responses or DTOs, we may return one computed value if a flag is true and another if false. Traditionally, this looks like 👇 val phoneNumber = if (user.hasContactInfo) user.phoneNumber else nullThe New Way: ifOrNull() ifOrNull(condition) { //.. } lazily evaluates the lambda block only if

## Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities

DevFeed: [Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities](<https://devfeed.tech/articles/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2-s-new-boolean-nullable-utilities-122052.md>)

Original publisher: [Read original article](<https://proandroiddev.com/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2s-new-boolean-nullable-utilities-7854207156ea?source=rss-711ab22c5c77------2>)

Author: Nav Singh

Published: 2026-11-07T02:22:10Z

Content type: tutorial

Language: en

Sources: [Nav Singh](<https://devfeed.tech/sources/stories-by-nav-singh-on-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>), [if statement](<https://devfeed.tech/topics/if-statement.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [scope function](<https://devfeed.tech/topics/scope-function.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-2](<https://devfeed.tech/tags/kotlin-2.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>)

### AI overview

Kotlin 2.5.0-Beta2 introduces three experimental standard-library utilities for conditional logic. `Boolean.onTrue` and `onFalse` run a supplied block when the Boolean matches, then return the original Boolean unchanged; the excerpt shows them used to trigger authentication messages while preserving the verification result. `ifOrNull(condition) { ... }` evaluates its block only when the condition is true, returning its value or `null`, as in the phone-number example. Use requires opting in with `ExperimentalStdlibApi`, either at a file or function or through the shown Gradle source-set setting. The supplied excerpt does not describe further behavior or limitations.

### Source excerpt

AI generated image Ditch redundant if-else boilerplate and awkward scope chaining with the newly introduced onTrue(), onFalse(), and ifOrNull() functions. Kotlin has always excelled at eliminating boilerplate. From concise data classes and standard scope functions (apply, also, let, takeIf) to smart casting, the language consistently seeks ways to make everyday idioms more expressive. Kotlin 2.5.0-Beta2 adds standard library functions that let us inspect a value before returning it, or return a nullable result based on that value. https://kotlinlang.org/docs/whatsnew-eap.html?utm_campaign=kotlin-releases&utm_content=2-5-0-beta2 Boolean.onTrue(action: () -> Unit): Boolean Boolean.onFalse(action: () -> Unit): Boolean ifOrNull(condition: Boolean, action: () -> T): T? Implementation Because these functions are introduced as experimental APIs in the standard library, we need to opt in to use them. File/Function Annotation OptIn(ExperimentalStdlibApi::class) Module-wide via Gradle config kotlin { sourceSets.all { languageSettings.optIn("kotlin.ExperimentalStdlibApi") } }onTrue() & onFalse() Both functions invoke a supplied block when the receiver matches the condition and return the original boolean unmodified. Example data class User(val id: String, val email: String) class AuthService() { // Before: fun authenticateLegacy(user: User, token: String): Boolean { val isValid = verifyToken(user.email, token) if (isValid) { "Auth.success" } else { "Auth.failure" } return isValid } // Now: @OptIn(ExperimentalStdlibApi::class) fun authenticate(user: User, token: String): Boolean = verifyToken(user.email, token) .onTrue { "Auth.success" } .onFalse { "Auth.failure" } }ifOrNull() When shaping API responses or DTOs, we may return one computed value if a flag is true and another if false. Traditionally, this looks like 👇 val phoneNumber = if (user.hasContactInfo) user.phoneNumber else nullThe New Way: ifOrNull() ifOrNull(condition) { //.. } lazily evaluates the lambda block only if

## How to Connect ESP32 to Wi-Fi on Android (The Right Way) | EasyEsp

DevFeed: [How to Connect ESP32 to Wi-Fi on Android (The Right Way) | EasyEsp](<https://devfeed.tech/articles/how-to-connect-esp32-to-wi-fi-on-android-the-right-way-easyesp-121955.md>)

Original publisher: [Read original article](<https://proandroiddev.com/how-to-connect-esp32-to-wi-fi-on-android-the-right-way-easyesp-b110317a5a41?source=rss----c72404660798---4>)

Author: Arul mani

Published: 2026-11-06T15:14:25Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [smartdevices](<https://devfeed.tech/topics/smartdevices.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Library](<https://devfeed.tech/topics/library.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automated](<https://devfeed.tech/tags/automated.md>), [build](<https://devfeed.tech/tags/build.md>), [esp32](<https://devfeed.tech/tags/esp32.md>), [firmware](<https://devfeed.tech/tags/firmware.md>), [flow](<https://devfeed.tech/tags/flow.md>), [hotspot](<https://devfeed.tech/tags/hotspot.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [http](<https://devfeed.tech/tags/http.md>), [iot](<https://devfeed.tech/tags/iot.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kmm](<https://devfeed.tech/tags/kmm.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [mvi](<https://devfeed.tech/tags/mvi.md>), [network](<https://devfeed.tech/tags/network.md>), [networking](<https://devfeed.tech/tags/networking.md>), [wi-fi](<https://devfeed.tech/tags/wi-fi.md>)

### AI overview

EasyESP Connect is presented as a way to provision an ESP32 from an Android app without sending users through phone Wi-Fi settings. The excerpt says Android 9+ may route requests from an internet-free ESP32 hotspot over cellular; on Android 10+, the library uses WifiNetworkSpecifier and binds the app process to that Wi-Fi network. It can discover setup SSIDs, fall back to guided manual connection if automatic connection is blocked, and pair with ESP32 firmware in WIFI_AP_STA mode. Developers can use a prebuilt Jetpack Compose UI, launch the flow through Activity Result API from XML or Fragment apps, or build a custom UI around its MVI session and state. The Arduino library exposes GET /networks for nearby networks and POST /credentials to receive Wi-Fi details, stop the temporary hotspot, and connect to the home router.

### Source excerpt

Photo by Vishnu Mohanan on Unsplash Stop frustrating your IoT users. Build a seamless ESP32 Wi-Fi provisioning flow using Jetpack Compose, Ktor, and MVI Architecture. The Painless Way to Connect ESP32 Devices to Wi-Fi on Android 📱⚡ How to build seamless IoT provisioning flows using Jetpack Compose, Ktor, and MVI Architecture. If you've ever built an IoT product, you know the biggest hurdle isn't writing the firmware or building the cloud backend -- it's the onboarding process. Getting a screenless microcontroller (like an ESP32) connected to a user's home Wi-Fi network is notoriously frustrating. Users have to leave your app, go to their phone's Wi-Fi settings, connect to a temporary hotspot, ignore the "Internet may not be available" warnings, go back to the app, enter their credentials, and pray it works. As Android developers, we can do better. Today, I am open-sourcing EasyESP Connect -- a battle-tested Kotlin Multiplatform (KMM) Library, Android App, and companion ESP32 firmware that makes provisioning ESP32 devices incredibly simple, resilient, and fully automated. The Android IoT Routing Problem 🚧 Before diving into the solution, let's talk about why Android makes IoT provisioning so hard. When your phone connects to an ESP32's temporary Wi-Fi hotspot, that hotspot doesn't have internet access. Modern Android versions (Android 9+) are smart -- if they detect a Wi-Fi network has no internet, they will silently route all HTTP requests through the user's Cellular Data instead. This means when your app tries to send the Wi-Fi password to http://192.168.4.1, the request goes to the cellular tower, times out, and the setup fails. The Solution: EasyESP Connect ✨ EasyESP Connect solves this (and many other edge cases) by taking full control of the Android Networking stack and providing a beautiful, state-driven Jetpack Compose UI. Key Features: * Automated Device Discovery: Passively scans for local ESP32 devices broadcasting setup SSIDs using Android's WifiManager. * P

## Add push notifications to your Android app without Firebase

DevFeed: [Add push notifications to your Android app without Firebase](<https://devfeed.tech/articles/add-push-notifications-to-your-android-app-without-firebase-121684.md>)

Original publisher: [Read original article](<https://appwrite.io/blog/post/add-push-notifications-to-your-android-app>)

Author: Atharva Deosthale

Published: 2026-11-06T00:00:00Z

Content type: tutorial

Language: en

Sources: [Appwrite Blog](<https://devfeed.tech/sources/appwrite-blog.md>)

Topics: [Push Notifications](<https://devfeed.tech/topics/push-notifications.md>), [notifications](<https://devfeed.tech/topics/notifications.md>), [Android](<https://devfeed.tech/topics/android.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [account](<https://devfeed.tech/tags/account.md>), [also](<https://devfeed.tech/tags/also.md>), [android](<https://devfeed.tech/tags/android.md>), [android-13](<https://devfeed.tech/tags/android-13.md>), [android-15](<https://devfeed.tech/tags/android-15.md>), [api](<https://devfeed.tech/tags/api.md>), [api-key](<https://devfeed.tech/tags/api-key.md>), [app](<https://devfeed.tech/tags/app.md>), [customers](<https://devfeed.tech/tags/customers.md>), [firebase](<https://devfeed.tech/tags/firebase.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [notifications](<https://devfeed.tech/tags/notifications.md>), [notify](<https://devfeed.tech/tags/notify.md>), [open](<https://devfeed.tech/tags/open.md>), [order](<https://devfeed.tech/tags/order.md>), [push-notifications](<https://devfeed.tech/tags/push-notifications.md>), [send](<https://devfeed.tech/tags/send.md>), [tap](<https://devfeed.tech/tags/tap.md>), [tutorials](<https://devfeed.tech/tags/tutorials.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

Appwrite Push lets a Kotlin Android app send notifications to a signed-in user across their devices without Firebase setup or FCM token collection. Register the Android app in Appwrite, add the Android SDK (API 24 or later), and subscribe after sign-in; an Appwrite Function can send pushes to a user ID when order status changes. Include an order ID in message data and handle taps with `getInitialNotification` and `onNotificationOpened`. Foreground messages reach the callback; background notifications can arrive after process death, reboot, or reconnect, but timing is delayed (15 seconds to two minutes in Android 15 tests). A foreground service reduced tested background delivery to within two seconds, with a quiet ongoing notification and a Google Play declaration requirement. Force-stopped apps receive nothing until reopened. Close Push before deleting a session to stop delivery for the previous user. Repeated order updates can resend notifications, so the tutorial recommends tracking the last status notified.

### Source excerpt

Send push notifications to a Kotlin app with Appwrite Push. Notify customers when an order ships, deliver while the app is closed, and open the order on tap.

## The Kotlin Multiplatform Contest Is Open: Win a Trip to KotlinConf

DevFeed: [The Kotlin Multiplatform Contest Is Open: Win a Trip to KotlinConf](<https://devfeed.tech/articles/the-kotlin-multiplatform-contest-is-open-win-a-trip-to-kotlinconf-119697.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/kotlin/2026/11/kotlin-multiplatform-contest-2027/>)

Author: Ksenia Shneyveys

Published: 2026-11-05T22:05:21Z

Content type: news

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>), [Kotlin](<https://devfeed.tech/sources/kotlin-a-concise-multiplatform-language-developed-by-jetbrains-the-jetbrains-blog.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [ai](<https://devfeed.tech/tags/ai.md>), [conference](<https://devfeed.tech/tags/conference.md>), [contest](<https://devfeed.tech/tags/contest.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [education](<https://devfeed.tech/tags/education.md>), [foundation](<https://devfeed.tech/tags/foundation.md>), [graduates](<https://devfeed.tech/tags/graduates.md>), [idea](<https://devfeed.tech/tags/idea.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [kotlinconf](<https://devfeed.tech/tags/kotlinconf.md>), [kotlinconf-2027](<https://devfeed.tech/tags/kotlinconf-2027.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [news](<https://devfeed.tech/tags/news.md>), [open](<https://devfeed.tech/tags/open.md>), [poland](<https://devfeed.tech/tags/poland.md>), [project](<https://devfeed.tech/tags/project.md>), [students](<https://devfeed.tech/tags/students.md>)

### AI overview

Students and recent graduates can enter the Kotlin Multiplatform Contest by December 7, 2026, with a project made specifically for the contest that uses KMP and runs on at least two platforms. Any project category is eligible. The top three projects' authors receive KotlinConf 2027 tickets, travel, and accommodation in Kraków; authors of other valid entries receive Kotlin souvenirs. No prior KMP experience is required: the contest offers a Starter Kit with AI-assisted skills, prompts, and workflows, alongside documentation and other learning resources. Winners are to be announced December 21, 2026.

### Source excerpt

The Kotlin Multiplatform Contest is back! Students and recent graduates, turn your idea into a cross-platform project with Kotlin Multiplatform (KMP). The authors of the top three projects will each win a trip to KotlinConf 2027 in Kraków, Poland, with conference tickets, travel, and accommodation covered by the Kotlin Foundation. Authors of all other valid [...]

## Migrating a Real Android App to Kotlin Multiplatform 2/4 -- What Moved for Free, and What Hurt

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 2/4 -- What Moved for Free, and What Hurt](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-2-4-what-moved-for-free-and-what-hurt-113141.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-2-4-what-moved-for-free-and-what-hurt-7ec973002f01?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-11-02T14:51:13Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [koin](<https://devfeed.tech/topics/koin.md>), [Ktor](<https://devfeed.tech/topics/ktor.md>), [sqldelight](<https://devfeed.tech/topics/sqldelight.md>), [Android](<https://devfeed.tech/topics/android.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [apis](<https://devfeed.tech/tags/apis.md>), [app](<https://devfeed.tech/tags/app.md>), [code](<https://devfeed.tech/tags/code.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [context](<https://devfeed.tech/tags/context.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [dependency-injection](<https://devfeed.tech/tags/dependency-injection.md>), [di](<https://devfeed.tech/tags/di.md>), [files](<https://devfeed.tech/tags/files.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [init](<https://devfeed.tech/tags/init.md>), [interface](<https://devfeed.tech/tags/interface.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [koin](<https://devfeed.tech/tags/koin.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>)

### AI overview

The author reports that roughly 84% of the app's Kotlin code moved to commonMain, but migration effort depended more on the app's platform coupling than on library support. Ktor's client configuration and request logic moved unchanged; SQLDelight's schema and queries were already platform agnostic, though its web WebWorkerDriver stores data only in memory. Koin modules bind platform implementations to shared interfaces when construction needs platform dependencies; this avoids some expect/actual constraints but makes missing bindings runtime failures. The excerpt recommends building a second target in CI early because Android builds can miss Android-only dependencies leaking into shared code. Replacing pervasive java.time usage was the hardest work: kotlinx-datetime helped, while locale-aware date formatting needed custom implementations using java.time on Android, Intl.DateTimeFormat on wasm, and NSDate on iOS. File uploads use a lazy, repeatable byte-source boundary; Android and iOS can stream, while the web implementation buffers chunks because browser reads are asynchronous and kotlinx-io's RawSource is synchronous. Multiplatform Settings with kotlinx.serialization handles key-

### Source excerpt

Migrating a Real Android App to Kotlin Multiplatform 2/4 -- What Moved for Free, and What HurtPart 2: What Moved for Free, and What Hurt In Part 1 I described the foundations: a modular Android codebase with Ktor, Koin and SQLDelight already in place, and a rule that the Android app must stay shippable after every step. The result is that around 84% of the Kotlin code now lives in commonMain. What that number hides is how unevenly the work was distributed. Some layers moved almost mechanically, in an afternoon, with a plugin swap and a few imports. Others took weeks and touched code I hadn't looked at in years. The pattern turned out to be simple, and in hindsight obvious: multiplatform support in your libraries matters far less than how tightly your own code is coupled to platform APIs. A library either supports KMP or it doesn't, and you find out in minutes. Your own platform coupling is spread across hundreds of files and you find out gradually, for weeks. What moved for freeKoin Dependency injection is the piece I'd underrate if I were writing this list from memory, and it deserves more credit than that. Koin ended up being the mechanism that keeps platform code out of shared code. Instead of reaching for expect / actual every time a component needs a platform implementation, the shared code depends on an interface, and each platform contributes a module that binds it: https://medium.com/media/a9ac7c95779230353cc1e3f0943e48b7/href expect/actual works well for small, self-contained things: a platform name, a formatter, a UUID generator. It gets awkward as soon as a platform implementation needs its own dependencies. The declaration in commonMain fixes the constructor signature for every target, so an Android implementation that needs a Context has to get it some other way, usually through an init step the platform has to remember to call. With a DI module, shared code depends on an interface and nothing else. Each platform binds its own implementation, with whatev

## Your Compose Code, on More Screens and Less CPU

DevFeed: [Your Compose Code, on More Screens and Less CPU](<https://devfeed.tech/articles/your-compose-code-on-more-screens-and-less-cpu-109731.md>)

Original publisher: [Read original article](<https://www.codenameone.com/blog/compose-on-more-screens/>)

Author: Shai Almog

Published: 2026-10-31T00:00:00Z

Content type: opinion

Language: en

Sources: [CodeName One](<https://devfeed.tech/sources/codename-one.md>)

Topics: [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [builds](<https://devfeed.tech/topics/builds.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [battery](<https://devfeed.tech/tags/battery.md>), [battery-life](<https://devfeed.tech/tags/battery-life.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [build](<https://devfeed.tech/tags/build.md>), [builds](<https://devfeed.tech/tags/builds.md>), [button](<https://devfeed.tech/tags/button.md>), [bytecode](<https://devfeed.tech/tags/bytecode.md>), [card](<https://devfeed.tech/tags/card.md>), [class](<https://devfeed.tech/tags/class.md>), [code](<https://devfeed.tech/tags/code.md>), [codename](<https://devfeed.tech/tags/codename.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [components](<https://devfeed.tech/tags/components.md>), [compose](<https://devfeed.tech/tags/compose.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [screen](<https://devfeed.tech/tags/screen.md>)

### AI overview

Codename One can build Kotlin Multiplatform Compose code from the same `commonMain` sources: Kotlin compiles to JVM bytecode with the Compose compiler plugin, uses upstream Compose runtime and coroutines, and maps the UI layer to Codename One components before ParparVM creates native binaries. In the Keynote app benchmark, all three release builds reached the same frame rate, while Compose on Codename One used about 4 ms of CPU per frame versus about 17 ms for Compose Multiplatform. The measurements used an iPhone 17 Pro simulator, programmatic scrolling, and five runs; startup comparisons are limited because the Compose Multiplatform marker precedes drawing and most startup time came from iOS. The article reports a 16.8 MB executable versus 22.9 MB for Compose Multiplatform, and says imperative Java on Codename One was faster and about half the size of its Compose version. Teams can mix Compose and Codename One components per screen. The port is incomplete: `LazyColumn(reverseLayout = true)` is unsupported, and its build targets JVM 11.

### Source excerpt

Kotlin Multiplatform code with Compose now builds as a Codename One app, with about a quarter of the CPU work per frame on our benchmark screen.

## Migrating a Real Android App to Kotlin Multiplatform 1/4 -- Before the Migration

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 1/4 -- Before the Migration](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-1-4-before-the-migration-107101.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-1-4-before-the-migration-8b1d16f68747?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-10-29T17:33:38Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Android](<https://devfeed.tech/topics/android.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [bike](<https://devfeed.tech/tags/bike.md>), [browser](<https://devfeed.tech/tags/browser.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [code](<https://devfeed.tech/tags/code.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [core](<https://devfeed.tech/tags/core.md>), [dagger](<https://devfeed.tech/tags/dagger.md>), [data](<https://devfeed.tech/tags/data.md>), [domain](<https://devfeed.tech/tags/domain.md>), [feature](<https://devfeed.tech/tags/feature.md>), [ios](<https://devfeed.tech/tags/ios.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [migration](<https://devfeed.tech/tags/migration.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>)

### AI overview

BikeHub moved from native Android to Kotlin Multiplatform while keeping Android releasable at every step; about 84% of its Kotlin now lives in commonMain, with Android, iOS and WebAssembly targets. The migration benefited from early choices of KMP-compatible Ktor Client, Koin and SQLDelight, so networking, dependency injection and persistence mostly moved rather than needing replacement. Modularization provided a module-by-module migration order, limited failures to individual modules and made it practical to pause between releases. Android-specific code was pushed behind interfaces at platform boundaries, and the iOS app was kept to a thin Swift entry point and platform wiring. The author says they would add another target to CI as soon as the first module is converted, since Android-only code can compile in commonMain while still failing on other platforms; smaller, single-responsibility core modules would also have saved time.

### Source excerpt

BikeHub is KMP app that runs on Android, on iOS and in the browser via WebAssembly. It started as native Android. Around 84 percent of its Kotlin code lives in commonMain. At no point during the migration did the Android app stop being releasable. This isn't a story about a heroic rewrite. The real story is less dramatic and, I think, more useful: the migration was easier than it could have been because of choices made long before it started. How much a platform shift hurts is decided largely by architectural decisions made years earlier, often for entirely different reasons. This series isn't a KMP tutorial either. This is a case study of a real app that already had users, history and assumptions baked into its code: what moved easily, what hurt, and what I'd do differently. Part 1 covers the foundations. Where it started BikeHub is a bike maintenance tracker. It pulls your mileage from Strava, tracks wear on parts like chains, cassettes and brake pads, and tells you when something is due for a service. It is a side project, that has its own story. Initially started to try out new libraries and best practices and was for an audience of one. Later it turned into something I wanted to release to wider audiences. It started as a native Android app, split into 24 feature modules and 14 core modules (before the start of the migration). Today it has both more feature modules and more granularized core modules: Where it started Kotlin, Jetpack Compose, a layered architecture, UDF in the presentation layer, and a reasonable number of modules make it a fairly standard modern Android stack. What made the difference later wasn't how modern each piece was, but how portable it turned out to be. Choices made before the migration Ktor Client and Koin were in the app from day one, and both already supported Kotlin Multiplatform. Ktor Client is something I prefer over Retrofit, and Koin is something I prefer over Dagger. When the data and domain layers moved to shared code, the net

## Migrating A Flutter Project to Built In Kotlin

DevFeed: [Migrating A Flutter Project to Built In Kotlin](<https://devfeed.tech/articles/migrating-a-flutter-project-to-built-in-kotlin-105647.md>)

Original publisher: [Read original article](<https://medium.com/flutter-community/migrating-a-flutter-project-to-built-in-kotlin-e0e41f2ea11a?source=rss----86fb29d7cc6a---4>)

Author: tomerpacific

Published: 2026-10-28T15:42:03Z

Content type: tutorial

Language: en

Sources: [Flutter Community](<https://devfeed.tech/sources/flutter-community-medium.md>)

Topics: [Flutter](<https://devfeed.tech/topics/flutter.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Android](<https://devfeed.tech/topics/android.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [built-in](<https://devfeed.tech/tags/built-in.md>), [dart](<https://devfeed.tech/tags/dart.md>), [flutter](<https://devfeed.tech/tags/flutter.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>)

### AI overview

Migrating a Flutter project to built-in Kotlin requires Flutter 3.44 or later and, for AGP 9 support, updates to the Android build configuration. The article says to use Flutter's stable channel, upgrade Flutter, set the minimum Flutter version in pubspec.yaml, remove the applied Kotlin Android plugin from the app build file, replace kotlinOptions with the Kotlin compilerOptions block, and update gradle.properties. Android Studio Otter 3 is identified as the first version supporting AGP 9. Dependencies must also support built-in Kotlin; otherwise, the author recommends replacing them or delaying migration. A pure Dart script can inspect a project and propose edits, but changes require approval, manual steps remain, and dependency blockers may persist. Its sample report also cautions that duplicate settings.gradle files can make findings misleading.

### Source excerpt

🙌 TL;DR I created a dart script to automatically migrate your Flutter project with ease. You can find it at the bottom of this article. If your application or plugin supports Flutter version >= 3.44, then you might consider migrating it to use Built In Kotlin support. This is needed in order to support Android Gradle Plugin (AGP) versions >= 9. If you are not supporting Flutter version >= 3.44 or if your project is not currently using AGP >= 9, you don't need to do this right now, but you might want to consider it. I have undergone this migration process with one of my applications, and would like to share the process I had to go through, so you may have an easier going though it. ✋ If you have a Flutter plugin that is a pure Dart plugin (meaning no native Android code), then you don't need to do anything regarding the migration and you can leave it as is.Setting up Flutter >= 3.44 The first thing you need to do in order to migrate your application/plugin is to make sure you are on a Flutter version that supports it. That means, to upgrade your local Flutter version to at least 3.44. Before you upgrade the version, make sure you are on the stable channel in Flutter. You can do so by opening up a terminal and typing: flutter channel If the output shows you that you are on the stable channel, you can proceed to upgrade by typing: flutter upgrade This will upgrade your Flutter version to the latest one in the stable channel. After doing this, we need to also declare in our pubspec.yaml file what our minimum supported Flutter version is: environment: sdk: ^3.2.0 flutter: '>=3.44.0'Upgrading AGP >= 9 (the manual approach) To upgrade the Android Gradle Plugin version to be >= 9, you need to open the android folder of your Flutter project. Make sure you have at least Android Studio Otter 3 since that is the first version that supports AGP 9. Once you have opened the project, you can use the AGP Upgrade Assistant under the Tools menu option. Now, there are several changes you need

## Kotlin Flow: Bugs That Look Correct at First

DevFeed: [Kotlin Flow: Bugs That Look Correct at First](<https://devfeed.tech/articles/kotlin-flow-bugs-that-look-correct-at-first-105704.md>)

Original publisher: [Read original article](<https://kt.academy/article/kaustubh_flow_bugs_that_look_correct_at_first>)

Published: 2026-10-26T00:00:00Z

Content type: article

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [coroutines-flow](<https://devfeed.tech/topics/coroutines-flow.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [bugfixes](<https://devfeed.tech/topics/bugfixes.md>), [coroutine-testing](<https://devfeed.tech/topics/coroutine-testing.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>), [Exception](<https://devfeed.tech/topics/exception.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [cancellation](<https://devfeed.tech/tags/cancellation.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [collector](<https://devfeed.tech/tags/collector.md>), [collectors](<https://devfeed.tech/tags/collectors.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [database](<https://devfeed.tech/tags/database.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [exception](<https://devfeed.tech/tags/exception.md>), [exceptions](<https://devfeed.tech/tags/exceptions.md>), [execution](<https://devfeed.tech/tags/execution.md>), [flow](<https://devfeed.tech/tags/flow.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

The excerpt explains four Kotlin Flow pitfalls and how to address them. Collecting a cold flow separately for multiple consumers reruns its upstream work; use `shareIn()` when those consumers should share one collection, choosing a suitable scope and `SharingStarted` policy. `catch` handles failures upstream of its position, so move operations whose exceptions it should handle before `catch`; cancellation should generally propagate. `conflate()` may replace pending values with newer ones when a collector is slow, so use it only when intermediate values can be skipped; buffering can decouple producer and consumer, but a finite buffer may fill. Finally, `stateIn()` with `WhileSubscribed()` will not start upstream until there is a subscriber, so a test that only calls `runCurrent()` can still see the initial value. Use `Eagerly` for immediate collection or start a collector when testing subscription-driven behavior.

### Source excerpt

Four well-known Kotlin Flow bugs that look correct at first, why they happen, and how to fix them

## Part 2: Kotlin Flows -- Mastering Operators (Valves, Filters, and T-Joints)

DevFeed: [Part 2: Kotlin Flows -- Mastering Operators (Valves, Filters, and T-Joints)](<https://devfeed.tech/articles/part-2-kotlin-flows-mastering-operators-valves-filters-and-t-joints-91136.md>)

Original publisher: [Read original article](<https://proandroiddev.com/part-2-kotlin-flows-mastering-operators-valves-filters-and-t-joints-f9d7a8ebd64c?source=rss----c72404660798---4>)

Author: Sandeep Kella

Published: 2026-10-20T16:42:42Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [coroutines-flow](<https://devfeed.tech/topics/coroutines-flow.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>), [Exception](<https://devfeed.tech/topics/exception.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [collect](<https://devfeed.tech/tags/collect.md>), [data](<https://devfeed.tech/tags/data.md>), [exception](<https://devfeed.tech/tags/exception.md>), [fallback](<https://devfeed.tech/tags/fallback.md>), [filter](<https://devfeed.tech/tags/filter.md>), [flow](<https://devfeed.tech/tags/flow.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [map](<https://devfeed.tech/tags/map.md>), [network](<https://devfeed.tech/tags/network.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

Kotlin Flow operators transform, filter, and handle errors as items travel through a flow: `filter` keeps matching values, `map` converts each value, and `catch` can emit a fallback for upstream exceptions. Operators return wrapped flows; intermediate operators do not start execution, while terminal operators such as `collect` do. The article recommends keeping filtering and formatting outside UI collection code. It contrasts Flow's sequential per-item processing with List operators that create a new list in memory. Its interview examples note that `catch` does not handle errors thrown downstream in `collect`, and compare search strategies: `flatMapConcat` runs sequentially, `flatMapMerge` concurrently with potentially out-of-order results, and `flatMapLatest` cancels outdated work.

### Source excerpt

Hey again! In Part 1, we built our Air Compressor (the Flow) and pulled the trigger on our Spray Gun (the .collect() function) to start the air moving. But let's be real--if you just blast raw air straight out of a compressor, you're going to get moisture, dirt, and uneven pressure. To do a professional paint job, you need attachments on your hose. In Kotlin Flows, these attachments are called Operators. They intercept the data while it's traveling down the pipe, changing it before it ever reaches the UI (the spray gun). The Breakdown: Valves and Filters Let's look at the three most common attachments you'll put on your hose: 1. The Moisture Trap (filter) Sometimes the compressor spits out water droplets along with the air. You don't want water ruining your paint job. The filter operator acts like a screen--it only lets things pass if they meet a certain condition. // Only emit air bursts that are perfectly dry airFlow.filter { air -> air.isDry == true } 2. The Paint Mixer (map) Right now, you just have raw air. But you want blue paint. The map operator intercepts the raw air, mixes blue paint into it, and sends it further down the line. It literally transforms the data type from A to B. // Transforms RawAir into BluePaint airFlow.map { rawAir -> Paint(color = "Blue", pressure = rawAir.pressure) } 3. The Safety Release Valve (catch) What happens if the compressor explodes or a pipe bursts? In code, this is an Exception (like a network crash). If you don't have a safety valve, the explosion travels all the way to the spray gun and breaks it (your app crashes). The catch operator safely handles the explosion. airFlow .catch { exception -> println("Whoops! Pipe burst: $exception") emit(BackupAir()) // We can even emit a fallback value! } Diagrammatic Mental Model: [Compressor] ---> ( filter: keep dry ) ---> ( map: add paint ) ---> ( catch: safety ) ---> [Spray Gun] raw air dry air blue paint safe paint UI updatesUnder the Hood: What happens internally? Operators in Flow

## Part 1: Kotlin Flows -- The Air Compressor of Android (Fundamentals & Cold Streams)

DevFeed: [Part 1: Kotlin Flows -- The Air Compressor of Android (Fundamentals & Cold Streams)](<https://devfeed.tech/articles/part-1-kotlin-flows-the-air-compressor-of-android-fundamentals-cold-streams-88051.md>)

Original publisher: [Read original article](<https://proandroiddev.com/part-1-kotlin-flows-the-air-compressor-of-android-fundamentals-cold-streams-7ae94471c1d7?source=rss----c72404660798---4>)

Author: Sandeep Kella

Published: 2026-10-15T16:34:19Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Android](<https://devfeed.tech/topics/android.md>), [coroutines-flow](<https://devfeed.tech/topics/coroutines-flow.md>), [suspend function](<https://devfeed.tech/topics/suspend-function.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [backpressure](<https://devfeed.tech/tags/backpressure.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [database](<https://devfeed.tech/tags/database.md>), [delay](<https://devfeed.tech/tags/delay.md>), [flow](<https://devfeed.tech/tags/flow.md>), [generate](<https://devfeed.tech/tags/generate.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-flow](<https://devfeed.tech/tags/kotlin-flow.md>), [network](<https://devfeed.tech/tags/network.md>), [stream](<https://devfeed.tech/tags/stream.md>), [streams](<https://devfeed.tech/tags/streams.md>), [timer](<https://devfeed.tech/tags/timer.md>), [tool](<https://devfeed.tech/tags/tool.md>)

### AI overview

This tutorial introduces Kotlin Flow through an air-compressor analogy, explaining cold streams, collection, operators, cancellation, and backpressure. It also compares Flow with lists, LiveData, and RxJava, and discusses coroutine context and flowOn.

### Source excerpt

Hey! So you want to learn Kotlin Flows? Grab a seat. I know the official documentation can sometimes feel like reading a microwave manual, but I promise you, once you get the mental model right, Flows are going to be your best friend. Forget about the code for a second. Let's talk about air. The Breakdown: The Air Compressor Analogy Imagine you are painting a car using an Air Compressor and a Spray Gun. The Producer (The Compressor): This is where the air is generated. In Kotlin, this is your database, your network call, or a timer. The Flow (The Hose): This is the pipe connecting the compressor to your tool. The Operators (Valves & Filters): Maybe you have a moisture filter on the hose, or a pressure regulator. It modifies the air before it reaches you. The Consumer / Collector (The Spray Gun): This is your Android UI. Here is the most important concept to understand about a standard Kotlin Flow: It is a COLD stream. What does "Cold" mean? Imagine your air compressor is completely turned off and silent. It will not generate a single ounce of air until you pull the trigger on the spray gun. The moment you pull the trigger (in Kotlin, we call this .collect()), the compressor kicks on, air pushes through the filters, and paint comes out. When you let go of the trigger (cancel the coroutine), the whole system shuts down instantly. Diagrammatic Mental Model: Plaintext [Air Compressor] ---> (Pressure Valve) ---> (Moisture Filter) ---> [Spray Gun] (Producer) (Operator: map) (Operator: filter) (Collector) Status: DEAD SILENT until someone pulls the trigger on the Spray Gun. Let's look at how this looks in code: Kotlin // 1. The Compressor (Producer) val airFlow = flow { println("Compressor turned on!") emit("Air Burst 1") delay(1000) // Takes a second to build pressure emit("Air Burst 2") } // 2. The Trigger (Collector) // If we don't write this code below, the "Compressor turned on!" is NEVER printed. coroutineScope.launch { airFlow.collect { air -> println("Spray gun rec

## Google Summer of Code 2026 With the Kotlin Foundation: Recap

DevFeed: [Google Summer of Code 2026 With the Kotlin Foundation: Recap](<https://devfeed.tech/articles/google-summer-of-code-2026-with-the-kotlin-foundation-recap-88028.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/kotlin/2026/10/google-summer-of-code-2026-with-kotlin/>)

Author: Ksenia Shneyveys

Published: 2026-10-15T15:03:05Z

Content type: article

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>), [Kotlin](<https://devfeed.tech/sources/kotlin-a-concise-multiplatform-language-developed-by-jetbrains-the-jetbrains-blog.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [ClojureScript](<https://devfeed.tech/topics/clojurescript.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Hacktoberfest](<https://devfeed.tech/topics/hacktoberfest.md>), [V8](<https://devfeed.tech/topics/v8.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [building](<https://devfeed.tech/tags/building.md>), [database](<https://devfeed.tech/tags/database.md>), [education](<https://devfeed.tech/tags/education.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [google-summer-of-code](<https://devfeed.tech/tags/google-summer-of-code.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-wasm](<https://devfeed.tech/tags/kotlin-wasm.md>), [mentorship](<https://devfeed.tech/tags/mentorship.md>), [news](<https://devfeed.tech/tags/news.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [recap](<https://devfeed.tech/tags/recap.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [wasm](<https://devfeed.tech/tags/wasm.md>)

### AI overview

The Kotlin Foundation's 2026 Google Summer of Code program completed two projects: adding WebAssembly tail-call support to the Kotlin/Wasm backend and creating a structured, automated overview of where Kotlin is taught. The compiler work improved performance for tested recursive patterns and led to a fix in V8; the education project assembled scattered information into a reusable resource.

### Source excerpt

Google Summer of Code 2026 has wrapped up! This was the Kotlin Foundation's fourth year participating in GSoC, bringing new contributors into the Kotlin open-source ecosystem through hands-on projects and mentorship. This year, two projects successfully reached completion, tackling two areas of the ecosystem: improving recursion support in the Kotlin/Wasm backend and building a global [...]

## IntelliJ IDEA's Java and Kotlin for Cursor and VS Code Hits 1.0

DevFeed: [IntelliJ IDEA's Java and Kotlin for Cursor and VS Code Hits 1.0](<https://devfeed.tech/articles/intellij-idea-s-java-and-kotlin-for-cursor-and-vs-code-hits-1-0-88093.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/idea/2026/10/intellij-idea-s-java-and-kotlin-for-cursor-and-vs-code-hits-1-0/>)

Author: Marco Behler

Published: 2026-10-15T13:06:31Z

Content type: release

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>)

Topics: [intellij idea plugin](<https://devfeed.tech/topics/intellij-idea-plugin.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [intellij-idea](<https://devfeed.tech/tags/intellij-idea.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [lsp](<https://devfeed.tech/tags/lsp.md>), [news](<https://devfeed.tech/tags/news.md>), [release](<https://devfeed.tech/tags/release.md>), [vs-code](<https://devfeed.tech/tags/vs-code.md>)

### AI overview

JetBrains released version 1.0 of Java and Kotlin by IntelliJ IDEA, an LSP-powered extension for VS Code and Cursor. It provides language support, code analysis, navigation, refactoring, build tool integration, testing, and debugging. The release requires an IntelliJ IDEA Ultimate subscription after a 30-day trial; the article says a licensing update for purely agentic use is forthcoming.

### Source excerpt

Ten weeks ago, we opened up a preview of an LSP-powered extension that brings IntelliJ IDEA's smartness for Java and Kotlin into VS Code and Cursor. As mentioned in that blog post, this is part of a bigger initiative: moving our JVM intelligence to wherever our users are, no matter what editor or agent they [...]

## One SDK, Multiple Platforms: Introducing the Auth0 SDK for Kotlin Multiplatform

DevFeed: [One SDK, Multiple Platforms: Introducing the Auth0 SDK for Kotlin Multiplatform](<https://devfeed.tech/articles/one-sdk-multiple-platforms-introducing-the-auth0-sdk-for-kotlin-multiplatform-87154.md>)

Original publisher: [Read original article](<https://auth0.com/blog/introducing-the-auth0-sdk-for-kotlin-multiplatform/>)

Author: Prince Mathew

Published: 2026-10-14T00:00:00Z

Content type: tutorial

Language: en

Sources: [Auth0 Blog](<https://devfeed.tech/sources/auth0-blog.md>)

Topics: [Auth0](<https://devfeed.tech/topics/auth0.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [multiplatform](<https://devfeed.tech/topics/multiplatform.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [Single sign-on (SSO)](<https://devfeed.tech/topics/sso.md>), [SDK](<https://devfeed.tech/topics/sdk.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [app](<https://devfeed.tech/tags/app.md>), [auth](<https://devfeed.tech/tags/auth.md>), [auth0](<https://devfeed.tech/tags/auth0.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [encrypted](<https://devfeed.tech/tags/encrypted.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [storage](<https://devfeed.tech/tags/storage.md>), [token](<https://devfeed.tech/tags/token.md>)

### AI overview

The article introduces Auth0's Kotlin Multiplatform SDK for implementing authentication in Android and iOS apps. It explains shared login and API calls, native secure credential storage, setup, and features such as passkeys, SSO, DPoP, and configurable retries.

### Source excerpt

Add login, logout, and secure token storage to iOS and Android apps using the Auth0 Kotlin Multiplatform SDK. Simplify cross-platform auth.

## How I Built Free and Full Build Flavors for Android in my KMP codebase

DevFeed: [How I Built Free and Full Build Flavors for Android in my KMP codebase](<https://devfeed.tech/articles/how-i-built-free-and-full-build-flavors-for-android-in-my-kmp-codebase-84566.md>)

Original publisher: [Read original article](<https://proandroiddev.com/how-i-built-free-and-full-build-flavors-for-android-in-my-kmp-codebase-511bffdcc28c?source=rss----c72404660798---4>)

Author: Avik Sharma Chowdhury

Published: 2026-10-10T17:17:07Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Android](<https://devfeed.tech/topics/android.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [app](<https://devfeed.tech/tags/app.md>), [auth](<https://devfeed.tech/tags/auth.md>), [billing](<https://devfeed.tech/tags/billing.md>), [build](<https://devfeed.tech/tags/build.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [flavors](<https://devfeed.tech/tags/flavors.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The tutorial explains how an Android app built with Kotlin Multiplatform uses Gradle product flavors to create free and full variants from one codebase. Flavor-specific dependencies keep authentication, sync and payment modules, SDKs and billing permission out of the free build, while shared code uses interfaces and flavor-specific implementations. A GitHub Actions CI check guards against full-only SDKs returning to the free release build.

### Source excerpt

How I Built Free and Full Build Flavors for Android in My KMP CodebasePart 3 of my KMP series: how Android product flavors let the free version of my app leave the sign-in, sync and payment code out of the build List: Building an Exam Prep App with Kotlin Multiplatform | Curated by Avik Sharma Chowdhury | Medium In Part 1, I shared how my plan changed after completing the closed testing with MVP. I decided to launch the app for free and keep the paid features (sign-in, cloud sync and a premium subscription) ready for later. In Part 2, I walked through how the project is organized. This part is about how one codebase builds both versions: a free app with only the core features, and a full app with everything. I'll cover product flavors, how the free app leaves the premium features out, and how the shared code works with either version without knowing which one it's in. One note before we start: product flavors are an Android feature, and everything in this part is about the Android app. On iOS, I plan to release the full version, so the iOS code simply includes all the features. Why Two Builds? My first attempt was introducing a feature flag that hid the premium features. The free version still included the Auth and Payment SDKs and still asked for the billing permission, even though no one can buy anything. I wanted the free app to contain only what it uses. That meant building two different apps from the same code. Product Flavors A product flavor is Android's way of building different versions of an app from one codebase. You define flavors in Gradle, and each flavor can have its own code, resources and dependencies. https://medium.com/media/0fdcaa2efa27e84b78270d2d428385d9/href The flavors are grouped into two dimensions: environment (dev / prod): a development version and a release version. The dev build has a different app ID, so both can be installed on the same phone. distribution (free / full): which features the app includes. The free flavor has only the co

## Start Your Next KMP App With Kotlin Toolchain 0.13

DevFeed: [Start Your Next KMP App With Kotlin Toolchain 0.13](<https://devfeed.tech/articles/start-your-next-kmp-app-with-kotlin-toolchain-0-13-66857.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/kotlin/2026/10/start-your-next-kmp-app-with-kotlin-toolchain-0-13/>)

Author: Anton Makeev

Published: 2026-10-07T10:21:46Z

Content type: release

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>), [Kotlin](<https://devfeed.tech/sources/kotlin-a-concise-multiplatform-language-developed-by-jetbrains-the-jetbrains-blog.md>)

Topics: [Zig](<https://devfeed.tech/topics/zig.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [IntelliJ IDEA](<https://devfeed.tech/topics/intellij-idea.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agent-skills](<https://devfeed.tech/tags/ai-agent-skills.md>), [android](<https://devfeed.tech/tags/android.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [build](<https://devfeed.tech/tags/build.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-toolchain](<https://devfeed.tech/tags/kotlin-toolchain.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [release](<https://devfeed.tech/tags/release.md>), [releases](<https://devfeed.tech/tags/releases.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>)

### AI overview

Kotlin Toolchain 0.13 adds an interactive `kotlin new` setup flow, smoother iOS and Android environment setup, Swift Package Manager dependency support, and Kotlin/Native compiler caches. JetBrains recommends the toolchain for most new Kotlin Multiplatform projects and highlights its support for AI agent workflows.

### Source excerpt

The Kotlin Toolchain is a unified entry point into Kotlin. It lets you build JVM, Android, iOS, multiplatform, and server-side applications with a simple declarative configuration. With the release of v0.13, we now recommend the Kotlin Toolchain for most new Kotlin Multiplatform (KMP) projects. Earlier this year, we promoted the Kotlin Toolchain to Alpha. Since [...]

## Amper Is Now the Kotlin Toolchain: Moving to the Kotlin Blog

DevFeed: [Amper Is Now the Kotlin Toolchain: Moving to the Kotlin Blog](<https://devfeed.tech/articles/amper-is-now-the-kotlin-toolchain-moving-to-the-kotlin-blog-65703.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/amper/2026/10/amper-is-now-the-kotlin-toolchain-moving-to-the-kotlin-blog/>)

Author: Joffrey Bion

Published: 2026-10-06T10:14:56Z

Content type: release

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>)

Topics: [Zig](<https://devfeed.tech/topics/zig.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>)

Tags: [announcements](<https://devfeed.tech/tags/announcements.md>), [github](<https://devfeed.tech/tags/github.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [news](<https://devfeed.tech/tags/news.md>), [release](<https://devfeed.tech/tags/release.md>), [releases](<https://devfeed.tech/tags/releases.md>)

### AI overview

Amper has become Kotlin Toolchain with the release of version 0.11, which is now in Alpha. The project says future news and release announcements will move to the Kotlin Blog, while the existing blog remains online as an archive. Readers can follow updates through the Kotlin Blog or the project's GitHub releases and changelogs.

### Source excerpt

Amper has evolved into the Kotlin Toolchain, and our blog is moving along with it. This isn't a goodbye - it's a continuation With the release of Kotlin Toolchain 0.11, Amper became the Kotlin Toolchain: a single, unified entry point into Kotlin, now in Alpha. What's changing To keep Kotlin ecosystem news in one place, [...]

[Next page](<https://devfeed.tech/topics/kotlin.md?cursor=WyIyMDI2LTEwLTA2VDEwOjE0OjU2KzAwOjAwIiwgImIyMmExNWU4LTI5YzYtNGE1MS1iMmQ1LTEwMmVhYzYyMzRmNiJd>)