KotlinConf 2026 — program

Join the AndroidX Team as they talk about the two Kotlin Multiplatform storage libraries - Room and DataStore - and their support for the Web platform! In this talk, the team will introduce the API changes that made it possible to support Web for these libraries, as well as demonstrate how you can take an existing project that uses Room or DataStore and have it work on the Web. They will also go over some of the challenges and complexities that were encountered to support WASM/JS and the technologies used such as Origin Private File System (OPFS) and Web Workers.

10:15 – 11:00 · Auditorium, Room 1

Compose Multiplatform supports all modern platforms for writing applications. To achieve this, we at JetBrains devote a lot of time and attention to deep integration with each platform. Every platform has its own unique challenges. In this talk, I want to focus on how I supported several features on the web target. What problems and peculiarities I encountered, and how I solved them. How the same problems were solved in other frameworks. And why there is not just one web target, but not even three, but six, if not more!

10:15 – 11:00 · Room 13b

Feature rich Compose screens often produce frozen frames—any frame over 700 ms—when multiple heavy UI sections are composed in a single pass. Users are forced to wait for the entire screen to finish composing before seeing anything meaningful, creating slow and unresponsive first-load moments. This talk presents Phased Compose, a phased rendering technique that splits a large composition into deterministic steps. Instead of generating one long frozen frame, each major section renders in its own phase, allowing meaningful content to appear immediately while remaining parts compose progressively. This approach reduced frozen frames by over 30% on complex screens—without delays, timers, or …

11:15 – 11:30 · Room 5 (lyntaler)

When designing a programming language, we decide what’s safe, what’s convenient, and what’s practical. These choices become our defaults, the way we believe most programs should be written in that language. However, defaults evolve over time. What once seemed like a good idea may later become a source of bugs and friction. In fact, wrong defaults are often one of the main reasons new programming languages emerge. In this session, we’ll explore how programming languages deal with their defaults. What tools do they have at their disposal, and what are the costs of changing defaults? We’ll look at how languages transition from mutability to immutability, adopt null-safety, and add deeper …

11:15 – 12:00 · Keynote, Room 14

Metro is, first and foremost, a multiplatform dependency injection framework. It’s also an advanced and complex Kotlin compiler plugin. In this talk, we’ll go under the hood and learn how much of Metro’s magic works in the compiler and what kind of code it’s generating. This is an advanced talk and assumes familiarity with DI frameworks like Metro, Dagger, etc. You don’t need to be familiar with compiler plugins, but we will be getting into the nitty gritty so come ready to learn!

11:15 – 12:00 · Room 13a

Ever built a Compose Multiplatform app and wished it looked at home on every platform? This lightning talk introduces Calf (Compose Adaptive Look & Feel) an open-source library that makes your Compose UI adapt to each platform’s native design. We’ll start with a typical Material3 styled Android app and ask: can it feel native on iOS without a complete rewrite? We’ll gradually replace Material components with Calf’s adaptive UI components (dialogs, bottom sheets, pickers, etc.). With just a few swaps, watch the app instantly adopt iOS’s familiar look while using the same codebase for both Android and iOS. You’ll see how Calf maps components to their native counterparts, Material on Android …

11:45 – 12:00 · Room 5 (lyntaler)

Code migrations are tedious: you need to rewrite syntax while preserving behavior, and one wrong assumption can break downstream consumers. PSI helps locate and transform code, but it can't answer the semantic questions that determine whether a transformation is actually safe. Kotlin Analysis API fills that gap. We'll show how we leverage its semantic capabilities—types, symbols, call-site resolution, and diagnostics—to validate intent before we rewrite. This lets us tighten visibilities without breaking consumers, simplify nullability only when every code path stays safe, and confidently transform framework patterns. We'll walk through real examples showing how to query types, resolve …

13:00 – 13:15 · Room 5 (lyntaler)

Compose Multiplatform lets you build beautiful UI with idiomatic Kotlin for Android, iOS, Desktop, and Web apps! It’s stable, production-ready, constantly evolving, and it already powers the experiences of millions of users every day. Its declarative nature also makes it a perfect fit for building cross-platform apps in the age of agentic development. As a framework that can be adopted incrementally rather than requiring a full rewrite, you can start using it risk-free even in existing apps. Your Android skills seamlessly transfer to other platforms, with tools like Navigation 3 already available for Compose Multiplatform. In this talk, we’ll take a hands-on look at everything that’s new …

13:00 – 13:45 · Keynote, Room 14

Kotlin’s coroutines and Flow APIs make asynchronous programming elegant — but when things get slow, they can also make performance opaque. What’s actually happening behind all those suspend functions and dispatchers? In this talk, we’ll explore what Kotlin’s concurrency features really look like under the microscope of Perfetto — Android’s modern performance tracing tool. You’ll see how coroutine scopes, dispatchers, and suspending functions appear on the system trace, and how to interpret their behavior in real-world applications. We’ll dive into how Kotlin constructs translate to threads, tasks, and context switches at runtime, revealing common bottlenecks like dispatcher overloads or …

13:00 – 13:45 · Room 13b

Kotlin coroutines give us powerful tools for asynchronous server programming, but using them well requires more than knowing launch, async, or Flow in isolation. High-performance servers are built from recurring concurrency patterns: small, composable ways to structure work, stream results, isolate slow dependencies, and control producer-consumer boundaries. In this session, we will explore several useful concurrency patterns by building a simplified AI assistant server live. We will break complex server behavior into distinct concurrency challenges and show how Kotlin’s async primitives provide elegant, structured answers: generator-style flows for more responsive event streams, fan-in for …

14:00 – 14:45 · Auditorium, Room 1

An introduction to RemoteCompose. Focusing on the Compose & Kotlin frontend for the RemoteCompose technology. A guided walk through State, Expressions, Actions and Components. Building up to examples of typical use cases and how to implement amazing UIs reaching to different remote surfaces. And the many possible meanings of Remote on Android platforms and otherwise.

14:00 – 14:45 · Room 13a

In this talk, as the team lead and product owner of the JS target, I will share the past vision of Kotlin/JS as a competitor to TypeScript, and the new one as a great addition to KMP projects with native UI. I will describe to you my team and the major projects we are currently working on, which the community has been inquiring about extensively: an unlimited JsExport (codename, project "All Might") and modern JS support (codename, project "Luffy") that should be available on some stages in the fall of 2026. I will also share my mid-term vision for the compilation target and our next big focuses. It will be a deep dive and extension for this blog post …

14:00 – 14:45 · Room 13b

Join us as we explore the Navigation3 API surface and peel back the layers of the library via the various NavDisplay overloads. We will provide insight into the decision behind each overload, how you would use each of them, and the helper APIs that assist you in building your custom logic. This will show you how to fully take advantage of the different building blocks that Navigation3 provides.

15:15 – 16:00 · Auditorium, Room 1

15:15 – 16:00 · Room 3

Compose Multiplatform allows for the creation of beautiful user interfaces in a declarative, functional paradigm. But the Compose compiler isn't limited to creating UI or even visuals. In this talk, we explore using the Compose compiler to create soundscapes and other pieces of music. I will present a library and domain-specific language (DSL) for musical composition – complete with a plugin to turn IntelliJ into a livecoding environment. We'll start by looking at the building blocks of musical compositions and how Kotlin and Compose Multiplatform can be used to implement them in a declarative and functional way. This includes tone generators/synths, shaping the envelope of a sound, playing …

15:45 – 16:00 · Room 5 (lyntaler)

If you've ever wondered why your IDE crawls when working on seemingly innocent code, you're not alone. In this talk, we won't dive into JVM flags, garbage collector tuning, or obscure performance hacks. Instead, we'll explore how your Kotlin code can have a surprising impact on IDE performance. We'll show how small changes in your code style can lead to noticeable improvements. By understanding how your IDE parses, indexes, and analyzes code, you'll learn how to write code that plays nicely with your tools. It will save a lot of time – not only for you now, but also for your teammates and your future self.

16:15 – 17:00 · Room 13a

Jetpack Compose gives us powerful APIs to craft interfaces, but standard implementations often miss opportunities to create truly delightful user experiences. This talk deep-dives into a single interaction. Slide to dismiss! I will demonstrate how thoughtful animation layering transforms a basic gesture into something that feels polished and intuitive. We'll build a complete slide-to-dismiss component, exploring: - **Tap animations** using spring physics for natural, responsive feedback - **Drag gestures** with fluid but interruptible motion - **Visual feedback systems** that guide users, like adding animated effects that communicate certain state changes - **Haptic feedback** that gives …

16:15 – 17:00 · Room 13b

16:15 – 17:00 · Room 3

Elide is a full package for building with Kotlin: install dependencies, compile and test code, and package for production! With support for Native Image and KotlinX built-in, experience Kotlin with nothing in the way. In this hands-on session, we will use Elide to build a small Kotlin command-line tool, shipped as a Native Image within a Docker container.

17:15 – 17:30 · Room 5 (lyntaler)

At Uber, our JVM backend operates at an extensive scale and has historically been developed with Java. Like many companies, we explored what it would mean to introduce Kotlin into that ecosystem not just as a language choice, but as a way to evolve how we build and maintain services. I’ll walk through the implementation and experiments we ran, the assumptions we challenged, and what we learned technically, organizationally, and culturally about introducing a new language into a large, fast-moving monorepo. We’ll cover what worked, what didn’t, and what signals actually matter when making language decisions: from tooling and correctness, to developer experience, to the hidden costs of …

17:15 – 18:00 · Room 13a

Standard animation libraries often force a compromise. GIFs consume bandwidth, Lottie struggles with complex rasters, and video formats lack frame-perfect alpha transparency. Furthermore, replicating complex text effects using these vector or raster formats is inefficient and bloated and can result in glyph shaping issues in different languages. To drive user engagement and measurable business impact, we need tools that are easy to deploy and cost effective to maintain. In this talk, we'll cover two explorations: a custom high-fidelity animated image sequence engine for complex visuals, and TextWave—a specialized engine for animating glyphs that offers superior efficiency and control over …

17:15 – 18:00 · Room 13b

Kuaishou, one of the world's largest short-video platforms with 800M+ MAU, has successfully adopted Kotlin Multiplatform (KMP) across our core business scenarios, including live streaming, IM, content creation, and social features. This talk shares our journey of migrating massive native codebases to KMP, focusing on practical challenges and solutions at scale. We'll dive into critical production issues we encountered and solved: GC optimization strategies to prevent watchdog crashes, SO library splitting to improve integration efficiency, and compilation optimizations for faster build times. We'll also share our best practices for cross-language interoperability between Kotlin/Native and …

17:45 – 18:00 · Room 5 (lyntaler)

What happens when a null pointer crash isn't just a bug — it's a compliance incident? Payment systems are one of the few places where the gap between "it compiles" and "it's correct" has real financial and legal consequences. This is a story about using Kotlin's type system as an architectural tool to close that gap. Here's what we'll cover: - Why Java wasn't enough — the specific failure modes that triggered the migration: null crashes in transaction processing, broken rollback flows, and sensitive data leaking into logs at the worst possible moment - Type-driven design in practice — how sealed hierarchies, value classes, and null-safety were used to make invalid payment states literally …

10:15 – 11:00 · Room 13a

The Kotlin compiler is the heart of the Kotlin ecosystem, but integrating it reliably into custom build systems, IDEs, or other tools has long presented challenges. Historically, interactions often relied on command-line interfaces (CLI) or internal, unstable APIs, making support for features like incremental compilation and multiplatform projects (KMP) difficult to maintain. Enter the Kotlin Build Tools API (BTA): a new, stable, and programmatic interface designed to simplify these integrations. BTA offers a consistent way to perform common compiler operations, starting with compiling Kotlin source files for the JVM platform - complete with full support for daemon/in-process modes and …

11:15 – 12:00 · Room 13b

Working with files and directories is such a ubiquitous task, we're all doing it every day whether we want it or not. After filesystems introduction, more than 60 years ago, multitude of libraries and APIs were introduced, and by the 2025 the problem of interaction with file systems from your program should be finally solved. But is it though? In my talk, I'll open a Pandora's box of leaking abstractions, data races and security vulnerabilities for you, and we'll see whether "there's a library from 80s doing that!" means the problem is solved, or it is an invitation to innovate.

11:45 – 12:00 · Room 5 (lyntaler)

You suggest that your fellow web developers reuse business logic already written in Kotlin, but they get stuck on a requirement to switch IDEs, and learn new tech stack? In this session, I’ll show you how to use Kotlin LSP, command-line tools like emulators and adb, and Hot Reload to build and iterate on a KMP mobile app directly in Cursor. From there, I’ll take the next step and begin sharing Kotlin business logic with an existing JS/TS application—all within a single IDE, while maintaining a tight feedback loop. For the most adventurous, we might even try sharing some UI. I will show also, how your web colleagues can use AI (Cursor in this case), to explore Kotlin code, without a need to …

13:00 – 13:15 · Room 5 (lyntaler)

Let’s take a closer look at Filament, the real-time physically based rendering engine, and learn how to use it to build fun effects in our day -to-day UI. Using Compose Multiplatform, we will explore the main Filament features, and how to use them to create some particle and material based UI effects and interactions. We will cover how to set up Filament, how to work with its material system, and how to use shaders and lighting to create simple effects that react to touch and animations. All of this rooted in practical examples, without diving too much into low level graphics code. After this talk, you will have a better understanding of how Filament works, and how you can use it to create …

13:00 – 13:45 · Auditorium, Room 1

OkHttp is a popular library for making network calls. You might use it directly, or with Ktor, Retrofit, Coil, or gRPC. But this is not a talk on how to use OkHttp. Instead, we’ll open up the code and look at its weird and clever implementation details. We’ll see connection lifecycles, cache state machines, and URL decoders. We’ll learn: * How OkHttp’s own architecture is a stack of interceptors. * How you can generate certificates for testing HTTPS. * The extreme effort OkHttp makes for great performance. * Three different ways to extend OkHttp. If you’d like to see some capable and efficient code in Kotlin, this talk is for you.

13:00 – 13:45 · Room 13a

“You have 9 months to build iOS and Android apps from scratch for our next premium headphones. How you do it is up to you, but it has to work flawlessly.” This was the directive given to a small group of Android engineers at Sony in 2021. The requirements were brutal: high-speed BLE connectivity for real-time sensor data, robust background execution, and a UI capable of keeping pace with hardware innovation. The goal? To ensure the software experience matched the world-class quality of our hardware. Against conventional wisdom, we made a calculated bet on Kotlin Multiplatform (KMP), even though it was still in preview. In this session, I will take you inside Sony’s 6-year journey from a …

13:00 – 13:45 · Room 13b

In the age of fitness trackers, smartwatches, cycling computers, and travel apps, each of us generates a huge amount of personal geographical data - daily steps, running routes, bike rides, hikes, city walks, and road trips. But how do we turn this raw stream of GPX, GeoJSON, KML, or TCX files into meaningful insights, clean datasets, and reliable analytics? These datasets are rich and deeply personal - and not everyone wants to upload them to cloud platforms or rely on whatever limited dashboards a mobile app provides. Sometimes the analytics you want simply aren’t there, and sometimes privacy matters more than convenience. In this talk, I’ll show how Kotlin DataFrame and Kandy can help …

14:00 – 14:45 · Room 13b

AI is not only transforming software development but also redefining how we teach programming. As this landscape evolves, programming courses must adapt to meet new industry demands. Traditional methods, like teaching basic syntax or relying heavily on lectures, are no longer enough. Instead, we need to rethink both what we teach and how we teach, equipping students with skills relevant to an AI-driven world. In this talk, we will share industry insights on how AI is already shaping the software development world, connect these trends to programming education, and explore how universities are integrating this into their programming courses. We’ll highlight how all of this maps to Kotlin …

15:15 – 16:00 · Room 13a

Lauren from product wants a future-facing mobile app full of highly responsive and rich visuals, robust animations, immersive soundscapes, and meaningful haptics. Eric from engineering wants to ensure the app starts up quickly, doesn’t drop frames, and runs on a cheap, 5-year-old tablet without OOMing on launch. Their product strategy requires both. In this fun, dialogue-style session, mobile performance experts and newly minted co-founders Lauren Darcey and Eric Kuck explore the eternal tension between "making it delightful" and "making it performant." What happens when mobile performance-focused developers lean in to building some of the most intensive user experiences, from particle …

15:15 – 16:00 · Room 13b

15:15 – 16:00 · Room 3

Sometimes you find yourself with a bug in a library or a tool you are using causing things to fail or even worse fail flakily. This talk will be a guide on how to take it from there. We'll walk through examples of non-determinism, race-conditions, undocumented behavior and others to see what we can learn to make the process to a working build/application faster. We'll look into an example of a race condition in the Kotlin Gradle Plugin. We'll hone our skills in investigation, isolation of the issue to create a standalone reproduction, and finally getting it resolved. We'll discuss at what point you should care about a problem or simply leave it alone. The stories will be inspired by …

16:15 – 17:00 · Auditorium, Room 1

AWS Lambda is a powerful tool for serverless architectures but many examples and tools assume you're working in Python, Node.js, or Java. This talk demonstrates fast, maintainable Lambda functions in your preferred language! In this session, we'll go from zero to fully-deployed Kotlin/Native Lambda functions, with real performance data and practical tradeoffs at every step. You'll learn how to build a custom Lambda runtime, structure your code for serverless, and to package & deploy your application. Throughout the talk we'll highlight how to measure & optimize for cold starts, concurrency, and efficiency. Whether you're hitting Lambda timeout limits, paying for wasted cold start time, or …

16:15 – 17:00 · Room 13a

Writing music creation apps for multiple platforms is challenging. We need cross platform, low latency audio. We also need a UI that can follow the musical events. And for multiplayer apps we need cross platform network communication. Learn how we solved the audio problem using expected/actual classes and multiple host specific implementations, including WebAudio. We will examine the issues around using co-routines for real-time audio and how it relates to state flow. We will also discuss the conversion of an old general purpose modular synthesis library from Java to Kotlin Multiplatform and how we modernized the API. The UI required some novel techniques including custom drawing and …

16:15 – 17:00 · Room 13b