r/KotlinMultiplatform • • 13h ago

Checking a KMP library for breaking changes against its last published release

Post image
1 Upvotes

I make Bumpwise, an IntelliJ / Android Studio plugin that compares your library with the last version you published and flags changes that would break the people using it. Kotlin Multiplatform support went in with 1.0.5, and I'd like to hear from people who publish KMP libraries whether it's useful and where it gets things wrong.

On Maven Central, the root module of a KMP library has no classes, only Gradle module metadata pointing at one module per target. Bumpwise follows that to the JVM target (`<artifact>-jvm`, or the Android one if there's no JVM target) and compares its bytecode with your `jvmMain` build.

What it catches:

- Signature changes that break binary compatibility. Add a parameter with a default value to a public function and callers' source still compiles, but code compiled against the old version fails with `NoSuchMethodError`.

- Removed or renamed public API.

- A target the last release published that your project no longer builds (say you drop `js` or `iosArm64`). Users on that target can't upgrade, so it's reported as MAJOR.

Tools → Check API Compatibility also tells you whether the next release is MAJOR, MINOR or PATCH and drafts the changelog.

What it doesn't do yet: code in `commonMain` and the other targets is only checked through the JVM target's bytecode, so a change that only affects iOS or JS isn't seen. Warnings while you type show up in `jvmMain` files; for `commonMain`, run the full check.

The same check runs in a terminal or CI with the free command line (`bumpwise check`, Java 17+); the screenshot is from that, on a small sample library. In the IDE, Kotlin needs the paid Team edition (30-day free trial). It's closed source, and I built it with a lot of help from AI coding agents.

Plugin: https://plugins.jetbrains.com/plugin/35935-bumpwise

Command line: https://gilware.com/bumpwise/cli/


r/KotlinMultiplatform • • 1d ago

Testing a KMP app on an iPad without a Mac, is it possible?

3 Upvotes

Hi everyone,

I want to start building a mobile app with Kotlin Multiplatform (KMP), targeting both Android and iOS. I haven't decided yet whether I'll use Compose Multiplatform for the UI or go with a native UI on each platform. I'm open to both.

I have an Android phone and an iPad, but I don't have a Mac.

Android is no problem. On the iOS side, I'd like to be able to install and run the app on my iPad during development, so I can test it as I go. I'm not talking about publishing to the App Store, that's not something I care about right now. I just want to test my app on a real iOS device while I'm coding.

Have any of you been in this situation? How did you handle it?

Thanks in advance!


r/KotlinMultiplatform • • 1d ago

From Idea to TestFlight: Building a Kotlin Multiplatform App With an AI Agent

0 Upvotes

r/KotlinMultiplatform • • 2d ago

PS1 cd games animation

8 Upvotes

r/KotlinMultiplatform • • 2d ago

iOS app to TestFlight in 1 command (zero Fastlane)

Thumbnail reddit.com
1 Upvotes

r/KotlinMultiplatform • • 3d ago

One Compose Multiplatform codebase on Android, iPhone, iPad and the browser: what tripped me up shipping a word game

6 Upvotes

I have just finished taking a small word game, WordEke, from an Android-only Kotlin and Jetpack Compose app to the same code running on Android, iOS, iPadOS and the web. It is in both stores and playable in a browser, so here are the parts that were not in the tutorials. Kotlin 2.3.21, Compose Multiplatform 1.11.1.

How it is laid out

•     core: a Kotlin Multiplatform module with no Android dependencies. All the game logic is in commonMain: board generation, dictionaries, scoring, the tap-selection state machine. Its tests run on the JVM with no emulator, which was the reason for the split long before iOS came up.

•     shared: the whole UI in Compose Multiplatform, targeting android, iosArm64, iosSimulatorArm64, wasmJs and js.

•     What the UI needs from a platform is one interface plus a handful of expect functions. Billing, sharing, the camera and notifications sit behind it.

•     The iOS app is an Xcode shell with a single SwiftUI file that shows the shared view controller.

1. Kotlin/Wasm does not run on an iPad that stops at iPadOS 17

Kotlin/Wasm needs WebAssembly garbage collection and exception handling. Safari gained them in 18.2, and every browser on an iPhone or iPad is Safari underneath. Several iPads from 2017 and 2018 end at iPadOS 17, so for their owners the page sat on "Loading" forever, with no error. Two players reported it before I understood why.

The fix was to build the game twice from the same source. I added a js target beside wasmJs and moved the web code into a source set the two share. Nothing in it had to change: the js() interop, promises and the settings storage compile for both. The page validates a small probe module, loads the Wasm build where that passes, and the JavaScript build elsewhere, and gives a failed Wasm start one try at JavaScript. Both builds keep their data in the same localStorage, so an iPad that later updates keeps its games.

Cost: one more script of about 4 MB, compressed to about 1 MB, that current browsers never download. The JavaScript build still uses Skia's .wasm, which only requires 2017-era WebAssembly.

2. Long-lived caching and fixed file names nearly bricked returning players

My server caches .js for years. The generated script had a fixed name and referred to .wasm files named by content. A deploy that replaced the folder deleted the old .wasm files, so a phone running the previous script requested files that no longer existed and hung. Reloading did not help, because the stale script was the thing being cached.

Two changes: the scripts are now named by content as well, and a deploy adds to the folder instead of replacing it, with old builds pruned after a month. That is also why I did not use Compose's own compatibility distribution for the Wasm and JavaScript pair: it does the same job but assigns fixed names to the scripts.

3. Lowering the iOS minimum

I had set the minimum to iOS 18.5 because that made a linker warning go away. Skia's ICU data object inside the framework is built for 18.5, and with a lower target the linker says it "was built for newer iOS version than being linked". I never tested a lower target, so the high minimum only hid the warning. Dropping to 17.0 brought it back.

The object holds data, not code. The build succeeds, the tests pass and the app runs on current simulators. But the current Xcode won't download any iOS 17 simulator for me, so the app on iOS 17 itself is still untested: a real device on 17 will be the test, and a refurbished 2018 iPad is on its way for exactly that. If text, dates or prices come out wrong there, the ICU data is my first suspect.

4. iPad is a one-way door

Once a released version supports iPad, Apple does not allow a later update to drop support for it, and the first submission requires 13-inch iPad screenshots. On iPad, the window can also be resized, so the layout has to cope with sizes a phone never has.

What I would do again

•     Keep the game logic in a pure Kotlin module from day one. Moving it to commonMain was the easy part because it never knew about Android.

•     Put every platform need behind one interface early. Each new target then has an obvious list of things to implement.

•     Test the web build on the oldest Safari you can find, not only in Chromium.

The game is free with no ads, and the browser version needs no install or account, so you can see the result at https://wordeke.com (the store links are there too).

Happy to answer questions about any of it. I would particularly like to hear from anyone who has found a cleaner way to serve Wasm with a JavaScript fallback.

Updates and feedback on the game itself: r/wordeke


r/KotlinMultiplatform • • 3d ago

DevView Library

4 Upvotes

Hi everyone! I wanted to share DevView, a Kotlin Multiplatform library that adds a developer overlay to your Android and iOS apps.

It brings a few debugging tools directly into the app:

- Toggle feature flags and override remote-config values.

- Inspect analytics events as you navigate.

- Mock API responses from OpenAPI specs through a Ktor plugin.

- View console logs on the device.

- Record and restore the current screen’s state with TimeCapsule.

You register only the modules you need, and you can add your own tools. It’s built with Compose Multiplatform, available on Maven Central, and open source under Apache 2.0.

If you’re working on a KMP app, try adding one module to your debug build. I’d love feedback on the setup and which tools would be useful in your day-to-day work.

Docs and setup: https://worldline.github.io/devview/


r/KotlinMultiplatform • • 5d ago

Another postmortem story of taking KMP into use in Solo project

Thumbnail clothie.app
5 Upvotes

I'm a solo developer and recently took KMP into use. The overall process took me around 4 months. Here's my four cents,

  • Where it all started: Around 80%+ of potential app users demanded an iPhone version.

  • The Strategy: I'm a Java developer by heart and Kotlin was my choice in the first place. Avoided learning Swift by leveraging Kotlin Multiplatform (KMP) and Compose Multiplatform (CMP), backed by a low-risk $0 hardware baseline (used Mac/iPhone) and a brief expert iOS architecture consultation.

  • Refactoring: Spent two weeks ruthlessly modularizing code (splitting into app, feature, and core layers) because KMP brutally punishes tight platform coupling.

  • Accelerated UI porting by feeding feature modules into LLMs, resulting in an "illusion of speed" where hollow state flows and broken layout measurements required a manual, screen-by-screen rewrite.

  • The Payoff: Achieved ~85-95% code sharing, zero context-switching between languages, and the operational leverage of a two-platform team as a solo builder. I'm ok with XCode although Android Studio with relevant plugins deals the same.

I pushed the whole story here,

https://clothie.app/blog/post.html?slug=how-a-solo-developer-traded-android


r/KotlinMultiplatform • • 5d ago

Using Jetpack AppState (alpha) with an MVI library: what worked, and what I found out about StateStore along the way

0 Upvotes

Google released Jetpack AppState at the end of October: transform runs a @Composable block in a headless composition and gives you Compose State outside the UI, and StateStore is a keyed container for sharing state between activities, services and widgets. It's alpha, but I wanted to see how it fits an MVI architecture, so I added experimental support to Kide, my Kotlin Multiplatform MVI + Clean Architecture library.

Sharing the design and a few things I learned, since they apply to anyone trying AppState.

The design decision: AppState feeds state in, it doesn't replace the loop

A transform result is conflated. If several inputs change before the block recomposes, you get the latest value only. That's fine for "what is the current state of X", and wrong for intents, reducers and side effects, where order and exactly-once delivery matter.

So Kide doesn't make the reducer composable. Instead there's one small bridge: transformFlow { } turns a headless composition into a cold Flow, and the processor's existing observe collects it.

@OptIn(ExperimentalKideAppStateApi::class)
class SearchProcessor(
    private val savedProjects: SavedProjectsProcessor,
    private val connectivity: ConnectivityService,   // val isOnline: State<Boolean>
) : PresentationProcessor<SearchIntent, SearchViewState, SearchSideEffect>(SearchViewState()) {

    init {
        observe("connectivity", transformFlow {
            if (connectivity.isOnline.value) {
                null
            } else {
                val saved by savedProjects.stateFlow.collectAsState()
                saved.projects.size
            }
        }) { savedCountWhileOffline ->
            reduce { copy(offlineSavedCount = savedCountWhileOffline) }
        }
    }
}

Compose State and Flow are read the same way inside the block, and dependencies are tracked by what the block actually reads: while the device is online, the saved projects aren't tracked at all. The result still enters the ViewState through reduce, so interceptors, traces and tests see it like any other change.

The other direction: domain state into a StateStore

A second module mirrors a use-case processor's state into a StateStore key, so a widget, a service or another activity can read it as Compose State:

savedProjects.mirrorTo(stateStore, SavedProjectsKey, applicationScope)

// With a persisted key, restore goes through an intent, so it's a normal, traced change:
savedProjects.mirrorTo(stateStore, SavedProjectsKey, applicationScope) { persisted ->
    RestoreSavedProjects(persisted)
}

The mirror is one-way: the processor stays the only writer.

Things I found by testing AppState 1.0.0-alpha02

These aren't in the docs as far as I can tell. They're observations from my tests, and it's an alpha, so they may well change:

  • StateStore.updateState isn't atomic. 80,000 concurrent increments from 8 coroutines left me with roughly 32,000 to 40,000.

  • First access to a key isn't thread-safe. If one thread calls getState while another creates the key with setState, the reader can end up holding a State that never updates. In my probe that happened in about 4 to 5% of attempts.

  • At start-up, disk wins. With the DataStore integration, a write made before or right after syncToDataStore starts is replaced by the persisted value, and I found no signal that loading has finished.

  • statestore-datastore is Android-only in alpha02, even though statestore and transform are multiplatform.

  • Headless composition works fine on a plain JVM with no UI toolkit present, and AppState didn't force a Compose runtime upgrade next to Compose Multiplatform 1.12.

The practical upshot for me: treat a StateStore key as single-writer, create it once at application start, and don't use it as the source of truth for anything that needs ordering.

Status of Kide

Support for AppState API in Kide is experimental, and deliberately kept away from the stable library:

  • two separate artifacts, kide-appstate and kide-clean-architecture-appstate, at 2.4.0-alpha02

  • every declaration needs an explicit opt-in

  • Android and JVM only for now; iOS and Web wait for the AppState beta

  • no existing Kide module depends on them, so nothing changes if you don't add them

Repo, with the design proposal and the test code behind the findings above: https://github.com/Fuusio/kide

I'd like to hear from anyone else experimenting with AppState, especially if you've approached the "composable presenter vs. feeding a reducer" question differently, or seen different StateStore behaviour.


r/KotlinMultiplatform • • 8d ago

I built Kotensor: A pure-Kotlin Transformer engine for JVM & Android (autograd, INT4/INT8, zero JNI)

4 Upvotes

Hi!,

I built Kotensor, a lightweight machine learning and generative Transformer engine written in pure Kotlin for the JVM and Android.

Most LLM runtimes on the JVM or mobile depend on heavy C++ libraries (llama.cpp, ONNX Runtime) wrapped with JNI bindings. That introduces ABI splits, toolchain friction, and native crashes. Kotensor implements the whole stack natively in Kotlin with only the Kotlin standard library as a runtime dependency.

Key Capabilities:

  • Architecture: Pre-norm Transformer blocks, SwiGLU, RMSNorm, RoPE with Llama 3 scaling, and grouped-query attention (GQA).

  • Fast Autoregressive Decoding: Pre-allocated KV cache with an allocation-free decode step.

  • Tiled & Vectorized MatMul: Cache-blocked matrix multiplication optimized for HotSpot C2 auto-vectorization (~24 GFLOP/s per thread on AVX-512) scheduled over a ForkJoinPool, plus an optional JDK 17+ Vector API (SIMD) backend.

  • Quantization: Group-wise INT8 and INT4 weight-only quantization with an on-the-fly dequantizing matmul. Models can be memory-mapped directly from storage so weights never bloat the Java heap.

  • Training & Fine-Tuning: Reverse-mode autograd, AdamW, loss masking (IGNORE_INDEX), fused projection + cross-entropy, and on-device LoRA / QLoRA adapters.

  • Hugging Face Interop: Natively parses config.json, byte-level BPE tokenizer.json (GPT-2, Qwen 2.5, SmolLM, Llama 3), and .safetensors checkpoints (F32, F16, BF16).

Quick Example:

val dir = File("SmolLM2-135M")
val model = HuggingFaceModelLoader.load(dir, Quantization.INT8)
val tokenizer = HuggingFaceModelLoader.loadTokenizer(dir)

model.generateStream("The capital of Mexico is", tokenizer, maxTokens = 32) { token ->
    print(token)
}

The library is published on Maven Central as io.github.tspstudio:kotensor:1.2.0 (requires Java 17+ / Android API 24+).

Would love any feedback on the architecture, performance, or use cases!

This is my first ML project and I'm thrilled to finally have something to show my work for. Much love,
tsuper <3


r/KotlinMultiplatform • • 8d ago

Looking for 12 Testers for My Open-Source Android App – KMP Instaloader 🚀

Thumbnail
reddit.com
0 Upvotes

r/KotlinMultiplatform • • 10d ago

# Seeking feedback: agentic architecture and agent harness for a mobile app with KMP shared logic, legacy UIKit/Android Views, and new SwiftUI/Compose UI

0 Upvotes

Hi everyone,

I’m working on a mobile application that contains both a legacy codebase and a newer Kotlin Multiplatform (KMP) architecture. I’m looking for feedback from people who have already introduced an agentic architecture or AI-assisted development workflows into a similar mobile project.

## Current architecture

- **Legacy part:**
- Legacy UI is implemented with UIKit on iOS and classic Android Views / XML layouts on Android.
- Legacy services are implemented natively in Swift for iOS and Kotlin for Android.

- **New KMP part:**
- Business logic, use cases, repositories, data sources, and ViewModels are shared in Kotlin Multiplatform.

- **New UI layer:**
- New screens are implemented with SwiftUI on iOS and Jetpack Compose on Android.
- Both platforms consume the shared KMP ViewModels.

So, the shared KMP layer covers domain/business logic through to the ViewModel, while the UI remains native on each platform. The legacy screens remain in UIKit on iOS and Android Views on Android, while new screens use SwiftUI and Compose.

## What I want to introduce

I want to introduce an **agentic architecture** to support development, code review, documentation, testing, and the progressive migration of legacy code into KMP.

I have access to both **GitHub Copilot** and **Claude**, and I’m looking for best practices to build a proper **agent harness** around them, rather than using them only as chat-based coding assistants.

By “agent harness”, I mean the surrounding system that makes agents reliable and useful in a real codebase:

- Structured project context and documentation
- Architecture rules and coding conventions
- Controlled access to repositories, files, and tools
- MCP integrations where relevant
- Task planning, delegation, and validation
- Test execution, static analysis, and review gates
- Guardrails around legacy UIKit and Android Views code
- Observability, feedback loops, and human approval for critical changes

The goal is not necessarily to create a fully autonomous agent that modifies the repository without supervision. I’m looking for a practical, controlled setup where agents can support analysis, planning, implementation, testing, documentation, and progressive migration, while developers remain responsible for architectural decisions, critical reviews, and production-facing changes.

## Questions

  1. How would you structure the agents?
    - One orchestrator agent plus specialised agents?
    - Domain-specific agents?
    - MCP tools?
    - Or a simpler deterministic workflow with AI-assisted steps?

  2. How would you design an agent harness using GitHub Copilot and Claude in a mobile KMP project?
    - Which responsibilities should be given to Copilot versus Claude?
    - Should Claude be used as the orchestrator/planner and Copilot for IDE-native implementation?
    - What MCP servers, tools, permissions, and validation steps would you expose?
    - How would you structure prompts, rules files, project documentation, and task workflows?
    - How would you prevent agents from modifying critical legacy UIKit or Android Views code without approval?

  3. What project context should be exposed to the agents?
    - Architecture documentation
    - KMP module map
    - Coding conventions
    - Legacy service inventory
    - Legacy UI inventory
    - API contracts
    - Test strategy
    - CI/CD information
    - ADRs / technical decision records

  4. For the legacy native Swift/Kotlin services and UIKit/Android Views screens, what strategy would you recommend?
    - Create an adapter layer in KMP
    - Expose legacy services through interfaces/ports
    - Migrate use cases progressively
    - Keep some services or screens native on purpose
    - Treat legacy UI as a protected area with stricter review rules

  5. What guardrails would you put in place?
    - Mandatory tests
    - Static analysis
    - Human review
    - Limited write permissions
    - Protected legacy areas
    - Approval gates before changes

  6. Has anyone used AI agents in a multi-module mobile repository with KMP, Xcode, Gradle, CI/CD, UIKit, Android Views, SwiftUI, and Compose?
    - What worked well?
    - What failed?
    - What would you do differently?

## My initial idea

I’m thinking of starting with a progressive approach:

- Create a structured project context: architecture docs, conventions, module map, migration rules, legacy inventory, and UI inventory.
- Define specialised agents:
- Architecture agent
- KMP/Kotlin agent
- iOS/SwiftUI agent
- Android/Compose agent
- Legacy iOS/UIKit agent
- Legacy Android/Views agent
- Testing agent
- Code review agent
- Documentation agent
- Use an orchestrator that receives a task, creates a plan, delegates work, and validates the result.
- Add guardrails: mandatory tests, static analysis, human approval, and restricted access to critical legacy code.

My assumption is that agents should not have unrestricted access to the whole repository from day one. They should work within a clearly defined scope, use verifiable tools, and follow repeatable workflows.

Any feedback, real-world experience, architecture examples, tooling recommendations, or pitfalls to avoid would be greatly appreciated.

Thanks!


r/KotlinMultiplatform • • 10d ago

Kotlean: write Android apps in Lean

Thumbnail
github.com
1 Upvotes

r/KotlinMultiplatform • • 12d ago

YAAN: An open-source, local-first AI assistant built with Kotlin Multiplatform & Compose Multiplatform

1 Upvotes

Hi r/Kotlin!

I wanted to share a real-world multiplatform project I recently open-sourced: **YAAN** (Your Autonomous Action Navigator).

🔗 Repository: https://github.com/developmentwithyash/yaan

### Architecture Highlights:

- **Compose Multiplatform:** Shared UI running across Android and Desktop JVM.

- **Crypto & DB:** AES-GCM encryption abstracted via `expect/actual` across Android Keystore and JVM crypto; SQLite persistence with clean driver factories.

- **State Management:** Reactive MVI-style state flows using pure Kotlin Coroutines and StateFlow.

- **Test Suite:** 465 passing unit tests running on Ubuntu CI via GitHub Actions.

- **Desktop Target:** Run instantly with `./gradlew :composeApp:run`.

Contributions, code reviews, and feedback on our multiplatform patterns are very welcome!


r/KotlinMultiplatform • • 12d ago

Phovo: a self-hosted photo backup app written entirely in Kotlin Multiplatform

Thumbnail reddit.com
3 Upvotes

r/KotlinMultiplatform • • 14d ago

Mac Android File transer.

Thumbnail
github.com
6 Upvotes

Hi everyone,
I am using mac and andorid and struggling to transfer files between them.

There are certian options but those are paid ones. So I built this a free and open source using Kotlin Multiplatform.

It uses ABD or MTP for transer and works seemlesly.

Only just it is not registered with Apple so cannot have trusted keys or cannot publish it to Apple store ( also I donot want to pay money).

It has all setup steps mentioned. And support drag and drop normal as Finder.

Please try it and share some feedback.


r/KotlinMultiplatform • • 14d ago

在 KMP Desktop 中为 macOS 打包和签名本地 .dylib 依赖项

1 Upvotes

在为 macOS 开发 KMP Desktop 应用时,我遇到了一些关于在 JAR 中打包本地 `.dylib` 依赖项的问题,特别是在动态库加载和代码签名方面。

经过一些调试和对 Gradle 构建脚本及 Mach-O 二进制文件的调整,我让它工作起来了。以下是我发现有用的三件事:

* 在代码签名之前提取本地库: 我在签名之前将 JAR 中的 `.dylib` 文件提取到了应用捆绑中。这样每个本地库都可以作为单独的 Mach-O 二进制文件进行签名。

* 修复 u/rpath 和库查找: 默认的库路径在开发环境之外不可靠。我使用 `install_name_tool` 更新库ID和依赖项引用以使用 u/loader_path,并在需要的地方添加 `LC_RPATH` 条目。

* 处理库名称不匹配: 一些本地依赖项期待特定的库名称,如 `_nolapack` 或带版本的文件名如 `.1.22.dylib`。我没有复制大型二进制文件,而是使用 `install_name_tool -change` 更新依赖项引用和符号链接(`ln -sf`)在需要的地方。

分享这些内容,以防其他人在为 macOS 上的 KMP Desktop 应用打包 JNI 本地库时遇到类似的问题。


r/KotlinMultiplatform • • 17d ago

Found a way to run gradle on musl-based systems

Thumbnail elisoli.fly.dev
0 Upvotes

r/KotlinMultiplatform • • 17d ago

I built AspectK – AOP for Android and Kotlin Multiplatform, an alternative to AspectJ

Thumbnail gallery
1 Upvotes

r/KotlinMultiplatform • • 17d ago

Bringing Amplitude Analytics to Kotlin Multiplatform (KMP)

Thumbnail
reddit.com
0 Upvotes

r/KotlinMultiplatform • • 18d ago

I built a gallery app for Compose Multiplatform components: live previews, tweakable parameters, full source

5 Upvotes

​

Glaze runs each component live, lets you change its parameters with sliders, and shows the full Kotlin source split by file, plus setup steps for Android and iOS.

Four components so far:

  • Morph Text — one word dissolves into the next using blur and a colour-matrix threshold

  • Firebase Auth — email/password, anonymous, Google on Android and Apple on iOS, behind one shared AuthService

  • Multiplatform Settings — SharedPreferences and NSUserDefaults behind one expect/actual factory

  • Android ProGuard — R8 setup with keep rules for Compose, Kotlin Serialization, Firebase Auth and Multiplatform Settings

It’s on Google Play now; iOS is in progress. Happy to answer questions on any of the implementations, and I’d like to know which components you’d want next.

https://play.google.com/store/apps/details?id=org.lightscout.candybox&referrer=utm_source%3Dreddit%26utm_medium%3Dsocial%26utm_campaign%3Dlaunch

Update: the component sources are now on GitHub under Apache 2.0, the same files the app shows in its Code tab. https://github.com/lightScout/glaze-components


r/KotlinMultiplatform • • 19d ago

how to specify a port in the WASM run configuration

Post image
6 Upvotes

I want to know how to specify a port in the WASM run configuration using the Kotlin Toolchain in IntelliJ IDEA.

It works fine when I run ./kotlin run --module webApp --port 8081 from the terminal,

but I can't figure out how to set it up in the run configuration settings.


r/KotlinMultiplatform • • 20d ago

I built a phone-call horror game in Kotlin (Compose Wasm + desktop): an LLM plays the caller, plain Kotlin decides what's true

Thumbnail
reddit.com
1 Upvotes

r/KotlinMultiplatform • • 22d ago

Lessons from shipping a live-streaming app on Android, iOS and web with Kotlin Multiplatform + Compose Multiplatform

Thumbnail reddit.com
2 Upvotes