Skip to main content
The --required-deps command displays the Gradle dependencies required for Lumo UI components to work in your project.

​
Syntax

./gradlew lumo --required-deps

​
What It Does

The command:
  1. Reads your lumo.properties configuration
  2. Checks if you’re using Kotlin Multiplatform
  3. Displays the appropriate dependency list for your project type
  4. Formats dependencies ready to copy into build.gradle.kts

​
Output for Android Projects

For standard Android projects (KotlinMultiplatform=false or not set): 
The plugin requires the following dependencies to your build.gradle.kts file:
api(platform("androidx.compose:compose-bom:2024.12.01"))
api("androidx.compose.foundation:foundation")
api("androidx.compose.foundation:foundation-layout")
api("androidx.compose.ui:ui")
api("androidx.compose.ui:ui-tooling")
api("androidx.compose.ui:ui-tooling-preview")
api("androidx.compose.ui:ui-util")
api("androidx.compose.material:material-ripple:1.7.6")
Note: Ignore this message if you have already added the dependencies.

​
Output for Kotlin Multiplatform Projects

For Kotlin Multiplatform projects (KotlinMultiplatform=true): 
The plugin requires the following dependencies to your build.gradle.kts file:
api("compose.runtime")
api("compose.foundation")
api("compose.material3")
api("compose.ui")
Note: Ignore this message if you have already added the dependencies.

​
Current Versions

The plugin uses these dependency versions:
​
Compose BOM
version
2024.12.01 - For Android projects
​
Material Ripple
version
1.7.6 - For Android projects
​
Compose Multiplatform
version
Uses the versions configured in your KMP project

​
Adding Dependencies to Your Project

​
Android Project

Add the dependencies to your app module’s build.gradle.kts:
build.gradle.kts
dependencies {
    // Lumo UI required dependencies
    api(platform("androidx.compose:compose-bom:2024.12.01"))
    api("androidx.compose.foundation:foundation")
    api("androidx.compose.foundation:foundation-layout")
    api("androidx.compose.ui:ui")
    api("androidx.compose.ui:ui-tooling")
    api("androidx.compose.ui:ui-tooling-preview")
    api("androidx.compose.ui:ui-util")
    api("androidx.compose.material:material-ripple:1.7.6")
    
    // Your other dependencies
    // ...
}

​
Kotlin Multiplatform Project

Add to your shared module’s build.gradle.kts:
build.gradle.kts
kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                // Lumo UI required dependencies
                api(compose.runtime)
                api(compose.foundation)
                api(compose.material3)
                api(compose.ui)
                
                // Your other dependencies
                // ...
            }
        }
    }
}
For Kotlin Multiplatform, ensure you have the Compose Multiplatform plugin configured in your project.

​
Prerequisites

This command requires lumo.properties to exist and be properly configured.
You must run ./gradlew lumo --init before using this command.

​
When to Use

Use this command:
  • During initial setup - After running --init, before --setup
  • When dependencies change - If plugin updates require new dependencies
  • For new team members - To quickly see required dependencies
  • When troubleshooting - To verify you have all required dependencies

​
Why api Configuration?

The plugin uses api instead of implementation because:
Generated components need to expose Compose types
Your app code will use Compose APIs from generated components
Ensures dependency transitivity for proper compilation
If you prefer implementation, you can change it after copying, but you may need to add some dependencies explicitly to your app module.

​
Dependency Details

The compose-bom manages versions of all Compose libraries, ensuring compatibility.
api(platform("androidx.compose:compose-bom:2024.12.01"))
When you use the BOM, you don’t need to specify versions for individual Compose libraries.
Core Compose functionality:
  • foundation - Basic building blocks
  • foundation-layout - Layout components (Column, Row, Box, etc.)
UI rendering and tooling:
  • ui - Core UI primitives
  • ui-tooling - Preview and inspection tools
  • ui-tooling-preview - Preview annotations
  • ui-util - Utility functions
Provides ripple effects for Material Design components:
api("androidx.compose.material:material-ripple:1.7.6")
Required for interactive components like buttons and cards.

​
Error Cases

Configuration Not Found
The plugin is not setup. Run the plugin with --init to get started.
Solution: Run ./gradlew lumo --init first.
Missing Configuration Properties
Missing required configs in lumo.properties. Expected: [ThemeName, ComponentsDir, PackageName].
Solution: Ensure lumo.properties has all required properties.

​
Verification

After adding dependencies, verify they’re properly configured: 
# Sync Gradle
./gradlew --refresh-dependencies

# Test setup
./gradlew lumo --setup
If setup succeeds, your dependencies are correctly configured.

​
Updating Dependencies

The Lumo plugin specifies dependency versions. To use different versions:
  1. Check compatibility - Ensure your versions are compatible with Lumo components
  2. Update build.gradle.kts - Change version numbers after copying
  3. Test thoroughly - Verify components still work correctly
// Example: Using a newer Compose BOM
api(platform("androidx.compose:compose-bom:2025.01.00"))
Using different versions may cause compatibility issues. Test thoroughly when deviating from recommended versions.

​
Alternative Configurations

You can also use implementation if your project structure allows: 
dependencies {
    implementation(platform("androidx.compose:compose-bom:2024.12.01"))
    implementation("androidx.compose.foundation:foundation")
    // ... etc
}
However, you may need to add explicit dependencies in modules that use the generated components.

​
Next Steps

After adding dependencies:
  1. Sync your project - Let Gradle download the dependencies
  2. Run setup - Use ./gradlew lumo --setup to generate theme
  3. Add components - Start adding UI components with --add or --add-all
# Complete workflow
./gradlew lumo --init
# Edit lumo.properties
./gradlew lumo --required-deps
# Copy dependencies to build.gradle.kts
./gradlew --refresh-dependencies
./gradlew lumo --setup
./gradlew lumo --add Button
Bookmark this command for quick reference when setting up Lumo UI in new projects or helping team members with setup.

Build docs developers (and LLMs) love

Get started for freeTalk to us