How to Generate a Random Number in Kotlin

By the end of this page, you will understand how random number generation works in Kotlin, how to generate integers within a range, how range boundaries behave, and how to wrap this logic in a reusable function for everyday coding tasks.

In Kotlin, random number generation is commonly done with the standard library's random utilities, especially kotlin.random.Random and range helpers like IntRange.random().

For beginners, the key idea is this: you usually do not generate any possible integer and then manually limit it. Instead, Kotlin lets you ask for a random number inside a specific range.

For example:

val n = (0..10).random()

This returns a random Int from 0 to 10, inclusive.

If you need two parameters, such as min and max, you can create a range from them:

fun randomBetween(min: Int, max: Int): Int {
    return (min..max).random()
}

This matters in real programming because random values are used in many places:

• games
• simulations
• testing
• shuffling
• selecting sample data
• generating temporary values

A very important detail is whether the upper bound is included or excluded. Kotlin ranges like min..max are inclusive, which means both ends are possible results.

Kotlin also supports Random.nextInt(from, until), where the second argument is exclusive:

val n = Random.nextInt(0, 10)

This returns a number from 0 up to 9, not 10.

So there are two common styles in Kotlin:

• (min..max).random() → inclusive range
• Random.nextInt(min, maxExclusive) → exclusive upper bound

Choosing the right one prevents off-by-one bugs.

Think of a range like a numbered row of boxes.

If you write:

2..5

you are creating these boxes:

• 2
• 3
• 4
• 5

When you call .random(), Kotlin picks one box at random.

Now think of Random.nextInt(from, until) as a door rule:

• from can enter
• until cannot enter

So:

Random.nextInt(2, 5)

can return:

• 2
• 3
• 4

but not 5.

This simple inclusive-vs-exclusive difference is the main thing to remember.

Basic range syntax

val number = (0..10).random()

This returns a random integer between 0 and 10, including both values.

Reusable function

fun randomBetween(min: Int, max: Int): Int {
    return (min..max).random()
}

fun main() {
    println(randomBetween(1, 6))
}

This is useful when you want a function that works like rand(min..max).

Using Random.nextInt

import kotlin.random.Random

fun main() {
    val number = Random.nextInt(1, 7)
    println(number)
}

This returns a random number from to because is excluded.

Consider this code:

fun randomBetween(min: Int, max: Int): Int {
    require(min <= max) { "min must be less than or equal to max" }
    return (min..max).random()
}

fun main() {
    val value = randomBetween(3, 8)
    println(value)
}

Step by step:

1. main() starts running.
2. randomBetween(3, 8) is called.
3. Inside the function, require(min <= max) checks whether 3 <= 8.
4. The condition is true, so execution continues.
5. (min..max) creates the range 3..8.
6. .random() picks one integer from this range.
7. Possible values are 3, 4, 5, 6, , or .

Random numbers appear in many common programming tasks.

Games

val diceRoll = (1..6).random()

Used for dice, enemy damage, loot drops, or random movement.

Picking a random item

val names = listOf("Ana", "Ben", "Cara")
val randomName = names.random()

Useful for selecting a winner, rotating tasks, or sampling data.

Temporary test data

val age = (18..65).random()

Helpful when generating fake users or mock records.

Simulations

You may need random values for weather, traffic, queue lengths, or experiments.

Security note

For passwords, tokens, or cryptographic secrets, ordinary random helpers are usually not the right tool. Use a secure randomness source when security matters.

In real Kotlin codebases, developers often wrap random logic in small helper functions so the rest of the app stays readable.

Validation before generating

fun randomBetween(min: Int, max: Int): Int {
    require(min <= max) { "min must be less than or equal to max" }
    return (min..max).random()
}

This is a common validation pattern.

Guard clauses

Developers often reject bad input early:

fun randomDiscount(min: Int, max: Int): Int {
    require(min >= 0) { "min cannot be negative" }
    require(max <= 100) { "max cannot be greater than 100" }
    require(min <= max) { "min must be <= max" }
    return (min..max).random()
}

Reproducible randomness for testing

In tests, developers may use a specific Random instance with a fixed seed so results are repeatable.

import kotlin.random.Random

 rng = Random()
 value = rng.nextInt(, )

1. Forgetting whether the upper bound is included

Broken expectation:

import kotlin.random.Random

val n = Random.nextInt(0, 10)
println(n) // many beginners expect 10 to be possible

10 will not be returned here.

Fix:

val n = (0..10).random()

or

val n = Random.nextInt(0, 11)

2. Not validating min and max

Broken code:

fun randomBetween(min: Int, max: Int): Int {
    return (min..max).random()
}

If min > max, this may fail.

.random() on a range vs Random.nextInt()

• Use (min..max).random() when you want code that clearly says “pick from this inclusive range.”

Quick reference

Inclusive random integer

val n = (min..max).random()

Returns a value from min to max, inclusive.

Exclusive upper bound

import kotlin.random.Random
val n = Random.nextInt(min, maxExclusive)

Returns a value from min up to maxExclusive - 1.

Reusable helper

fun randomBetween(min: Int, max: Int): Int {
    require(min <= max)
    return (min..max).random()
}

Important rules

• min..max includes both ends.
• Random.nextInt(from, until) excludes until.
• Validate input when building helper functions.
• Random values can repeat.
• Use secure randomness for security-sensitive tasks.

How do I generate a random number between two values in Kotlin?

Use an inclusive range:

val n = (min..max).random()

Is the maximum value included in Kotlin random ranges?

Yes, with (min..max).random(), both min and max are possible.

What is the difference between .random() and Random.nextInt() in Kotlin?

.random() on a range is inclusive. Random.nextInt(from, until) uses an exclusive upper bound.

How do I make a reusable random function in Kotlin?

Create a helper:

fun randomBetween(min: Int, max: Int): Int {
    require(min <= max)
    return (min..max).random()
}

Can Kotlin generate random items from a list?

Yes:

val item = myList.random()

• Ranges in Kotlin — random integers are often generated from ranges like 1..10.
• Functions in Kotlin — useful for wrapping random logic into reusable helpers.
• Input validation — important for checking that min is not greater than max.
• Collections in Kotlin — lists and arrays also support random element selection.
• Exceptions and require — used to fail early when invalid arguments are passed.
• Kotlin standard library — provides built-in helpers such as .random() and Random.nextInt().
• Off-by-one errors — very relevant when working with inclusive and exclusive bounds.