CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-compose-multiplatform

Declarative framework for sharing UIs across multiple platforms with Kotlin, including Gradle plugin, component libraries, and web support

—

Pending
Overview
Eval results
Files

gradle-plugin.mddocs/

Gradle Plugin

The Compose Multiplatform Gradle plugin provides build system integration and dependency management for Compose projects. It configures compilation for different platforms, manages dependencies, handles resource processing, and provides application packaging for desktop platforms.

Capabilities

Plugin Application

Apply the Compose plugin to enable multiplatform Compose development.

// In build.gradle.kts
plugins {
    id("org.jetbrains.compose") version "1.8.2"
}

// Repository setup
repositories {
    jetbrainsCompose() // Extension function that adds JetBrains Compose repository
}

Compose Extension

Root configuration extension for the plugin.

/**
 * Root extension for configuring Compose plugin
 */
abstract class ComposeExtension {
    abstract val desktop: DesktopExtension
    abstract val resources: ResourcesExtension
    abstract val web: WebExtension
    abstract val android: AndroidExtension
    abstract val dependencies: Dependencies
    
    @Deprecated("Use Kotlin Multiplatform plugin configuration")
    abstract val kotlinCompilerPlugin: Property<String?>
    
    @Deprecated("Use Kotlin Multiplatform plugin configuration")
    abstract val kotlinCompilerPluginArgs: ListProperty<String>
}

Desktop Application Configuration

Configure desktop applications with packaging and distribution options.

/**
 * Desktop extension for configuring desktop applications
 */
abstract class DesktopExtension {
    abstract val application: JvmApplication
    abstract val nativeApplication: NativeApplication
    
    fun application(configure: Action<JvmApplication>)
    fun nativeApplication(configure: Action<NativeApplication>)
}

/**
 * JVM application configuration for desktop apps
 */
abstract class JvmApplication {
    /** Main class for the application */
    abstract var mainClass: String?
    
    /** Main JAR file property */
    abstract val mainJar: RegularFileProperty
    
    /** Java installation path */
    abstract var javaHome: String
    
    /** Application command line arguments */
    abstract val args: MutableList<String>
    
    /** JVM command line arguments */
    abstract val jvmArgs: MutableList<String>
    
    /** Distribution configuration */
    abstract val nativeDistributions: JvmApplicationDistributions
    
    /** Build types configuration */
    abstract val buildTypes: JvmApplicationBuildTypes
    
    /** Configure from source set or Kotlin target */
    fun from(from: SourceSet)
    fun from(from: KotlinTarget)
    
    /** Disable default configuration */
    fun disableDefaultConfiguration()
    
    /** Add task dependencies */
    fun dependsOn(vararg tasks: Task)
    fun dependsOn(vararg tasks: String)
    
    /** Configure from files */
    fun fromFiles(vararg files: Any)
    
    /** Set application arguments */
    fun args(vararg args: String)
    
    /** Set JVM arguments */
    fun jvmArgs(vararg jvmArgs: String)
    
    /** Configure distributions */
    fun nativeDistributions(configure: Action<JvmApplicationDistributions>)
    
    /** Configure build types */
    fun buildTypes(configure: Action<JvmApplicationBuildTypes>)
}

Usage Example:

compose {
    desktop {
        application {
            mainClass = "com.example.MainKt"
            
            args("--debug", "--config=prod")
            jvmArgs("-Xmx2G", "-Dfile.encoding=UTF-8")
            
            nativeDistributions {
                targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
                packageName = "MyApplication"
                packageVersion = "1.0.0"
                description = "My Compose Desktop Application"
                vendor = "Example Corp"
                
                macOS {
                    bundleID = "com.example.myapp"
                    signing {
                        sign.set(true)
                        identity.set("Developer ID Application: Example Corp")
                    }
                }
                
                windows {
                    console = false
                    shortcut = true
                    menu = true
                }
                
                linux {
                    shortcut = true
                    packageName = "my-application"
                    appCategory = "Utility"
                }
            }
            
            buildTypes {
                release {
                    proguard {
                        isEnabled.set(true)
                        obfuscate.set(true)
                        optimize.set(true)
                    }
                }
            }
        }
    }
}

Distribution Configuration

Configure application packaging and distribution for different platforms.

/**
 * Distribution configuration for JVM applications
 */
abstract class JvmApplicationDistributions : AbstractDistributions {
    /** Runtime modules to include */
    abstract val modules: ArrayList<String>
    
    /** Include all runtime modules */
    abstract var includeAllModules: Boolean
    
    /** Linux platform settings */
    abstract val linux: LinuxPlatformSettings
    
    /** macOS platform settings */
    abstract val macOS: JvmMacOSPlatformSettings  
    
    /** Windows platform settings */
    abstract val windows: WindowsPlatformSettings
    
    /** Set target distribution formats */
    fun targetFormats(vararg formats: TargetFormat)
    
    /** Add runtime modules */
    fun modules(vararg modules: String)
    
    /** Configure Linux settings */
    fun linux(configure: Action<LinuxPlatformSettings>)
    
    /** Configure macOS settings */
    fun macOS(configure: Action<JvmMacOSPlatformSettings>)
    
    /** Configure Windows settings */
    fun windows(configure: Action<WindowsPlatformSettings>)
    
    /** Configure file associations for all platforms */
    fun fileAssociation(
        mimeType: String,
        extension: String, 
        description: String,
        iconFile: File? = null
    )
}

/**
 * Available distribution formats
 */
enum class TargetFormat {
    /** Application image (cross-platform) */
    AppImage,
    /** Debian package (Linux) */
    Deb,
    /** RPM package (Linux) */
    Rpm, 
    /** Disk image (macOS) */
    Dmg,
    /** Package installer (macOS) */
    Pkg,
    /** Executable installer (Windows) */
    Exe,
    /** MSI installer (Windows) */
    Msi;
    
    /** Check if format is compatible with current OS */
    val isCompatibleWithCurrentOS: Boolean
    
    /** Output directory name for the format */
    val outputDirName: String
    
    /** File extension for the format */
    val fileExt: String
}

Platform-Specific Settings

Configure platform-specific packaging options.

/**
 * Linux platform settings
 */
abstract class LinuxPlatformSettings : AbstractPlatformSettings {
    /** Create desktop shortcut */
    abstract var shortcut: Boolean
    
    /** Linux package name (may differ from main package name) */
    abstract var packageName: String?
    
    /** Application release version */
    abstract var appRelease: String?
    
    /** Application category for app stores */
    abstract var appCategory: String?
    
    /** Debian package maintainer */
    abstract var debMaintainer: String?
    
    /** Menu group for application menu */
    abstract var menuGroup: String?
    
    /** RPM license type */
    abstract var rpmLicenseType: String?
    
    /** Debian package version */
    abstract var debPackageVersion: String? 
    
    /** RPM package version */
    abstract var rpmPackageVersion: String?
}

/**
 * Windows platform settings
 */
abstract class WindowsPlatformSettings : AbstractPlatformSettings {
    /** Show console window */
    abstract var console: Boolean
    
    /** Show directory chooser during installation */
    abstract var dirChooser: Boolean
    
    /** Per-user installation instead of system-wide */
    abstract var perUserInstall: Boolean
    
    /** Create desktop shortcut */
    abstract var shortcut: Boolean
    
    /** Create start menu entry */
    abstract var menu: Boolean
    
    /** Start menu group */
    abstract var menuGroup: String?
    
    /** UUID for upgrade identification */
    abstract var upgradeUuid: String?
    
    /** MSI package version */
    abstract var msiPackageVersion: String?
    
    /** EXE package version */
    abstract var exePackageVersion: String?
}

/**
 * macOS platform settings
 */
abstract class JvmMacOSPlatformSettings : AbstractMacOSPlatformSettings {
    /** Application name in dock */
    abstract var dockName: String?
    
    /** Use package name as dock name */
    abstract var setDockNameSameAsPackageName: Boolean
    
    /** App Store compatibility mode */
    abstract var appStore: Boolean
    
    /** Entitlements file for code signing */
    abstract val entitlementsFile: RegularFileProperty
    
    /** Runtime entitlements file */
    abstract val runtimeEntitlementsFile: RegularFileProperty
    
    /** PKG package version */
    abstract var pkgPackageVersion: String?
    
    /** PKG build version */
    abstract var pkgPackageBuildVersion: String?
    
    /** Provisioning profile for distribution */
    abstract val provisioningProfile: RegularFileProperty
    
    /** Runtime provisioning profile */
    abstract val runtimeProvisioningProfile: RegularFileProperty
    
    /** Info.plist settings */
    abstract val infoPlistSettings: InfoPlistSettings
    
    /** Configure Info.plist */
    fun infoPlist(configure: Action<InfoPlistSettings>)
}

ProGuard Configuration

Configure code obfuscation and optimization for release builds.

/**
 * ProGuard settings for code obfuscation and optimization
 */
abstract class ProguardSettings {
    /** ProGuard version to use */
    abstract val version: Property<String> // default: "7.7.0"
    
    /** Maximum heap size for ProGuard */
    abstract val maxHeapSize: Property<String?>
    
    /** ProGuard configuration files */
    abstract val configurationFiles: ConfigurableFileCollection
    
    /** Enable ProGuard processing */
    abstract val isEnabled: Property<Boolean> // default: false
    
    /** Enable code obfuscation */
    abstract val obfuscate: Property<Boolean> // default: false
    
    /** Enable bytecode optimization */
    abstract val optimize: Property<Boolean> // default: true
    
    /** Join output JARs into single file */
    abstract val joinOutputJars: Property<Boolean> // default: false
}

Resources Configuration

Configure resource generation and processing.

/**
 * Configuration for Compose Resources
 */
abstract class ResourcesExtension {
    /** Whether generated resources class should be public */
    abstract var publicResClass: Boolean // default: false
    
    /** Package for generated Res class */
    abstract var packageOfResClass: String
    
    /** Name of generated resources class */
    abstract var nameOfResClass: String // default: "Res"
    
    /** Resource class generation mode */
    abstract var generateResClass: ResourceClassGeneration
    
    /** Associate custom resource directory with source set */
    fun customDirectory(
        sourceSetName: String,
        directoryProvider: Provider<Directory>
    )
}

/**
 * Resource class generation modes
 */
enum class ResourceClassGeneration {
    /** Generate based on project configuration */
    Auto,
    /** Always generate resources class */
    Always,
    /** Never generate resources class */
    Never
}

Dependency Management

Access Compose library dependencies through the plugin.

/**
 * Provides access to Compose library dependencies
 */
abstract class Dependencies {
    /** Desktop-specific dependencies */
    abstract val desktop: DesktopDependencies
    
    // Core Compose libraries
    abstract val animation: String
    abstract val animationGraphics: String
    abstract val foundation: String
    abstract val material: String
    abstract val material3: String
    abstract val runtime: String
    abstract val runtimeSaveable: String
    abstract val ui: String
    abstract val uiTest: String
    abstract val uiTooling: String
    abstract val uiUtil: String
    abstract val preview: String
    abstract val materialIconsExtended: String
    
    /** Component libraries */
    abstract val components: CommonComponentsDependencies
    
    /** HTML/Web libraries */
    abstract val html: HtmlDependencies
}

/**
 * Desktop-specific dependencies
 */
object DesktopDependencies {
    /** Desktop components */
    val components: DesktopComponentsDependencies
    
    /** Common desktop dependency */
    val common: String
    
    /** Current OS dependency (automatically selected) */
    val currentOs: String
    
    // Platform-specific dependencies
    val linux_x64: String
    val linux_arm64: String
    val windows_x64: String
    val windows_arm64: String
    val macos_x64: String
    val macos_arm64: String
    
    /** Desktop UI testing */
    val uiTestJUnit4: String
}

Extension Functions

Utility functions for dependency and repository management.

/**
 * Add JetBrains Compose repository
 */
fun RepositoryHandler.jetbrainsCompose(): MavenArtifactRepository

/**
 * Helper functions for adding Compose dependencies
 */
fun KotlinDependencyHandler.compose(groupWithArtifact: String): String
fun DependencyHandler.compose(groupWithArtifact: String): String

Annotations

/**
 * Marks experimental Compose library APIs
 */
@RequiresOptIn
annotation class ExperimentalComposeLibrary

Install with Tessl CLI

npx tessl i tessl/maven-compose-multiplatform

docs

component-libraries.md

gradle-plugin.md

html-web.md

index.md

tile.json