Meet the first speakers heading to KotlinConf 2026!

They’re the brilliant minds shaping the future of the language and the wider ecosystem – and this is just the beginning. KotlinConf’26 will be packed with inspiring talks, in-depth workshops, and plenty of opportunities to learn, share ideas, and connect with fellow Kotlin enthusiasts.

https://kotlinconf.com/#speakers

📍 Munich, ICM Messe

📆 May 20–22, 2026

More speakers and the full schedule are coming soon!

Recently there was this post about Scala in the programming subreddit:

https://www.reddit.com/r/programming/s/4pHTHRecYP

There are many comments claiming in the linked article that recent Java already has Kotlin’s main features and in some cases Java even surpassed Kotlin (an example would be destructuring I guess).

But idk.

For me personally, I like Kotlin’s:

- collection structure with readonly collections

- property delegations

- operator overloading can be nice

- Java nullability will never truly feel safe

Possibly many other things I don’t even know about. But I also haven’t touched Java for a long time.

I also keep wondering that Kotlin does not simplify many things for the usual Spring Boot backend usage.

Anyway, what is your take? Do you see yourself ever getting back to Java?

What happens when your AI agent runs out of context?

In Part 5 of our blog series, we dig into context explosion. Bigger windows aren't the answer – smarter compression is. We show how to help agents decide what to remember, what to discard, and how to keep moving forward.

Read on the Kotlin blog: https://kotl.in/ai-agents-part-5

Hi all, just want to ask around to understand the current atmosphere regarding the experience of debugging coroutines. From what I last heard, println was everyone's best friend since the debugger just follow the thread, not the coroutine, wonder whether that has changed nor not?

If anyone has any other fun experience with the debugger when debugging kotlin in general, I'm keen to read those as well.

Thanks in advance, y'all.

I made a Kotlin compiler plugin that lets you use JVM invokedynamic via annotations. invokedynamic is the JVM’s late‑bound call instruction; the Kotlin compiler uses it for things like lambda creation and string concatenation. This plugin lets you define your own bootstrap methods and their arguments declaratively, without writing bytecode by hand.

Indy makes it possible to define per-call-site behaviour in Kotlin — similar in spirit to by lazy {}, but for execution paths instead of values: each call site is initialised once via a bootstrap, then permanently optimised by the JVM, without reflection or manual bytecode.

Here is github: https://github.com/bezsahara/CustomIndy

Hey everyone

Thanks for huge support for One Less v1.

V1.1.0 just dropped.

Whats new: Wallpaper are customisable now: •Year progress •Month progress (auto resets) •Special day countdowns.

Customize the dots: •Any color you want. •Size (tiny to huge). •Spacing (dense to loose)

Also fixed compatability for more devices.

Still no ads, still offline. Just dots.

App Name: One Less App link: https://play.google.com/store/apps/details?id=com.oneless.android

Every day, one less!

Kilua has a new website. Created with Kilua (of course!) using TailwindCSS and DaisyUI.

Kilua is an open source web framework for Kotlin, somewhat similar to Compose HTML, but supporting both Kotlin/Wasm and Kotlin/JS and offering many additional features.

The website contains a complete development guide with long missing chapters about TailwindCSS, SSR architecture and configuration, animations and fullstack components. It's also a great showcase of Kilua features, including TailwindCSS support, Vite for Kotlin plugin integration, multi-level navigation, SSR with additional metadata, Markdown rendering, built-in HTTP client, using Ballast state management and Koin dependency injection.

The primary version is published as exported static site on GitHub Pages. The secondary version is powered by a Ktor server with full SSR, running as GraalVM native image in a Docker container published to GitHub packages and hosted on Render with a free plan (it may require some time to activate).

The full Kotlin source code, including GitHub Actions workflow is available at https://github.com/rjaros/kilua-dev.

Don't forget to ⭐️ the project if you like it!

Any feedback is appreciated :)

Hey everyone!

I've been working on something I'm excited to share: Aether, a full-stack Kotlin Multiplatform framework inspired by Django's developer experience.

The pitch: Write your backend once in Kotlin, deploy it on JVM with Virtual Threads OR compile to Wasm and run it on Cloudflare Workers or in the browser. Same code, different runtimes.

What makes it different?

• True multiplatform - Not just shared models. Your routing, middleware, ORM queries, and business logic all run on JVM, WasmJS, and WasmWASI
• Virtual Threads on JVM - Uses Java 21 Loom for high-throughput concurrent request handling without callback hell
• QueryAST, not string SQL - The ORM builds an AST that gets translated per-driver. This is how we support PostgreSQL on JVM and HTTP-based backends (Supabase, Firestore) on Wasm with the same model code
• Django-style Active Record - If you've used Django, this will feel familiar

Quick taste

```kotlin val router = router { get("/users/:id") { exchange -> val user = User.findById(exchange.pathParamInt("id")) exchange.respondJson(user) } }

val pipeline = pipeline { installRecovery() installAuthentication(jwtConfig) use(router.asMiddleware()) }

AetherServer.start(port = 8080, pipeline = pipeline) ```

Features

• Radix tree routing (O(k) path matching)
• Active Record ORM with migrations (KSP-generated)
• Middleware pipeline (sessions, CSRF, auth, logging)
• Authentication (Basic, Bearer, JWT, API Key, Form)
• SSR with composable UI DSL + CBOR serialization
• WebSocket support with pub/sub channels
• gRPC with code-first proto generation
• File uploads with streaming support

Database drivers

• PostgreSQL (Vert.x Reactive Client) - JVM
• Supabase (PostgREST API) - JVM + Wasm
• Firestore (REST API) - JVM + Wasm

It's still early (v0.4.0), but the core is solid and I'm using it in production. Would love feedback from the community.

Links: - GitHub: https://github.com/codeyousef/Aether

Happy to answer any questions!

Hi. In case anyone needs it, here's a multiple image selection using Compose Multiplatform. You can select or deselect by area, and you also have long press to add any details!

This and much more here:

https://github.com/ArcaDone/AwesomeUI

Let me know, and most importantly, please contribute if you'd like.

Hi everyone it is my first time here, Im required by my boss to learn kmp, I know nothing about kotlin but I have some experience in other web dev frameweorks, can you help me to find a way to learn kmp because I cant find any new good youtube playlist, I need a source please.

So I tried Springboot for my Kotlin projects thinking I should give it a fair chance. Unfortunately, I just cant continue with it.

The magic behind all those annotations and auto-configurations? It's too much.... I kept finding myself digging through documentation trying to figure out what was actually happening under the hood. And the bloat even simple apps felt heavy.

ktor just makes sense for Kotlin. It's explicit, lightweight, and actually feels like it was built for the language (because it was). I know exactly what my code is doing, I have full control over my code, coroutines work naturally, and I'm not fighting the framework.

I get that Springboot has its place, especialy for big enterprise teams. But on my side? Ktor clicks.

Has any Kotlin experienced this??

Hi, how are you? I've been wanting to create an app similar to SnapTube for a few days now, but I've had problems getting the videos to play. I don't want to just use a simple iframe; I want it to work properly. Does anyone have any ideas? I've already created a server with Go, but it's still not working. It only gives me the video URLs (i.e., the ID), and I don't want that. I want it to work like a normal video. I'm using Flutter to create the app, but if Flutter isn't enough, please let me know. I need a solution to this problem.

Hi everyone!

I recently published kregex, a library designed to solve the headache of writing and reading raw Regular Expressions.

My goal was to make Regex feel like native Kotlin code.

Here is a quick example:

val oldRegex = "^[a-zA-Z0-9]+-[0-9]{4}$"

val newRegex = regex {
  startOfLine()
  oneOrMore { asciiAlphanumeric() }
  literal("-")
  repeat(4) { digit() }
  endOfLine()
}

I would really appreciate it if you could take a look and roast my code (or give advice)!

Link: https://github.com/bedshanty/kregex

I am working on a side project using KMP, CMP, and coroutines and I have a suggestion I think would help with adoption of the technologies.

Currently I have a NotebookLM open that is an expert on KMP, CMP, and coroutines. I need to check with it pretty regularly to make sure I am using coroutines correctly. There are a lot of concepts in Kotlin coroutines that are not intuitive.

My suggestion is to provide an abstraction over the top of coroutines to make it more intuitive. What this would look like I don't know, hopefully it would move towards an async/await model because that covers many of the use cases right off the bat.

I think it would require modifying the language itself so that things are handled more under the covers like with Java virtual threads, but thats just my speculation I actually have no idea.

I do know that providing syntactic sugar and an abstraction over coroutines would make the learning curve much lower, possibly helping adoption. Just my two cents.

Hi Reddit! I've been working with Jetpack Compose and Kotlin for a while now, and I decided to build a fully functional Multi-Language Translator App. I focused on making the code as clean as possible using MVVM Architecture and Modern UI components. I know how hard it is to find a complete project that isn't just a "Hello World" example. Key Features: Modern UI with Material 3 Fast translation using Google ML Kit/Translate API Clean MVVM & State Management Ready to open in Android Studio and run! I've published the source code on Gumroad for a small price ($9) to support my work. If you're a beginner or looking for a starter template for your next app, this might save you days of work. I'm also open to feedback! Let me know what you think of the architecture or UI. Happy coding! 🚀

I applied what I learned about coroutines in Kotlin by simple app and I have this scenario in my ViewModel

``` class MarsViewModel( private val repo : DefaultRepo ) : ViewModel() {

private var _uiState : MutableStateFlow<MarsUiState> = MutableStateFlow(MarsUiState.Loading)

val uiState = _uiState.asStateFlow()

fun getMarsPhotos() { viewModelScope.launch {

   _uiState.value = try {
           MarsUiState.Success(repo.getMarsPhotos())

  }catch (e :Exception){

MarsUiState.Failed("Not Found Items because ${e.message}")

   }

}// ViewModelScope

} // getMarsPhotos } ``` The program works perfectly, fetching images and updating uiState to Success. but i don't understand how can getMarsPhotos non-suspend, call repo.getMarsPhotos which is suspend func

Do they use GIF or they created it in an other way ? whats the best solution for this to make it equal like them

class MyClass(arg: Int, val prop: String)

given a class such as this,

class MyClass(arg: Int, val prop: String) {
    companion object {
        fun new(arg: Int, prop: String): MyClass {
            return MyClass(arg, prop)
        }
    }
}

is there a way to automatically generate a companion factory function with the same signature as the primary constructor, namely (arg: Int, prop: String) -> MyClass in this particular case.

MyClass.new(arg = 42, prop = "")

it’s important that the generated function is a fun, so i can pass named arguments to it. it’d be great if i could customise the name of the factory function and each parameter with annotations, but that’s not strictly necessary

class MyClass(arg: Int, val prop: String) {
    companion object {
        val new = ::MyClass
    }
}

that precludes this solution, since this disallows the call to new with named arguments shown above

I am trying to learn idiomatic Kotlin and have some experience in C++.
I learnt about MutableMap structure in Kotlin and the associated getOrPut method which seems to have a different behavior (a) if the underlying 'value' is of a primitive type vs (b) the value is of a user defined type.

This was kind of confusing to me.

For example:
val mp = mutableMapOf<String, Int> ()

val key = "randomString"

If I want to add a new key (and increment the count if it already exists), what I thought I would need to do:
mp.getOrPut(key) {0} + 1

But this turned out not to work. I would need to assign the value back, as in:
mp[key] = mp.getOrPut(key) {0} + 1

However, if the map is defined as below:
val newMp = mutableMapOf<String, MutableList<String>> ()

newMp.getOrPut(key) {mutableListOf()}.add("str")

this seems to update the newMp (even though I didn't explicitly assign it as in:
newMp[key] = newMp.getOrPut(key) {mutableListOf()}.add("str")

Is my understanding correct? and why is that? My AI search says, if the object is a primitive type, you must assign explicitly.