# KotlinConf App: A Reference Kotlin Multiplatform Client and Ktor Backend

> JetBrains publishes the full source of the official KotlinConf conference app: a Compose Multiplatform client for Android, iOS, desktop and web, plus a Ktor and Exposed backend. It is a working sample of a shared-code stack, not a general-purpose product you adopt.

**JetBrains/kotlinconf-app** — The official KotlinConf application

- Repository: https://github.com/JetBrains/kotlinconf-app
- Website: https://jetbrains.github.io/kotlinconf-app/
- Stars: 3,564 · Forks: 425
- Language: Kotlin
- License: Apache-2.0
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/jetbrains-kotlinconf-app

## What the KotlinConf App repository actually contains

This is the source of the official application for KotlinConf, the conference JetBrains runs. The README says the app is written in Kotlin and shares code between platforms using Kotlin Multiplatform. Two halves live in one repository: a client that runs on Android, iOS, desktop and web with shared UI built on Compose Multiplatform, and a backend built on the Ktor server framework with the Exposed database library. The published builds are listed for Android on Google Play, iOS on the App Store, and the web build deployed to GitHub Pages. The audience is therefore narrow and specific. It is not aimed at people who want a conference app for their own event; it is aimed at engineers who want to read a complete, production-flavoured Kotlin Multiplatform codebase that JetBrains itself maintains, with the client, the server and the build configuration all visible. The top-level layout supports that reading: app/ for the client targets, backend/ for the server, core/ for shared code, plus gradle/ and settings.gradle.kts for the build.

## How the shared client and the Ktor backend fit together

The mechanism described in the README is code sharing rather than a single binary. One Kotlin codebase produces four client targets, and Compose Multiplatform supplies the UI layer across all of them, so screens are written once and rendered on Android, iOS, desktop and web. The web target is notable because the README names the wasmJs browser development task, which places the web build on Kotlin/Wasm rather than Kotlin/JS. The backend is a separate Ktor application using Exposed for database access, which means the conference data the client renders is served by a server in the same repository rather than by a third-party API. The repository structure reflects that split: app/ holds the client modules, backend/ holds the server, and core/ holds code shared between them. That three-way separation is the part worth studying. It shows where JetBrains draws the line between what the client and the server both need and what only one of them does, and it is the decision most teams get wrong when they start a multiplatform project by putting everything in one module.

## Building the KotlinConf App locally

The README gives a short build path. First set up your environment for Kotlin Multiplatform development, following JetBrains' own setup guide. Then open the project in IntelliJ IDEA or Android Studio. There is no published artifact to install; you clone the repository and run a target. The desktop client has a single documented Gradle command, which runs the app with hot reload enabled:

```bash
./gradlew :app:desktopApp:hotRun -DmainClass=org.jetbrains.kotlinconf.MainKt
```

The backend runs on its own, and the README documents one task for it:

```bash
./gradlew :backend:run
```

The web client uses the Wasm browser development task:

```bash
./gradlew :app:webApp:wasmJsBrowserDevelopmentRun
```

Android and iOS do not use Gradle tasks in the README. For Android you select the app.androidApp run configuration in the IDE; for iOS you select KotlinConfAppScheme. The README does not document ports, environment variables or database configuration for the backend, so what you see after `:backend:run` depends on defaults that are not described in the README. That is the first thing to inspect in the backend module before assuming the client will talk to a local server.

## Where the repository stops being useful

The README does not document rollback, deployment, database migrations or backend configuration. There is no section on how the production backend is deployed, how conference data is loaded, or how the client is pointed at a different server. For a repository whose stated purpose is the official app for one event, that is a reasonable omission, but it limits what you can copy. The client is also tied to KotlinConf: the README lists store links for the KotlinConf app specifically, and nothing in it suggests a configuration path for running the same client against a different conference. If you wanted to reuse the UI for another event, you would be reading the source and rewriting the data layer, not setting a value. The web target is another boundary. Because the README names the wasmJs development task, the browser build depends on Kotlin/Wasm tooling, which is a narrower compatibility surface than a plain Kotlin/JS build. If your target browsers or your team's tooling are not ready for that, the web client here is a reference rather than a starting point.

## Compared with a plain Android-only Kotlin app

The obvious alternative is a conventional single-platform Kotlin app: one Android module, Jetpack Compose for UI, and no shared module. That approach is simpler to build and debug, and it avoids the Gradle complexity of a multiplatform project with four client targets. The difference in approach is where the UI lives. In a single-platform app, Compose is Android's Compose and the toolchain is the Android toolchain. Here, Compose Multiplatform renders the same screens on Android, iOS, desktop and web, and the build has to satisfy all four. You pay for that in setup: the README's first step is environment setup for Kotlin Multiplatform, and there are separate run configurations per platform. You get it back in shared screens and a shared core module. If you only ever intend to ship on Android, the multiplatform structure is overhead with no payoff, and this repository is a poor template. If you intend to ship on more than one platform, the structure here is the argument for the approach, and the repository is one of the more complete public examples of it.

## Maintenance, licence and what to check before cloning

The repository is not archived, and the last push was on 2026-09-23, so the codebase is current as of that date. That matters for a sample project, because Kotlin Multiplatform and Compose Multiplatform move quickly and an unmaintained example teaches outdated idioms. The licence is Apache-2.0, which permits reuse and modification with the usual conditions around notices and attribution; that is a statement about the licence text, not legal advice, and anyone embedding this code in a product should read the LICENSE file and the CODE_OF_CONDUCT.md and CONTRIBUTING.md at the repository root. There is no release list to track, so upgrade cost is not measured in version bumps of a library. It is measured in toolchain alignment: the Gradle wrapper, the Kotlin version in gradle.properties, and the plugin declarations in settings.gradle.kts and build.gradle.kts all have to agree with the Kotlin Multiplatform setup you install. If your environment is behind, the first build will fail on plugin resolution rather than on application code, and that is the cost of using a fast-moving sample.

## Conclusion

Treat this repository as a study project, not a dependency. Teams building a Kotlin Multiplatform product with Compose Multiplatform on the client and Ktor plus Exposed on the server should read the app/ and core/ modules before writing their own; anyone who wants a ready-made conference app to brand and ship should not, because the README documents no configuration for a different event and the published builds are tied to KotlinConf. Before cloning, check the Gradle and Kotlin versions in gradle.properties and settings.gradle.kts against your local toolchain, and confirm that the four run targets you need (app.androidApp, KotlinConfAppScheme, app:desktopApp:hotRun, app:webApp:wasmJsBrowserDevelopmentRun, backend:run) all resolve on your machine.

## FAQ

### Can the KotlinConf App be used as an example Kotlin app?

Yes. It is the source of JetBrains' official KotlinConf application, written in Kotlin with Kotlin Multiplatform for code sharing and Compose Multiplatform for shared UI across Android, iOS, desktop and web. It is a full application with a Ktor backend rather than a minimal snippet.

### Can Kotlin be used to develop desktop apps, as shown in the KotlinConf App?

The README documents a desktop client and gives the command to run it: ./gradlew :app:desktopApp:hotRun -DmainClass=org.jetbrains.kotlinconf.MainKt. Desktop is one of the four platforms the client targets, alongside Android, iOS and web.

### Can Kotlin make iOS apps, like the KotlinConf App?

The README lists iOS as a published platform, available from the App Store, and says the iOS client is run with the KotlinConfAppScheme configuration. The shared UI is built with Compose Multiplatform, so the iOS app is part of the same shared codebase.

### Is Kotlin Multiplatform worth it, judging by the KotlinConf App?

The repository shows the payoff and the cost. One Kotlin codebase produces Android, iOS, desktop and web clients with shared UI, but each platform has its own run path and the README's first step is setting up a Kotlin Multiplatform environment. Whether that trade is worth it depends on how many platforms you actually intend to ship.

## Sources

- [Issues](https://github.com/JetBrains/kotlinconf-app/issues)
- [JetBrains/kotlinconf-app on GitHub](https://github.com/JetBrains/kotlinconf-app)
- [License: Apache-2.0](https://github.com/JetBrains/kotlinconf-app/blob/main/LICENSE)
- [Project website](https://jetbrains.github.io/kotlinconf-app/)
- [README](https://github.com/JetBrains/kotlinconf-app/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jetbrains-kotlinconf-app