Home > Software > How Does String Interpolation Work in Kotlin?

How Does String Interpolation Work in Kotlin?

Anastasios Antoniadis

Updated on:

Explore how string interpolation works in Kotlin, enhancing code readability and efficiency by embedding variables and expressions directly into strings. This article delves into the syntax, usage, and compiler optimizations behind Kotlin’s string interpolation, providing insights and best practices for developers to write cleaner, more maintainable code.


On the journey of learning Kotlin, a statically typed programming language designed to fully interoperate with Java, one feature that stands out for its simplicity and power is string interpolation. String interpolation in Kotlin simplifies the process of embedding variables and expressions into strings, making code more readable and concise compared to traditional string concatenation methods. This article explores the inner workings of string interpolation in Kotlin, its advantages, and how developers can leverage this feature to write cleaner code.

Understanding String Interpolation in Kotlin

String interpolation allows developers to directly insert variables, expressions, or even complex logic into strings without the cumbersome plus operators (+) or the verbose String.format() method. In Kotlin, string interpolation is achieved using template expressions, which consist of a dollar sign ($) followed by a variable name, or a dollar sign followed by an expression in curly braces (${expression}).

Syntax and Basic Usage

The basic syntax for string interpolation in Kotlin is straightforward:

val name = "Kotlin"
val version = 1.4

val message = "Welcome to $name version $version!"
// Output: Welcome to Kotlin version 1.4!

For more complex expressions, curly braces can be used:

val price = 9.99
val taxRate = 0.08
val totalPrice = "Total Price: $${price * (1 + taxRate)}"
// Output: Total Price: $10.7892

In the above example, the expression within the curly braces calculates the total price including tax, and the result is embedded directly into the string.

How It Works

Under the hood, Kotlin’s string interpolation is transformed by the compiler into string concatenation or a StringBuilder operation, depending on the complexity of the template expression. For simple interpolations that involve just a variable, Kotlin might compile it down to a simple concatenation:

// Kotlin source
val message = "Hello, $name!"

// Equivalent Java bytecode (simplified)
String message = "Hello, " + name + "!";

For more complex expressions, or when multiple variables and expressions are interpolated in a single string, Kotlin optimizes this by using a StringBuilder to append the parts of the string:

// Kotlin source
val message = "$greeting, $name! You have ${messages.size} new messages."

// Equivalent Java bytecode (simplified)
String message = new StringBuilder()
    .append(", ")
    .append("! You have ")
    .append(" new messages.")

This optimization ensures that string interpolation is convenient and efficient, avoiding the creation of multiple string objects that is typical with naive string concatenation.

Advantages of String Interpolation

  • Readability: Code that uses string interpolation is easier to read and understand, as it closely resembles the final output.
  • Conciseness: It reduces the verbosity of string manipulation, making code more succinct.
  • Efficiency: The Kotlin compiler optimizes string interpolation to ensure that it is as efficient as possible, using StringBuilder where appropriate.

Best Practices

  • Security: To avoid injection attacks, be cautious when interpolating user input or data from untrusted sources into strings, especially in contexts where the resulting string is executed as code or rendered in a UI.
  • Performance: While Kotlin optimizes string interpolation, for scenarios where performance is critical and strings are concatenated in a loop, consider using StringBuilder directly.


String interpolation is one of Kotlin’s features that significantly improves the developer experience by making string manipulation more intuitive, readable, and efficient. Developers can leverage string interpolation to write cleaner and more maintainable Kotlin code by understanding how it works and following best practices. Whether you’re building simple log messages or crafting complex dynamic queries, string interpolation in Kotlin offers a powerful tool to embed expressions seamlessly into strings.

Anastasios Antoniadis
Follow me
0 0 votes
Article Rating
Notify of
Inline Feedbacks
View all comments
Would love your thoughts, please comment.x