# Confetti: a Kotlin Multiplatform conference app sharing one GraphQL backend across six clients

> Confetti is John O'Reilly's reference project for Kotlin Multiplatform, with a GraphQL backend and Apollo-based shared code driving Compose clients for Android, desktop, web, Wear OS and Android Automotive, plus an iOS client. It suits a developer studying how one shared Kotlin codebase reaches six different front ends, and it is the wrong base for a project that only needs one platform.

**joreilly/Confetti** — KMP/CMP GraphQL based conference project with Jetpack Compose Android, Compose for Wear, and Compose Multiplatform Desktop, Web and iOS clients along with GraphQL backend.

- Repository: https://github.com/joreilly/Confetti
- Stars: 1,066 · Forks: 125
- Language: Kotlin
- License: Apache-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/joreilly-confetti

## One shared module, five very different front ends

The repository description calls Confetti a KMP and CMP GraphQL based conference project with a Jetpack Compose Android client, Compose for Wear, and Compose Multiplatform desktop, web and iOS clients alongside a GraphQL backend. The README expands on the same point: it is a Kotlin and Compose Multiplatform GraphQL project covering both backend and clients, for viewing conference information across a range of conferences. The shared layer is Apollo GraphQL based Kotlin Multiplatform code. What makes the project worth studying is the fan-out. The repository root shows androidApp/, compose-desktop/, compose-web/, iosApp/, wearApp/ and automotiveApp/ as separate modules alongside common/ and shared/, which is the concrete shape of a multiplatform codebase where one domain layer has to satisfy six UI toolkits.

## The extra clients were contributed, which is a useful signal

The client list is longer than a typical multiplatform sample, and the README attributes two of them to outside contributors. The Compose for Wear OS client was contributed by yschimke, and the Android Auto and Automotive OS support by cmota. The repository confirms this with dedicated modules, androidApp/snapshot/walkthroughAndroidAuto.gif, automotiveApp/snapshot/walkthroughAndroidAutomotive.gif, and separate wearApp/ and wearBenchmark/ and androidBenchmark/ directories. What that says about the codebase is that the platform surface was extended by people who knew the platform but not necessarily the project, and the project absorbed the result. For a reader studying how to add a target, those directories are the closest thing to a worked example.

## The backend is GraphQL, and the conference is chosen by an HTTP header

The API is described precisely, which is unusual for a sample project. It lives at https://confetti-app.dev/graphql, with a GraphQL playground linked alongside, and you can query the list of conferences with conferences.id. The conference to query is chosen by passing a conference HTTP header, rather than by a path segment or a query parameter. That is a small design decision with real consequences for a client: the selection of which dataset you are looking at travels in the request metadata, so a shared client can point at a different conference without rebuilding its queries. The repository root holds a backend/ directory and a proto/ directory, and the topic tags list apollo-client and graphql-server.

## The build requirements are specific and have moved with the platform

The Building section is short and worth quoting in full because it defines what you need before anything compiles. The Android client is built and run with Android Studio or IntelliJ, and it requires a recent Android Studio release supporting AGP 9.1. The iOS client requires Xcode 26 or later, and the parenthetical matters: Apple silicon only, because the Intel simulator target was removed. JDK 17 or later is required. The README badge shows Kotlin 2.4.10, so the Kotlin toolchain version is also pinned. The root holds a gradlew and gradlew.bat, a settings.gradle.kts and a build.gradle.kts, plus a build-logic/ directory, which is the modern convention for shared Gradle configuration across modules.

## A Gemini feature is configured rather than built in

The Gemini functionality section describes talk recommendations for a particular conference, included in the mobile clients, and it is conditional on a configuration file. The mechanism is a gemini_api_key set in local.properties, and the desktop client allows free entry of the query instead. So the AI feature is opt-in by credential rather than compiled in, which is the right shape for a reference project since it means the repository works without any API key. The author also links a related post about adding embeddings and RAG support to a Koog-based AI agent in Confetti, which suggests the AI work in this repository is an ongoing line rather than a one-off demo.

## The related posts show the hard problems in this stack

The README lists four posts by the author, and their titles read like a list of the awkward parts of sharing an app between Kotlin and Swift. There is a post on Swift and Kotlin ViewModel alignment in a Kotlin Multiplatform project, one on using the KMM-ViewModel library to share a ViewModel between iOS and Android, one on consuming Compose for iOS in a SwiftUI application, and the RAG post. The topic tags confirm the direction, with swift and swiftui listed alongside kotlin-native and kotlin-multiplatform-mobile. The SwiftUI post in particular addresses the gap that a Compose Multiplatform project cannot paper over, since an iOS app built with SwiftUI has to reach the shared Kotlin logic through an interop layer rather than through composables.

## A sample project with a real distribution footprint

Despite being a reference project, Confetti ships like a product. The README links a Google Play Store listing under the identifier dev.johnoreilly.confetti and an App Store listing, and the repository root contains a fastlane/ directory, which is the tool for automated store submissions, a landing-page/ directory, and a design/ directory. There is also a.devcontainer/ directory for a containerised development environment, a tmp-previews/ directory, and a.lfsconfig for Git LFS. Those last details are the ones that separate a project people actually build from a demonstration. The release history shows tags 0.8.12, 0.8.13 and 0.8.14 in June 2023, and the last push to the repository was on 2026-10-19, so the code is still being worked on well past the last tag.

## Conclusion

Confetti is worth reading as a reference implementation if your team is evaluating Kotlin Multiplatform with a shared GraphQL client, since the repository shows the same shared module feeding six separate UI targets and a backend, and the build requirements are stated plainly enough to reproduce. It is a poor fit as a starting point for a conference app of your own, because the data model, the API and the branding are all specific to this project, and it is a poor fit if you cannot meet the iOS toolchain requirement of Xcode 26 on Apple silicon. Verify first which of the client targets you actually need, since each brings its own platform dependency, and note that the most recent tagged release is 0.8.14 from 2023-06-18 even though the tree is being worked on.

## FAQ

### What is the Confetti project?

It is a Kotlin Multiplatform and Compose Multiplatform GraphQL project, backend and clients, for viewing conference information. It includes Compose Multiplatform clients for Android, desktop and web, a Compose for Wear OS client, an Android Auto and Automotive OS client, an iOS client, and shared Apollo-based Kotlin Multiplatform code.

### How do you choose which conference the Confetti API returns?

You pass a conference HTTP header on the request to https://confetti-app.dev/graphql. The list of conferences can be queried with conferences.id, and the conference to query is selected by that header.

### What do I need to build Confetti?

The README states that JDK 17 or later is required, the Android client needs Android Studio or IntelliJ with a recent release supporting AGP 9.1, and the iOS client needs Xcode 26 or later on Apple silicon, since the Intel simulator target was removed.

### Is the Gemini talk recommendation feature enabled by default?

No. It is included in the mobile clients but only active if a gemini_api_key is configured in local.properties, and the desktop client instead allows free entry of the query.

## Sources

- [Issues](https://github.com/joreilly/Confetti/issues)
- [joreilly/Confetti on GitHub](https://github.com/joreilly/Confetti)
- [License: Apache-2.0](https://github.com/joreilly/Confetti/blob/main/LICENSE)
- [README](https://github.com/joreilly/Confetti/blob/main/README.md)
- [Releases](https://github.com/joreilly/Confetti/releases)

---

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