Kotlin const vs val: What’s the Difference?

By the end of this page, you will understand that val means a read-only reference, while const val means a compile-time constant in Kotlin. You will learn where const is allowed, what types it supports, why it is more restrictive than val, and how developers typically use each one in real Kotlin codebases.

val and const val are related, but they are not the same thing.

• val means the variable can be assigned once.
• const val means the value is not only assigned once, but is also known at compile time.

val: read-only reference

A val creates a read-only reference. Once a value is assigned, you cannot reassign that variable.

val username = "alice"
// username = "bob" // Error

However, the value assigned to a val does not have to be known at compile time.

val currentTime = System.currentTimeMillis()

This is valid because currentTime is assigned only once, even though Kotlin can only get the value when the program runs.

const val: compile-time constant

A const val is a special kind of .

Think of val as a label on a box that cannot be moved to another box.

• You attach the label once.
• After that, the label must always point to the same thing.
• But the thing inside may have been created at runtime.

Think of const val as a value printed in the instruction manual before the program even starts.

• The value is fixed ahead of time.
• The compiler already knows it.
• It can copy that value directly wherever needed.

So:

• val = fixed reference
• const val = fixed compile-time literal

Basic syntax

val siteName = "Example"
const val APP_NAME = "MyApplication"

Example 1: regular val

val timestamp = System.currentTimeMillis()
println(timestamp)

This works because timestamp is assigned once. Its value is decided when the program runs.

Example 2: const val

const val DEFAULT_PORT = 8080
const val BASE_URL = "https://api.example.com"

These work because the values are compile-time constants.

Example 3: invalid const val

const val createdAt = System.currentTimeMillis() // Error

This fails because function calls are evaluated at runtime, not compile time.

Where can be declared

Consider this code:

const val TAX_RATE = 0.2

fun main() {
    val price = 100.0
    val total = price + (price * TAX_RATE)
    println(total)
}

Step by step

1. const val TAX_RATE = 0.2

   • Kotlin reads this as a compile-time constant.
   • The value 0.2 is fixed and known before execution.

2. val price = 100.0

   • When main() runs, price is created.
   • It cannot be reassigned later.

3. val total = price + (price * TAX_RATE)

   • Kotlin uses price from runtime.
   • It uses TAX_RATE as a constant value.
   • The expression becomes 100.0 + (100.0 * 0.2).

When to use val

Use val for most read-only values in normal application code:

• results from a database query
• user input after validation
• API response data
• generated timestamps
• parsed configuration values

Example:

val userId = request.getParameter("id")
val createdAt = System.currentTimeMillis()

When to use const val

Use const val for fixed values that never change and are known ahead of time:

• API endpoint paths
• intent keys
• database column names
• request timeout defaults
• error codes
• annotation arguments

Example:

const val EXTRA_USER_ID = "extra_user_id"
const val RETRY_LIMIT = 3
const val TABLE_NAME = "users"

Android example

 Keys {
      USER_ID = 
      SESSION_TOKEN = 
}

In real Kotlin projects, developers usually prefer val by default and reserve const val for true constants.

Common patterns

Configuration constants

object Defaults {
    const val PAGE_SIZE = 20
    const val CACHE_DURATION_MINUTES = 60
}

Keys and identifiers

object JsonFields {
    const val NAME = "name"
    const val EMAIL = "email"
}

Companion object constants

class Logger {
    companion object {
        const val TAG = "Logger"
    }
}

Guard clauses with val

 {
     safeName = name ?: 
    println(safeName)
}

1. Thinking val means deeply immutable

val prevents reassignment of the reference, but the object itself may still be mutable.

val numbers = mutableListOf(1, 2, 3)
numbers.add(4) // Valid
// numbers = mutableListOf(5, 6) // Error

Avoid confusion by remembering:

• val protects the variable reference
• it does not automatically make the object immutable

2. Using const with runtime expressions

Broken example:

const val NOW = System.currentTimeMillis()

Why it fails:

• System.currentTimeMillis() is only known at runtime.

Use this instead:

val now = System.currentTimeMillis()

3. Declaring const in the wrong place

var vs vs

Quick rules

• val = assign once
• const val = assign once and known at compile time
• every const val is also effectively a val
• not every val can be const

Use val when

val now = System.currentTimeMillis()
val user = getUser()
val total = price * quantity

Use const val when

const val APP_NAME = "Demo"
const val MAX_RETRIES = 3
const val API_PATH = "/users"

const val rules

• must be known at compile time
• must be primitive or String

Is const the same as val in Kotlin?

No. const val is a compile-time constant, while val is only a read-only reference.

Can I use const inside a function?

No. const val cannot be declared as a local variable inside a function.

Can a val be calculated at runtime?

Yes. A val can store the result of a function call or any runtime expression.

Why would I use const val instead of val?

Use const val when the value is fixed, known at compile time, and needs to behave like a real constant, such as in annotation arguments or shared constant keys.

Can const val hold a list or object?

No. const val only supports primitive types and String.

Is val always immutable?

The reference is immutable, but the object it points to may still be mutable.

• var — contrasts with val because it allows reassignment.
• immutability — helps explain the difference between a read-only reference and a mutable object.
• compile-time constants — the core idea behind const val.
• companion object — one of the valid places where const val can be declared.
• object declarations — another common place to store constants.
• annotations in Kotlin — useful because annotation arguments often require compile-time constants.
• primitive types — important because const val only supports primitives and String.