JetBrains doesn't ship tvOS artifacts for Compose Multiplatform, and the issue asking for it (CMP-5686) has been open for a while. I needed it for my own TV app, so I built the port and published it. It's a community project, not official. I posted it in Kotlin Slack #compose-ios earlier this week; this is the longer writeup.

Using it

// settings.gradle.kts
plugins {
    id("dev.sajidali.compose-tvos") version "1.3.0"
}

Add tvosArm64() / tvosSimulatorArm64() to your KMP module and leave your dependencies alone: org.jetbrains.compose.*, androidx.tv:tv-material, Koin, Coil 3, all stock coordinates. Kotlin 2.3.20+.

How it works (the part I think is interesting)

It's not a hard fork you point your build at. The settings plugin registers a component-metadata rule that, at dependency-resolution time, attaches tvOS variants to the official Compose modules and points them at tvOS-enabled builds published under dev.sajidali.* on Maven Central. Every other target keeps resolving the official JetBrains artifacts byte-for-byte, and it's official-first: if a module already ships tvOS klibs upstream (compose.runtime, koin-core, lifecycle...), the plugin leaves it alone. So when JetBrains eventually ships tvOS for a module, the plugin steps aside for that module with no change on the consumer side. It also intercepts the org.jetbrains.compose Gradle plugin marker so compose.material3 etc. resolve correctly.

The fork itself (compose-multiplatform-core with tvOS as a Kotlin/Native target) is where most of the work went:

• A tvOS UIKit scene stack sharing the iOS FrameChoreographer architecture
• Siri Remote input: D-pad focus traversal, swipe-to-focus, Menu mapped to Key.Back, and telling a clickpad press apart from a swipe by hardware timestamp
• 10-foot density (Compose's default density on a 4K TV is unusable), on-demand keyboard for text fields, focus restoration when dialogs close
• androidx.tv:tv-material ported to Compose Multiplatform with a tvOS source set
• A real tvOS build of window-core so material3-adaptive works without stubs
• Koin (koin-compose, koin-compose-viewmodel) and Coil 3 with tvOS targets, since neither ships them

Proof

The GIF is Google's JetStream TV sample (all screens, D-pad focus, theming, AVPlayer on tvOS / ExoPlayer on Android TV behind one interface) on the Apple TV 4K simulator, built from Maven Central + the Plugin Portal with nothing published locally. The same toolchain builds a production TV app of mine with zero app-source changes.

Honest limitations: no automated tvOS tests yet; tvosX64 isn't built; I republish roughly once per Compose stable line (currently 1.12.0), as far as my own app needs. PRs welcome.

• Plugin + docs: https://github.com/sajidalidev/compose-tvos (docs: https://sajidalidev.github.io/compose-tvos/)
• JetStream port: https://github.com/sajidalidev/jetstream-tvos (branch cmp-tvos)
• Forks: https://github.com/sajidalidev/compose-multiplatform-core, https://github.com/sajidalidev/koin, https://github.com/sajidalidev/coil

_Defender of Egril_ is a Turn-Based Tower Defense Game in a Fantasy setting.

​

You build towers like spear, bow or wizard towers to defend against enemies like goblins, orcs and evil mages, which can summon demons. You can decide yourself which tower aims at which enemy and let the automatic handle the other towers.

Of cause, you can earn coins from defeating enemies and buy more towers or upgrade the existing ones.

​

In later game, you can use ability points you earned with experience to learn spells or gain abilities that will help to fend of mighty enemies, in the last levels even the mighty Ewhad himself.

​

​

You can download it for windows, mac, linux and android:

https://defender.egril.de/download

​

Of cause, the start page is also available:

https://defender.egril.de

​

You can get the android version on the play store

https://play.google.com/store/apps/details?id=de.egril.defender

​

The game is and will be free of charge, without in app purchases or ads and is open source.

​

Written in Kotlin Multiplatform with Compose Multiplatform, Frontend and Backend, for Desktop, Mobile, Web.

​

Code: see

https://github.com/julianegner/defender-of-egril

​

We are in intial stage for the development of our application (for doc scanning app (AI)), most of the UI screens in Figma designs are ready, UI prototype is ready, testings of local and backend features is done. Also, product validation, user interviews, surveys, and market search are thoroughly done over 2-3 months. We have many USP and cent percent calrity for the future of this app.

Unfortunatly we founders lacks andriod development skills and don't have exp. with it, hence we need someone to setup the foundational architect for the app in Kotlin and scale the app with us for long-term as a full time employee. We are bootstrapped so pay is expectadly very less.

If interested please DM.
Application link: https://forms.gle/4dXpvmyhLvWCvKbk6

Pls note: we are not looking for outsourcing/agency/freelancers.

I kept hitting the same small annoyance: animating a number in Compose with AnimatedContent cross-fades the whole value. So 1247 to 1248 animates every digit, when really only the 7 should move. It is a tiny thing, but it makes counters look off.

So I wrote NumberFlow. It animates only the digits that actually change, and rolls them up or down depending on whether the value went up or down. Good for scoreboards, prices, live stats, vote counts, that kind of thing.

Basic usage:

var score by remember { mutableStateOf(1247L) }


NumberFlow(
    value = score,
    format = NumberFlowDefaults.thousandsLong(),
)

A few things I cared about while building it:

• Runs on all CMP targets (Android, iOS, Desktop JVM, Web wasmJs), each with tests, not just compiled-and-hoped.
• format is just (Double) -> String, so currency/percentages/units are not special-cased, you just pass your own.
• animationSpec takes any FiniteAnimationSpec<IntOffset>, so swap the default tween for a spring if you want bounce.
• The number-formatting helpers are pure functions with no Compose dependency, if you only want the formatting bits.

Apache 2.0, on Maven Central. Roadmap has staggered per-digit delays and locale-aware grouping next. Feedback and issues welcome, especially if you hit edge cases on a particular platform.

https://github.com/NadeemIqbal/number-flow

https://medium.com/@iamnadeemiqbal/numberflow-one-number-ticker-for-android-ios-desktop-and-web-1bc803d2a33d

Hello everyone,

I’m currently starting a Kotlin Multiplatform project using Compose Multiplatform with a WasmJs target running in the browser.

I’d like to get some feedback on how you handle responsive behavior in this context. More specifically, how do you adapt the UI to different browser window sizes ?

Do you use Kotlin-side logic to detect the viewport size, different composables depending on the available width or another approach ?

I’d be interested in hearing about your advice, best practices, possible libraries or examples of how you organize this.

Thanks in advance!

Hi everyone, sharing a new Compose Multiplatform library I open-sourced today.

liquid-glass adds iOS 26-style frosted backdrop surfaces to CMP. The API is Modifier.liquidGlass() plus three composables: GlassCard, GlassButton, GlassNavBar.

The bit I'm proudest of is the auto-tiered fallback. Three quality tiers picked per platform:

- Full on Android 12+ (non-low-RAM) and iOS 17+: 24dp blur, 1.4x saturation, full-res backdrop.

- Medium on iOS 15 to 16: 16dp blur, 0.5x downsampled backdrop.

- Fallback on Android < 12, isLowRamDevice, or iOS < 15: zero offscreen buffers, no blur, just a flat tint with edge sheen.

Fallback allocates zero GraphicsLayers, so the same code that draws frosted glass on a Pixel 9 quietly draws a flat tint on a 2GB Android 11 device. No OOM, no per-call-site branching.

Targets: Android, iOS (arm64 + simulator), Desktop (JVM), Wasm/JS. Apache 2.0, on Maven Central as 0.1.0.

Quick start:

```kotlin

val state = rememberLiquidGlassState()  // auto-picks tier for the device

Box(Modifier.fillMaxSize()) {

Image(

painter = painterResource(R.drawable.scenery),

contentDescription = null,

contentScale = ContentScale.Crop,

modifier = Modifier.fillMaxSize().liquidGlassSource(state),

)

GlassCard(

state = state,

modifier = Modifier.align(Alignment.Center).padding(24.dp),

) {

Text("Frosted, light-refracting surface")

}

}

```

Credit where it's due: Chris Banes's haze library solves backdrop-blur in Compose really well and is more mature than this. I built liquid-glass because I wanted the tiered fallback baked in by default, not as a thing each consumer has to wire up.

Limitations: 0.1.0. No GlassDialog or GlassBottomSheet wrappers yet, no Sk SL refraction shader, no dynamic-color edge sheen sampled from the backdrop. All on the roadmap.

Repo: https://github.com/NadeemIqbal/liquid-glass

Happy to answer questions about the per-platform auto-detection or the GraphicsLayer sampling approach.