KotlinConf 2026 in Munich – Conference Review

KotlinConf is the official annual conference organized by JetBrains, the company behind Kotlin and (among other things) the IntelliJ development environment. Kotlin is a modern program language that is widely used in application development – particularly for Android. KotlinConf brings together the entire Kotlin community to learn about the latest features, attend exciting presentations and, of course, to network with other developers. It was great for us that KotlinConf 2026 took place in Munich!

As the Android team at Apps with love, we use Kotlin on a daily basis, both in native Android development and, with Kotlin Multiplatform (KMP), across platforms. We Ossi, Miggi and Dinah, were very excited for the two days of the conference. The main topics that particularly interested us were: the latest news on KMP and Compose Multiplatform (CMP), and everything to do with Kotlin as a program language.

The journey to Munich

On Wednesday evening at 6.30 pm, we met up at Bern main station with our luggage, snacks and a sense of anticipation. We’re all secretly fans of Kodee, the Kotlin mascot. So, even before we set off, we’d all agreed: our mission for KotlinConf 2026 was to return with at least three Kodee soft toys.

Our train was delayed by about 30 minutes, we pulled into Munich five hours later, hopped on the underground towards Messestadt Ost and checked into the hotel right next to the Munich Exhibition Centre at around 12.30 am.

Having had very little sleep, we set off for the exhibition centre at around eight o’clock the next morning. The Munich Exhibition Centre is well suited as a conference venue: the site is so large that the 2,200 or so attendees were spread out comfortably, and outside the conference rooms it was bright – so we still managed to enjoy some of the long-awaited fine weather.

As we’d arrived early enough, we tackled the most important thing first: merch!😉 After checking in, we were directed straight to the swag stand and lo and behold: we each received a T-shirt (not unisex, yay!) and a mini Kodee soft toy! We hadn’t expected to complete our mission so quickly. Next to the swag booth was the merchandise stand. One mini Kodee each wasn’t enough: we needed a big Kodee for the office. Spotted it, bought it, and we are happy.

After that, we headed over to some other stands, picked up some croissants, sandwiches, and a coffee, and found some JetBrains pins. Shortly afterwards, it was already time for the keynote, where we actually managed to secure seats in the front row. Can you spot us?

The keynote was packed with summaries and statistics on the evolution of Kotlin, information on partnerships and JetBrains products, and a brief overview of KMP and CMP. For example, JetBrains has now also released a dedicated IDE (Integrated Development Environment) similar to Cursor or Google Antigravity: JetBrains Air. You can read more about the keynote on the JetBrains blog.

Talks

KotlinConf offered a packed programme: 100 speakers and 108 sessions spread across parallel tracks covering KMP/CMP, AI integration with Kotlin, server-side development, and Kotlin language development. As always, we mainly attended the talks that interested us the most.

Ossi’s Favourite Talk: The Lord of Collection Functions - The Fellowship of Kotlin

by Ben Kadel

As we all know, the last slot on the first day of a conference is always the toughest. Our heads were spinning from all the information we’d taken in, our legs felt heavy, and the tiredness was really starting to show in all of us in the hall. But since we already knew Ben Kadel from the Droidcon two years ago, we knew: this was going to be good. Our expectations were high – and they were absolutely exceeded!

At the start, Ben was standing on stage looking completely normal and not in costume. He played a perfectly staged intro video that set the scene for the epic story, then slipped quietly backstage. When the video ended and the lights came back on in the hall, the brilliant reveal followed: Ben walked back onto the stage dressed entirely as Gandalf! 🧙‍♂️

Or when it came to aggregating values, functions such as .sum() or .sumOf { ... } were used, rather than laboriously incrementing a mutable variable outside a loop.

Because the talk was so funny, vivid and creative thanks to this storytelling, any tiredness vanished in an instant. Despite the long day, it was really easy to follow the narrative, and you found yourself getting really caught up in the excitement as the code became cleaner line by line and .forEach was finally vanquished.

My conclusion: An absolutely brilliant way to round off the first day! I’ll definitely be keeping an eye out during future code reviews to see if a secret ‘Ring of Power’ has crept in somewhere, which we’d be better off replacing with a more appropriate collection function.

Note: All the animations were created in Compose Multiplatform. Even the slides themselves were made using in Compose Multiplatform 🤯

It quickly became clear what the aim was. A clever use of animations and haptic feedback to make the experience as intuitive as possible for users. 

To achieve this, we first took stock of all the tools we already have at our disposal in Compose:

This allows us to build our own swipe-to-dismiss components. Here is an example (the shake animations are intended to represent haptic feedback, as this cannot be felt via video) featuring haptic feedback and an intensification of the border colour. This signals to the user that if they release their finger at this point, the corresponding action will be performed. If they release it earlier, the component will spring back to its original state.

To avoid unnecessary onboarding or explanatory screens, animations can be used to give users clues as to what they can do. In the following example, you can see how users are shown that a swipe action is hidden behind the component, and how to indicate to users that an action has not worked:

And so we have a fantastic all-in-one package that guides users through the app’s features using a ‘learning by doing’ approach. 

This helps to avoid unnecessarily long onboarding processes and provides useful haptic and visual feedback alongside cool animations and designs.

We'll see – maybe I'll use Compose Multiplatform for my next presentation too. I'm certainly inspired to have a bit to play around with all these possibilities.

Dinah's Favourite Talk: What's New in Compose Multiplatform: Better Shared UI for iOS and Beyond

by Sebastian Aigner & Márton Braun, JetBrains

With Compose Multiplatform (CMP), developers can build user interfaces for Android, iOS, desktop and the web – all using the same code, as the framework translates it for the respective platform. The whole thing runs on Kotlin Multiplatform (KMP), which is used to programme the business logic for each platform.
CMP can now be used in production on mobile devices (Android & iOS) and on desktop. CMP for Web is currently in beta.

The latest CMP features were presented at this talk. In fact, new features and APIs from Jetpack Compose (the Android UI framework) are now making their way into CMP within about three to five weeks. For all four platforms. This pace is impressive and is an huge benefit to developers to developers like us who want to keep their projects up to date.

First, the two speakers mentioned Navigation 3 . We had already successfully used Google’s new navigation library for Jetpack Compose in a KMP project, so the content was nothing new to us. However, it’s great that the library is now fully usable across all platforms.

In KMP projects, there is a new project structure designed primarily to ensure that each module has a clearly defined responsibility and a single purpose. The structure should be as consistent as possible, and it should be easy for developers to further modularise the project. Furthermore, Compose Hot Reload is now directly integrated into the Gradle plugin and no longer needs to be installed separately by developers. Yay!

Overall, it’s clear that KMP and CMP are the main focus of JetBrains’ strategy. There are constant improvements to the tooling and APIs, and there are new features that are genuinely useful to us developers – our voices are being heard. The strategy seems to be working: there are now over 3,500 Kotlin libraries!

The part of the presentation I found most exciting, however, was about iOS (I know, shocking!). Apple’s new visual design system from iOS 26 onwards, Liquid Glass, differs significantly from Android Material 3 Expressive, Android’s design system (for more on Liquid Glass, see also our blog). As much as I, as an Android user, am a fan of Material 3 Expressive: if an iOS user uses a CMP app based exclusively on Compose, it looks rather alien because the familiar glass look is missing. It also behaves differently from native iOS apps in terms of usability, because some interactions do not work as usual.
JetBrains has now changed this: the most important native iOS components (tab bar, navigation bar and toolbars) can now be displayed with the Liquid Glass look.
With a new property, embedded native UIKit components can also be rendered on top of the Compose UI layer, thereby supporting transparent backgrounds and native shader effects. This means that even embedded native components fit seamlessly into the Liquid Glass UI.
The result: a CMP app that feels familiar to iOS users. Liquid Glass, or iOS 26, was released by Apple in mid-September 2025. I was impressed that JetBrains delivered support for Liquid Glass so quickly.

They also showed us some new features regarding text input on iOS. This now utilises native iOS components, which means that precise cursor movements are now visible in text input fields (e.g. in a text field or search bar) and gestures, selection functions and system context menus (‘AutoFill’, ‘Translate’ and ‘Share’, etc.) can be used natively. In addition, it is now possible to define a custom input view that replaces the standard keyboard – generally speaking, iOS apps now run more smoothly. In short, these are all implementations that significantly improve the look and feel of a CMP app for iOS users.

This talk was definitely a highlight for me. The fact that JetBrains (in collaboration with Google) is investing so heavily in the UX for iOS apps shows that KMP and CMP are no longer just experimental playgrounds, but the strategic approach that Android developers can use today to build applications for all platforms. With a single shared codebase and virtually no compromise on the native feel. I like!

Our conclusion

We were thoroughly impressed by KotlinConf 2026. It was professionally organised, the catering was sourced locally and the food was excellent. The Messe München venue was welcoming, and we found the four-minute walk between the venue and the hotel particularly convenient – we’ll bear that in mind for future conferences.

KotlinConf doesn’t focus solely on Android development – that’s what DroidCon is for – but rather on Kotlin and the JetBrains ecosystem as a whole: Android, backend, KMP, desktop, IoT and more. We were therefore all the more pleasantly surprised by how many presentations focused on mobile and Android. As it wasn’t possible to attend every presentation at the conference either, JetBrains will soon be posting all the talks online, so you can take your time to watch them again or catch up on anything you missed.

As an agency, we are currently continuing to focus on native development and are also developing cross-platform logic using KMP. But the CMP approach is an exciting prospect. After this conference, it’s clear that there’s a lot to try out and discuss across teams.

We are convinced that KMP and CMP are not frameworks that will end up in an application graveyard in a few years’ time, but rather that they will be actively developed and improved. Together with ongoing improvements to Kotlin as a language and the tools in the JetBrains ecosystem, we look forward to everything else JetBrains has in store for us. Above all, however, we are now delighted with our Kodee soft toys, which now serve as rubber ducks – or simply sit on our desks as decoration.

Finally, a few honorable mentions:

The talk “We were meant to be” by Lena Reinhard highlighted the promises and vision of the tech industry surrounding AI, articulating the pressure that many software developers are currently experiencing due to AI and the associated disruption in the industry. She drew on her personal life and shared four strategies with us on how developers can cope with current global events. An impressive, funny, inspiring and, above all, encouraging message – and my absolute “Let’s go, girl!” moment at KotlinConf 2026.

Finally: the Most Beautiful Presentation Award goes to Hammad Akram, Lead Engineer at H&M, for his presentation “Tiny Models, Big Impact: On-Device AI for Real Apps”.