KotlinConf 2025 Recordings

Good news everyone! The recordings from KotlinConf 2025 are now available (you can find them all here). I have watched most of them, and I talked with other attendees about their favorites. Based on that, I prepared my opinionated list of recommendations. Enjoy!

You do not need to watch all sessions, but you should definitely watch the keynote. This is where all the most important announcements are made, and it is also a great way to get a general overview of the conference.

Rich Errors are the most important feature announced at KotlinConf 2025, so if you want to understand them, you should start with this session. Michail Zarečenskij explains how they work, why they are needed, and how they will be used in Kotlin.

The biggest revolution that is not happening in Kotlin is the introduction of compiler plugins. They allow you to extend the Kotlin compiler with your own features, which it an absolute game-changer. For instance, it allowed Compose to be implemented. Brian Norman is the here behind Kotlin Power Assert. Now he works in Kotliun team on compiler, and he write other compiler plugins. In this session, he explains how to write your own compiler plugin.

I think it was the most commented session (after the Keynote) on KotlinConf corridors. It caused a lot of discussions, but also some controversy as not everyone agreed with proposed solutions. I definitely recommend watching it, as it is good to understand what Project Valhalla might introduce, and how it might affect Kotlin. Marat Akhin presented a lot of interesting ideas, and I am sure you will find it inspiring.

Time for my own session, but I recommend it not because it is mine. I decided to make it because I believe it is very needed. If you search for some lessons about debugging and performance tuning, you will find either very specific presentations about using debugger or profiling tools, or a very specialized ones about tuning JVM (that is not practical for most developers). I felt there is a great need for a practical session that shows what to do to find and fix issues, both regular and performance-related. I concentrated in this session on coroutines, but I wanted to give a general overview of the most important tools and techniques. I believe I achieved that, as I received a lot of positive feedback from attendees, and I can see that this session average grade is way higher than the average grade of other sessions.

I mentioned presentations that concentrate on using debugger, so here is one of them. Here Alexey Merkulov, shows all the improvements that were made in the last year to make debugging coroutines easier. A lot has improved, and I am sure you will find it useful.

Another revolution that happens in Kotlin is that is becomes a language for AI. One of its most promising new capabilities is the ability to simply define AI agents. In this session, Vadim Briliantov shows how to do it in Kotlin. He explains how to use the new Koog library, and how to define agents in a simple and effective way.

Hot Reload in Compose Desktop is amazing. It allows you to change the code and see the results immediately, without restarting the application. It is a great feature that makes development much more efficient, but it is also a very interesting technical challenge. In this session, Sebastian Sellmair explains how it works, and how it was implemented.

I always recommend Ross Tate's sessions. He is the person designing Kotlin type system. Last year he presented a session about union types, and this year we had Rich Errors announced, exactly as he described them last year. This year he presents an algorithm that might revolutionize type inference (or outference). It would be a revolution not only in Kotlin, but in programming languages in general, and it is stunning what depth of language smartness it might allow. I am sure you will find it very interesting, and looking forward to seeing it in Kotlin.

I love staying in touch with how other languages solve problems, so I couldn't skip the session that shows how Swift deals with the same problems we have in Kotlin Coroutines. Here it is, a very interesting session.

Let's end this list with something fun. This session shows over 47 refactorings, but what makes it special is that it shows how the best developers use IntelliJ to make their work extremely efficient. I am sure you will learn a lot of new tricks that will make your work easier and more efficient.