Kotlin Void vs Unit vs Nothing: Differences, Uses, and Examples

By the end of this page, you will understand what Void, Unit, and Nothing mean in Kotlin, when each one appears, and why they are not interchangeable. You will also learn how these types are used in function return types, Java interoperability, and expressions that never complete normally.

Kotlin uses Unit, Nothing, and sometimes Void for different purposes, even though they can look related.

Unit

Unit is Kotlin's way of saying:

"This function finishes normally, but it does not return any useful value."

It is similar to Java's void, but with one important difference: Unit is a real type in Kotlin. It has exactly one value: Unit.

fun printMessage(): Unit {
    println("Hello")
}

In most Kotlin code, you omit it:

fun printMessage() {
    println("Hello")
}

Kotlin still treats that function as returning Unit.

Think of a function like a delivery trip.

• Unit means: the driver came back, but there was no package to deliver.
• Nothing means: the driver never comes back at all.
• Void means: you are working with another company's paperwork system (Java), and they use a special form named Void.

So even though all three may look like "no value," they describe very different situations:

• one finishes normally
• one never finishes normally
• one mostly exists to match Java APIs

Core syntax

Unit

fun log(message: String): Unit {
    println(message)
}

Usually written without the explicit return type:

fun log(message: String) {
    println(message)
}

Nothing

fun crash(): Nothing {
    throw RuntimeException("Something went wrong")
}

Void

fun javaStyle(): Void? {
    return null
}

This is uncommon in Kotlin and usually only appears when matching Java APIs.

Consider this example:

fun getUsername(input: String?): String {
    return input ?: throw IllegalArgumentException("Username cannot be null")
}

Now trace it.

Case 1: input is not null

getUsername("alice")

Step by step:

1. The function receives "alice".
2. Kotlin checks input ?: ....
3. Since input is not null, the left side is used.
4. The function returns "alice".
5. The function completes normally.

Case 2: input is null

getUsername(null)

Step by step:

1. The function receives null.
2. Kotlin checks input ?: ....
3. Since is , Kotlin evaluates the right side.

Where Unit is used

Unit appears in functions that perform actions:

• logging
• printing output
• saving data
• sending analytics events
• updating UI state
• writing files

Example:

fun saveUser(user: User) {
    repository.save(user)
}

The function does something useful, but there is no meaningful value to return.

Where Nothing is used

Nothing is common in code paths that must stop execution:

• validation failures
• impossible states
• helper functions that always throw
• program termination wrappers

Example:

fun requireAdmin(isAdmin: Boolean): Nothing {
    throw IllegalAccessException("Admin access required")
}

A more realistic pattern is a helper used conditionally:

In real Kotlin projects, developers usually follow these patterns.

Unit for side-effect functions

Most application code uses Unit implicitly:

fun updateProfile(profile: Profile) {
    validate(profile)
    api.save(profile)
}

This is the normal choice for command-style functions.

Nothing for guard clauses and fail-fast code

A common pattern is writing helper functions that stop execution:

fun failValidation(message: String): Nothing {
    throw IllegalArgumentException(message)
}

Then using them inside expressions:

val email = inputEmail ?: failValidation("Email is required")

This is especially useful for:

• validation
• null checking
• impossible branches
• exhaustive when handling

1. Using Void instead of Unit in Kotlin code

Broken style:

fun logMessage(): Void? {
    println("Hello")
    return null
}

Better:

fun logMessage() {
    println("Hello")
}

Why this is a mistake:

• Void is not idiomatic Kotlin
• it often forces null
• it makes APIs less natural

2. Thinking Unit means null

Unit is a real value, not the same as null.

val result: Unit = 

Quick reference

Unit

• Means: no meaningful return value
• Function completes normally
• Kotlin's usual replacement for Java void
• Has one value: Unit
• Usually omitted in function declarations

fun printName() {
    println("Sam")
}

Nothing

• Means: no value can ever be returned
• Function never completes normally
• Used for throw, fatal errors, infinite loops
• Has no values

fun fail(): Nothing {
    throw IllegalStateException("Failed")
}

Void

• Means: Java interop type java.lang.Void
• Rare in Kotlin-first code
• Mostly used in Java generic APIs
• Often appears as with

What is the difference between Unit and Nothing in Kotlin?

Unit means a function finishes normally but has no meaningful result. Nothing means a function never finishes normally, such as one that always throws an exception.

Is Kotlin Unit the same as Java void?

They are similar in purpose, but not identical. Unit is a real type with one value, while Java void is not a normal type you can use as a value.

When should I use Void in Kotlin?

Usually only when working with Java APIs that explicitly require Void, especially generic types like Callable<Void>.

Why does throw work inside expressions in Kotlin?

Because throw has type Nothing. Kotlin knows that branch never returns, so it can fit into expressions expecting another type.

Can a function returning Nothing return null?

null

Represents the absence of a value. It is often confused with Unit, but they mean different things.

Nullable types

Understanding String? and null safety helps explain why Nothing is useful in expressions like value ?: throw ....

Exceptions

Nothing is closely related to throwing exceptions because exception-only functions never return normally.

Function return types

This topic is fundamentally about how Kotlin models what a function gives back to its caller.

Java interoperability

Void makes the most sense when you see how Kotlin maps Java types and APIs.

Elvis operator

The Elvis operator (?:) commonly uses Nothing on the right-hand side for validation and fail-fast code.

Type inference

Kotlin can infer Unit and can also reason about Nothing in expressions and control flow.