Kotlin

https://kotlinlang.org/docs/
Admin
Kotlin is a modern, statically-typed programming language that runs on the JVM and supports...
Tokens:950,075
Snippets:7,912
Trust Score:9.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### Start Junie CLI

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-spm-migration-ai.html

Starts the Junie CLI for initial setup, authentication with a JetBrains account, or configuration of an external LLM.

```shell
junie
```

--------------------------------

### Multi-project directory structure example

Source: https://kotlinlang.org/docs/dokka-gradle.html

Example folder structure illustrating parent and child projects for documentation aggregation.

```text
.
└── parentProject/
    ├── childProjectA/
    │   └── demo/
    │       └── ChildProjectAClass.kt
    └── childProjectB/
        └── demo/
            └── ChildProjectBClass.kt

```

--------------------------------

### Install Kotlin Toolchain CLI on Windows

Source: https://kotlinlang.org/docs/multiplatform/kotlin-toolchain.html

Installs the Kotlin Toolchain CLI on Windows by executing the installation script in PowerShell.

```powershell
powershell -ExecutionPolicy ByPass -c "irm 'https://kotl.in/install.ps1' | iex"
```

--------------------------------

### Install Kotlin Toolchain CLI using SDKMAN!

Source: https://kotlinlang.org/docs/multiplatform/kotlin-toolchain.html

Installs the Kotlin Toolchain CLI tool using SDKMAN!.

```shell
sdk install kotlintoolchain
```

--------------------------------

### Install Kotlin compiler using Snap

Source: https://kotlinlang.org/docs/command-line.html

Installs the Kotlin command-line compiler as a classic Snap package on Ubuntu 16.04 or later.

```bash
sudo snap install --classic kotlin
```

--------------------------------

### Install Kotlin Toolchain CLI on macOS or Linux

Source: https://kotlinlang.org/docs/multiplatform/kotlin-toolchain.html

Installs the Kotlin Toolchain CLI via the shell installer script and refreshes the shell session to make the command available.

```bash
curl -fsSL https://kotl.in/install.sh | sh

# Restart your terminal or run this command
# to make 'kotlin' available
exec $SHELL
```

--------------------------------

### Start Koin in MainApplication.kt

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-ktor-sqldelight.html

Initialize Koin with the Android context and pass `appModule` to `startKoin` in the `onCreate` method of `MainApplication`.

```kotlin
package com.jetbrains.spacetutorial

import android.app.Application
import org.koin.android.ext.koin.androidContext
import org.koin.core.context.GlobalContext.startKoin

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        startKoin {
            androidContext(this@MainApplication)
            modules(appModule)
        }
    }
}
```

--------------------------------

### Run kapt CLI with options example

Source: https://kotlinlang.org/docs/kapt.html

Pass kapt options such as mode, output paths, and processor classpath to the CLI tool.

```shell
kapt -Kapt-mode=stubsAndApt \
  -Kapt-sources=build/kapt/sources \
  -Kapt-classes=build/kapt/classes \
  -Kapt-stubs=build/kapt/stubs \
  -Kapt-classpath=lib/ap.jar \
  -Kapt-classpath=lib/anotherAp.jar \
  src/main/kotlin
```

--------------------------------

### StringGen configuration example

Source: https://kotlinlang.org/docs/lincheck-argument-generation-constraints.html

Shows generated string combinations for a StringGen configuration specifying max word length and alphabet.

```text
"2:abc" -> [
    "a", "b", "c",
    "aa", "bb", "cc",
    "ab", "bc", "ac",
    "ba", "cb", "ca"
]
```

--------------------------------

### Install ki shell with Homebrew on macOS

Source: https://kotlinlang.org/docs/run-code-snippets.html

Installs the ki shell utility on macOS using Homebrew. Once installed, start the shell by running ki in the terminal.

```shell
brew install ki
```

--------------------------------

### Set up Desktop entry point using application and Window

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-entry-points.html

Launches the desktop JVM application window and renders the common App() composable. Configures window properties and specifies ::exitApplication as the onCloseRequest callback.

```kotlin
fun main() = application {
    Window(
        onCloseRequest = ::exitApplication,
        title = "ComposeDemo"
    ) {
        App()
    }
}
```

--------------------------------

### Set up Web entry point using ComposeViewport

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-entry-points.html

Initializes the web Compose environment and mounts the common App() composable. Requires opting into the ExperimentalComposeUiApi annotation.

```kotlin
// The web API is experimental and requires opt-in
@OptIn(ExperimentalComposeUiApi::class)
fun main() {
    // Sets up the Compose environment for the web app
    ComposeViewport {
        // Produces the UI layout
        App()
    }
}
```

--------------------------------

### Clone the intro-coroutines tutorial project repository

Source: https://kotlinlang.org/docs/coroutines-and-channels.html

Clones the intro-coroutines project template repository from GitHub to begin the tutorial.

```bash
git clone https://github.com/kotlin-hands-on/intro-coroutines
```

--------------------------------

### Track coroutines and print hierarchy with DebugProbes

Source: https://kotlinlang.org/docs/coroutines-debugging.html

Installs the debug agent at runtime and prints active coroutines alongside a specific Job hierarchy using DebugProbes. Note that dynamically loading the agent using install() may produce a warning starting with JDK 21.

```kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.debug.*
import kotlin.time.Duration.Companion.seconds

private suspend fun loadAccount() {
    delay(5.seconds)
}

private suspend fun loadPreferences() {
    delay(5.seconds)
}

private suspend fun loadUserProfile() = coroutineScope {
    launch { loadAccount() }
    launch { loadPreferences() }
}

@OptIn(ExperimentalCoroutinesApi::class)
fun main() {
    // Installs the debug agent
    // This is only required if you don't use the -javaagent VM option
    DebugProbes.install()

    runBlocking {
        // Starts a coroutine with two child coroutines
        val loadingJob = launch {
            loadUserProfile()
        }

        // Gives the child coroutines time to suspend
        delay(1.seconds)

        // Prints all active coroutines
        DebugProbes.dumpCoroutines()

        println("============")

        // Prints the loading job and its child coroutines
        DebugProbes.printJob(loadingJob)
    }
}
```

```text
Debug mode example output {...}
```

--------------------------------

### Create hello.kt stub file for C interop

Source: https://kotlinlang.org/docs/mapping-primitive-data-types-from-c.html

Define the main entry point referencing functions imported from the C interop package. Requires opting in to ExperimentalForeignApi.

```kotlin
import interop.*
import kotlinx.cinterop.ExperimentalForeignApi

@OptIn(ExperimentalForeignApi::class)
fun main() {
    println("Hello Kotlin/Native!")

    ints(/* fix me*/)
    uints(/* fix me*/)
    doubles(/* fix me*/)
}
```

--------------------------------

### Example Maven Central user token configuration

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-publish-libraries.html

Generated by the Central Portal website on the Setup Token-Based Authentication page. Maven Central does not store these credentials, so new ones must be generated if lost.

```xml
<server>
    <id>${server}</id>
    <username>l2nfaPmz</username>
    <password>gh9jT9XfnGtUngWTZwTu/8141keYdmQpipqLPRKeDLTh</password>
</server>
```

--------------------------------

### Configure composite GitHub Action in .github/actions/gradle-setup/action.yml

Source: https://kotlinlang.org/docs/multiplatform/github-actions-for-kmp.html

Defines a reusable composite GitHub Action to synchronize Java and Gradle setup across CI jobs. It installs Java 17 (Temurin distribution) and configures Gradle.

```yaml
name: gradle-setup
description: Setup Java and Gradle
runs:
  using: "composite"
  steps:
    - name: Setup Java
      uses: actions/setup-java@v4.0.0
      with:
        java-version: "17"
        distribution: "temurin"
    - name: Setup Gradle
      uses: gradle/actions/setup-gradle@v5.0.0
```

--------------------------------

### Initialize output container and input in main

Source: https://kotlinlang.org/docs/js-get-started.html

Sets up both the text output container and the input listener within main().

```kotlin
fun main() {
    // Creates a text container for our output
    // Replace val message = Message(topic = "Kotlin/JS", content = "Hello!")
    val output = document.body?.appendTextContainer()

    // Reads the input value
    document.body?.appendInput(onChange = { println(it) })
}
```

--------------------------------

### Install CocoaPods with Homebrew

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Installs CocoaPods using Homebrew. Homebrew installations can lead to compatibility issues if the bundled Xcodeproj gem does not yet support the installed Xcode version.

```bash
brew install cocoapods
```

--------------------------------

### Install Ruby and CocoaPods with RVM

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Installs a specific Ruby version using RVM and then installs CocoaPods to `/usr/local/bin`.

```bash
rvm install ruby 4.0.6
```

```bash
sudo gem install -n /usr/local/bin cocoapods
```

--------------------------------

### Configure compose.desktop distribution in desktopApp/build.gradle.kts

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-project-recommended-structure.html

Set up desktop packaging targets, main class entry point, package name, and version in the desktopApp build script.

```kotlin
compose.desktop {
    application {
        mainClass = "compose.project.demo.MainKt"

        nativeDistributions {
            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
            packageName = "compose.project.demo"
            packageVersion = "1.0.0"
        }
    }
}
```

--------------------------------

### Complete Example5.kt implementation placeholder

Source: https://kotlinlang.org/docs/async-programming.html

Placeholder reference for the full Example5.kt source file representing the complete suspending function reminder application.

```text
Complete Example5.kt file {...}
```

--------------------------------

### Install Junie CLI

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-spm-migration-ai.html

Run this command in the terminal to download and install the Junie CLI using the official installation script.

```shell
curl -fsSL https://junie.jetbrains.com/install.sh | bash
```

--------------------------------

### Configure Desktop App for Hot Reload in main.kt, App.kt, and Greeting.kt

Source: https://kotlinlang.org/docs/multiplatform/compose-hot-reload.html

Configure the desktop window with alwaysOnTop enabled to view live updates during edits. Wire the Button composable in App.kt to Greeting().greet() and define the greet() function in Greeting.kt to observe instant UI updates when saving files.

```kotlin
fun main() = application {
    Window(
        onCloseRequest = ::exitApplication,
        alwaysOnTop = true,
        title = "composedemo",
    ) {
        App()
    }
}
```

```kotlin
Button(onClick = { showContent = !showContent }) {
    Column {
        Text(Greeting().greet())
    }
}
```

```kotlin
fun greet(): String {
    return "Hello!"
}
```

--------------------------------

### Install Ruby and CocoaPods with rbenv

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Installs a specific Ruby version via rbenv, configures it globally or locally, and installs CocoaPods to `/usr/local/bin`.

```bash
rbenv install 4.0.6
```

```bash
rbenv global 4.0.6
```

```bash
sudo gem install -n /usr/local/bin cocoapods
```

--------------------------------

### Create a basic Kotlin/JS entry point in App.kt

Source: https://kotlinlang.org/docs/running-kotlin-js.html

Defines a sample main function that prints a message to the console. Place this in src/jsMain/kotlin/App.kt to provide an executable entry point.

```kotlin
fun main() {
    console.log("Hello, Kotlin/JS!")
}
```

--------------------------------

### Install CocoaPods with default macOS Ruby

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Installs CocoaPods using the default macOS Ruby. This installation method does not work on Apple silicon (M chips).

```bash
sudo gem install cocoapods
```

--------------------------------

### Start full GPG key pair generation with gpg --full-generate-key

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-publish-libraries.html

Initiates the interactive GPG key pair creation wizard from the command line.

```shell
gpg --full-generate-key
```

--------------------------------

### Install GnuPG using Homebrew

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-publish-libraries.html

Installs the gpg tool on macOS using the Homebrew package manager.

```shell
brew install gpg
```

--------------------------------

### Install Kotlin compiler using Homebrew

Source: https://kotlinlang.org/docs/command-line.html

Updates Homebrew and installs the Kotlin command-line compiler on macOS.

```bash
brew update
brew install kotlin
```

--------------------------------

### Configure basic desktop application in build.gradle.kts

Source: https://kotlinlang.org/docs/multiplatform/compose-native-distribution.html

Sets up the desktop application configuration block in build.gradle.kts. Specifies the main entry point class for packaging and running the application.

```kotlin
compose.desktop { application { mainClass = {...}
```

--------------------------------

### Create entry point in hello.kt

Source: https://kotlinlang.org/docs/native-get-started.html

Defines the main entry point function for the application. Place this source file inside the src/nativeMain/kotlin directory.

```kotlin
fun main() {
    println("Hello, Kotlin/Native!")
}
```

--------------------------------

### Run compiled Kotlin/Native binary on Windows

Source: https://kotlinlang.org/docs/native-get-started.html

Execute the compiled hello.exe binary from the command line on Windows.

```shell
./hello.exe
```

--------------------------------

### Add GET request in requests.http

Source: https://kotlinlang.org/docs/jvm-spring-boot-add-db-support.html

Defines an HTTP GET request template in requests.http to retrieve a message by its identifier.

```http
### Get the message by its id
GET http://localhost:8080/id
```

--------------------------------

### Set up Android entry point with ComponentActivity and setContent

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-entry-points.html

Calls the common App() composable inside MainActivity's setContent block. Enables edge-to-edge display and initializes platform-specific Android activity configuration.

```kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge()
        super.onCreate(savedInstanceState)

        setContent {
            // Calling the common App() composable
            App()
        }
    }
}
```

--------------------------------

### Search documents via GET request to /kotlin/docs

Source: https://kotlinlang.org/docs/spring-ai-guide.html

Send a GET request in the terminal to search the loaded documents after ingestion is complete.

```bash
curl -X GET http://localhost:8080/kotlin/docs
```

--------------------------------

### Set up iOS entry point with ComposeUIViewController

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-entry-points.html

Creates a ComposeUIViewController that hosts the shared App() composable for iOS integration. Acts as the iOS equivalent of an Android activity.

```kotlin
fun MainViewController() = ComposeUIViewController { App() }
```

--------------------------------

### Update Rbenv, RubyGems, and installed gems

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Sequential steps to pull the latest Rbenv repository, update RubyGems, and upgrade all installed gems.

```bash
cd ~/.rbenv
git pull

```

```bash
gem update --system

```

```bash
gem update

```

--------------------------------

### Execute actions before Flow emission with onStart

Source: https://kotlinlang.org/docs/coroutines-flow-operators.html

Demonstrates listening to the start of flow collection using .onStart(), including a custom extension implementation of the operator.

```kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.TimeSource

// A simplified custom version of the default .onStart() operator
fun <T> Flow<T>.myOnStart(
    action: suspend FlowCollector<T>.() -> Unit
): Flow<T> = flow {
    this@flow.action()
    this@myOnStart.collect(this@flow)
}

suspend fun main() {
    withContext(Dispatchers.Default) {
        flowOf("Page 1", "Page 2", "Page 3").onStart {
            println("Processing pages!")
        }.onEach {
            println("Emitted $it")
        }.collect {
            println("Collected $it")
        }
    }
}
```

--------------------------------

### Send GET request with specific message id

Source: https://kotlinlang.org/docs/jvm-spring-boot-add-db-support.html

Executes an HTTP GET request using a specific message UUID retrieved from previous responses.

```http
### Get the message by its id
GET http://localhost:8080/f910aa7e-11ee-4215-93ed-1aeeac822707
```

--------------------------------

### Configure launcher properties

Source: https://kotlinlang.org/docs/multiplatform/compose-native-distribution.html

Sets the application startup configuration including the entry point class name, program arguments, and JVM parameters.

```kotlin
compose.desktop {
    application {
        mainClass = "MainKt"
        args += listOf("-customArgument")
        jvmArgs += listOf("-Xmx2G")
    }
}
```

--------------------------------

### Install Kotlin AI skill via npx

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-spm-migration-ai.html

Installs the Kotlin AI skills package in the project directory. Requires npm version 5.2.0 or newer.

```shell
npx skills add Kotlin/kotlin-agent-skills
```

--------------------------------

### Define GET endpoint with @GetMapping and @RequestParam

Source: https://kotlinlang.org/docs/jvm-create-project-with-spring-boot.html

Implements an HTTP GET endpoint at the root path where the 'name' request parameter is bound to the index() function argument.

```kotlin
@GetMapping("/")
fun index(@RequestParam("name") name: String) = "Hello, $name!"
```

--------------------------------

### Update RVM, RubyGems, and installed gems

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Sequential steps to update RVM, upgrade RubyGems, and update all installed gems to resolve C interop Pod errors.

```bash
rvm get stable

```

```bash
gem update --system

```

```bash
gem update

```

--------------------------------

### Set up localization directory structure

Source: https://kotlinlang.org/docs/multiplatform/compose-localize-strings.html

Organize default and locale-specific translation directories inside commonMain/composeResources.

```text
commonMain/composeResources/
├── values/
│   └── strings.xml
├── values-es/
│   └── strings.xml
├── values-fr/
│   └── strings.xml
└── ... (other locale directories)
```

--------------------------------

### Display Kotlin compiler options with -help

Source: https://kotlinlang.org/docs/command-line.html

Displays all available command-line options supported by kotlinc.

```bash
kotlinc -help
```

--------------------------------

### Start a background coroutine with CoroutineScope.launch()

Source: https://kotlinlang.org/docs/coroutines-basics.html

Starts a new coroutine without blocking the surrounding scope. Returns a Job handle that can be used to manage or wait for the launched coroutine.

```kotlin
// Imports the kotlin.time.Duration to enable expressing duration in milliseconds import kotlin.time.Duration.Companion.milliseconds  import kotlinx.coroutines.*  suspend fun main() {     withContext(Dispatchers.Default) {         performBackgroundWork()     } }  //sampleStart suspend fun performBackgroundWork() = coroutineScope { // this: CoroutineScope     // Starts a coroutine that runs without blocking the scope     this.launch {         // Suspends to simulate background work         delay(100.milliseconds)         println("Sending notification in background")     }      // Main coroutine continues while a previous one suspends     println("Scope continues") } //sampleEnd
```

--------------------------------

### Write, compile, and run a Hello World Kotlin application

Source: https://kotlinlang.org/docs/command-line.html

Creates a console application in hello.kt, compiles it into a runnable self-contained JAR using kotlinc with -include-runtime, and executes it with java -jar.

```kotlin
fun main() {
    println("Hello, World!")
}
```

```bash
kotlinc hello.kt -include-runtime -d hello.jar
```

```bash
java -jar hello.jar
```

--------------------------------

### Install Kotlin compiler using SDKMAN!

Source: https://kotlinlang.org/docs/command-line.html

Installs the standalone Kotlin compiler on UNIX-based systems (macOS, Linux, Cygwin, FreeBSD, Solaris) using SDKMAN! in Bash or ZSH.

```bash
sdk install kotlin
```

--------------------------------

### Inter-pod dependency cinterop signature example

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-libraries.html

Shows an example where two dependent Pods share a common type (WebImage), requiring useInteropBindingFrom() to avoid mismatched type packages.

```kotlin
// The cinterop of pod("WebImage"):
fun loadImage(): WebImage

// The cinterop of pod("Info"):
fun printImageInfo(image: WebImage)

// Your code:
printImageInfo(loadImage())
```

--------------------------------

### Configure styles.css and initialize ComposeViewport entry point

Source: https://kotlinlang.org/docs/multiplatform/compose-css-styles.html

Applies full-screen CSS to the host container and initializes the Compose Multiplatform web entry point using ComposeViewport. Explicit CSS is required so the canvas resizes properly without relying on automatic styling. Requires opting into ExperimentalComposeUiApi.

```css
html, body {
    width: 100%;
    height: 100%;
    margin: 0;
    padding: 0;
    overflow: hidden;
}
```

```kotlin
@OptIn(ExperimentalComposeUiApi::class)
fun main() {
    ComposeViewport(viewportContainerId = "webApp") {
        App()
    }
}
```
Tokens:
Raw