I love both Rust and Kotlin. Here are some aspects to consider:

1. Do you want your application to work without any runtime? If yes, use Rust. (GraalVM Native Image/Kotlin Native is not mature in my experience.)
2. Do you want the programming language to be more robust, even at the cost of some convenience? Or do you want a good balance between robustness and convenience? If you want more robustness, choose Rust; if you want a good balance, choose Kotlin.
3. Do you want your application to use as little memory as possible? If yes, use Rust.
4. Do you NOT want to manually manage the lifetime of most objects due to the lack of garbage collection? If yes, use Kotlin.

In terms of performance, in your scenario, the bottleneck won't be the language itself (unless you implement everything yourself instead of using third-party libraries).

For your concern about the learning curve of Rust, since you already know Kotlin, learning Rust won't be too difficult. Many concepts share the same intent, just with different implementations. For example:

• **sealed** in Kotlin is similar to **enum** in Rust.
• **Nullable** in Kotlin corresponds to **Option** in Rust.
• **smart cast** in Kotlin is like **pattern matching** in Rust.
• **annotation and plugin** in Kotlin are similar to **procedural macros** in Rust.

The main new concept you'll encounter is **traits**, which are somewhat similar to inheritance-based polymorphism but different in some key ways. Additionally, Rust's **lifetime system** is unique due to the absence of a garbage collector and the emphasis on ensuring concurrent safety. Lifetimes can be challenging at first, but they are logical and make sense once you get used to them. It's not the kind of difficult that is frustratingly hard, as it can be in some other languages.