To model tvOS in a Compose Multiplatform fork, declare separate device and simulator targets, share code through the source sets that feed those targets, and isolate fork-specific build logic from upstream-oriented files. Maintainers can either build and maintain the source fork themselves or use a community Gradle settings plugin that redirects eligible dependencies to tvOS-enabled artifacts. These are different levels of control, not equivalent forms of official support.
What targets and source sets do
A Kotlin Multiplatform target represents a compilation platform. A source set groups source files, dependencies, and compiler options for code compiled for one or more targets. Kotlin’s project-structure documentation uses tvosArm64 for a tvOS device target and tvosSimulatorArm64 for a tvOS simulator target, and describes tvosMain as an intermediate source set the two can share. Kotlin Multiplatform project structure
As an Amazon Associate I earn from qualifying purchases.
This distinction helps decide where code belongs: put platform-neutral logic in common source sets, code shared by relevant Apple targets in an appropriate Apple intermediate set, and tvOS-specific code in a tvOS source set. Code that depends on device- or simulator-specific APIs may need to live lower in the hierarchy.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Declare the device and simulator separately
A fork intended to build for both Apple TV hardware and the simulator needs both targets. The following is a conceptual target declaration, not a complete project configuration:
kotlin {
tvosArm64()
tvosSimulatorArm64()
}With both targets declared, the intended sharing structure can be represented as:
commonMainfor platform-neutral code.- An Apple shared layer, when appropriate for the project’s declared targets.
tvosMainfor code shared by the tvOS device and simulator targets.tvosArm64MainandtvosSimulatorArm64Mainfor code specific to each target.
This is a conceptual hierarchy, not a promise that every project creates these exact source sets automatically. The actual hierarchy depends on the targets declared and Kotlin Gradle plugin conventions or configuration. Because device and simulator are distinct targets, a successful simulator build alone does not establish that the device target builds.
Keep fork build logic separate from upstream-oriented files
The JetBrains Compose Multiplatform Core repository illustrates one way to separate fork configuration: it has settings-fork.gradle and build-fork.gradle alongside its other build files. The settings file references fork-specific settings scripts under buildSrc-fork, uses gradle/libs-fork.versions.toml, and changes the default version-catalog extension name. JetBrains Compose Multiplatform Core: settings-fork.gradle
Recommended Free Tools
Its fork build file applies root project plugins and uses fork-specific repository setup. Together, the files show how that repository keeps fork-related settings and build behavior distinct from upstream-oriented configuration. JetBrains Compose Multiplatform Core: build-fork.gradle
buildSrc-fork is a convention of this repository, not a required Gradle directory or a standard Compose Multiplatform feature. The repository’s settings also make clear that its scripts rely on assumptions about that project’s structure. Treat its file names and selection mechanics as repository-specific; check the wrapper tasks and instructions for the branch you intend to build rather than assuming a universal command.
Choose between maintaining a source fork and redirecting dependencies
A source fork gives maintainers direct access to the build and modules they need to adapt. A community settings plugin instead offers a consumer-side route: its README describes substituting eligible dependencies with published tvOS-enabled alternatives. The choice depends on whether the needed work fits the plugin’s coverage and configuration surface or requires changes inside the underlying source.
Rank #4
- 264 Pages
- Includes 78 Songs
- Composer: Various
- Softcover
| Decision | Build and maintain a source fork | Consume redirected tvOS artifacts |
|---|---|---|
| Control | Can change fork build logic and modules directly. | Uses the plugin’s published coverage and configuration surface. |
| Maintenance | Requires keeping fork build files and source changes aligned with upstream. | Requires tracking plugin, Kotlin, Compose, and artifact-version compatibility. |
| Dependency coverage | Can add platform work in source where needed. | Limited to compatible tvOS variants and explicit plugin mappings. |
| Packaging | Controls its own build and output path. | Follows the plugin’s documented framework and resources packaging behavior. |
This comparison describes practical implications of the two approaches, not measured differences in build speed, cost, or reliability.
Free tools Windows power users keep installed
One-click scans. No signup required.
What the community plugin documents
The compose-tvos README describes applying its plugin in settings.gradle.kts, declaring tvosArm64() and tvosSimulatorArm64() in a consumer module, and substituting eligible modules with fork-published tvOS artifacts. It also documents interception of org.jetbrains.compose plugin resolution for fork-specific Compose Resources packaging, remote version mapping, and an “official first” approach when upstream variants exist. These are claims about that community plugin and its artifact ecosystem, not guarantees from JetBrains.
Best Value
The README’s stated requirements include Gradle 8.0 or later, Kotlin 2.3.20 or later for consumer projects targeting tvOS, and JetBrains Compose Multiplatform 1.6 or later. Its supported-module matrix and version mappings are specific to the plugin and can change. The README’s quickstart and displayed matrix can reflect different release states, so check the release and mapping information for the version you plan to use rather than treating an undated example as a current compatibility guarantee.
The plugin README also describes building a Kotlin framework for each tvOS target and a particular Compose Resources bundle nesting expected by its tvOS resource reader. Those details apply to the plugin’s documented packaging path; they should not be assumed for every fork or upstream build.
Know where official support stands
In the repository overview checked on 7 October 2026, Compose Multiplatform is presented for iOS, Android, desktop, and beta web; tvOS is not listed among those documented targets. The community plugin presents its tvOS variants as a way to cover cases where upstream artifacts are unavailable. This is a snapshot of those sources, not a guarantee that official support status will remain unchanged. Compose Multiplatform repository overview
Kotlin’s quickstart says Apple-platform development requires a macOS machine with Xcode installed and directs developers to launch Xcode for initial tool setup. That guidance establishes the Apple tooling prerequisite, but the quickstart focuses on iOS and does not provide a tvOS-specific local setup recipe. Kotlin Multiplatform quickstart
Quick Recap
Practical decision checklist
- Choose a source fork if you need to modify modules or build logic beyond what published variants cover, and can maintain the divergence from upstream.
- Consider dependency redirection if the plugin explicitly covers the modules you need and its current version mapping fits your Kotlin, Compose, and Gradle setup.
- Declare both tvOS targets when both device and simulator builds matter, and keep shared code in source sets that actually feed both.
- Use macOS and Xcode for Apple-platform development, while verifying tvOS-specific requirements for your chosen toolchain and build path.
- Check the relevant repository branch or plugin release documentation for current compatibility and invocation details before adopting either path.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
