Fix Kotlin Unresolved Reference: println in IntelliJ IDEA

println is part of Kotlin's standard library, so it should work in every correctly configured Kotlin project. An unresolved reference usually means IntelliJ IDEA is not treating the file as part of a configured Kotlin module, the module has no Kotlin standard library dependency, or its JDK/SDK setup is incomplete. You will learn how Kotlin finds built-in functions and how to check a project's essential configuration.

Kotlin code does not run in isolation. A Kotlin source file belongs to a module (or build project), and that module needs the libraries and runtime configuration required to compile it.

println is a top-level function provided by Kotlin's standard library (kotlin-stdlib). It is normally available without an import:

println("Hello")

If the compiler reports that println is unresolved, the problem is generally not the spelling of println. Instead, it indicates that the Kotlin standard library is not available to the module compiling the file, or that the file is outside the module's recognized source directories.

For Kotlin targeting the JVM, a working setup typically includes:

• A Kotlin-enabled module or a Gradle/Maven Kotlin project.
• A configured JDK, which provides the Java runtime and compiler tools used by Kotlin/JVM.
• The Kotlin standard library on the module's compile classpath.
• The .kt file located in a recognized source root, such as src/main/kotlin in a Gradle project.

These pieces are usually configured automatically when you create a Kotlin project in IntelliJ IDEA or import an existing Gradle/Maven project.

Think of a Kotlin source file as a recipe in a kitchen.

• Your .kt file is the recipe.
• The module is the kitchen where the recipe is prepared.
• The JDK is the kitchen equipment needed for Kotlin/JVM work.
• Kotlin's standard library is the pantry containing common ingredients such as println, collections, and utility functions.

Writing println("lol") asks for an ingredient from the pantry. If the kitchen has no pantry connected, IntelliJ and the Kotlin compiler cannot find it. Adding random imports does not fix an unconnected pantry; the project itself must be configured correctly.

The usual Kotlin entry point is a top-level main function:

fun main() {
    println("Hello, Kotlin!")
}

main is where a console application begins. println writes text to standard output and then adds a line break.

Older Kotlin examples may include command-line arguments:

fun main(args: Array<String>) {
    println("Received ${args.size} arguments")
}

Both forms are valid. If arguments are not needed, prefer the simpler version:

fun main() {
    println("lol")
}

You do not normally need this import:

import kotlin.io.println

Kotlin imports its default packages automatically. If that import also cannot be resolved, it further suggests a project dependency or module configuration problem.

Consider this program:

fun main() {
    val message = "lol"
    println(message)
}

Execution proceeds as follows:

1. The Kotlin runtime starts the main function.
2. val message = "lol" creates a read-only variable named message containing the text lol.
3. println(message) calls Kotlin's standard-library output function.
4. The function writes lol to the console and moves to the next line.
5. main finishes, so the program exits.

Before these steps can happen, the compiler must resolve every referenced symbol. It must find println in the Kotlin standard library. If the library is missing from the compile classpath, compilation stops before the program can run.

Although println is often the first Kotlin function beginners use, the same dependency-resolution idea applies throughout real software.

• Command-line tools: Print progress messages, reports, or errors to the terminal.
• Learning and debugging: Temporarily inspect values while understanding program flow.
• Build scripts: Kotlin-based Gradle scripts use Kotlin libraries and Gradle APIs that must be present on the script classpath.
• Backend services: A web service depends on libraries such as Ktor, Spring, or database drivers. Missing dependencies cause unresolved-reference errors just as a missing standard library can.
• Android applications: Android modules require the Android SDK, Kotlin plugin, and Android/Kotlin dependencies to resolve framework and Kotlin code.

For production logging, use the application's logging system rather than leaving many println calls in application code.

In real projects, dependencies are usually declared in a build tool rather than configured manually in IntelliJ module settings.

A minimal Kotlin/JVM Gradle project commonly declares the Kotlin plugin and standard library like this:

// build.gradle.kts
plugins {
    kotlin("jvm") version "2.1.0"
    application
}

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
}

application {
    mainClass.set("MainKt")
}

Its source file would normally be placed here:

src/main/kotlin/Main.kt

fun main() {
    println("Application started")
}

When Gradle is imported or refreshed, IntelliJ reads this configuration and supplies the correct compiler, standard library, and classpath. This approach is more reliable than adding JAR files manually because the configuration can be committed to version control and reproduced by other developers.

In application code, output is often guarded by conditions or replaced with structured logging:

fun processOrder(orderId: String?) {
    if (orderId.isNullOrBlank()) return

    println("Processing order: $orderId")
}

The early return prevents invalid input from reaching later code.

Treating this as an import problem

This is usually not fixed by adding import kotlin.io.println. Kotlin default imports already make println available.

// Usually unnecessary
import kotlin.io.println

If the standard library itself is unavailable, this import may be unresolved too. Configure the module instead.

Creating a plain Java module and adding a Kotlin file

A Java module may have a JDK but no Kotlin support or Kotlin standard-library dependency. Create a Kotlin/JVM project, add Kotlin support to the module, or use Gradle with the Kotlin JVM plugin.

No Project SDK or module SDK

Kotlin/JVM needs a JDK. In IntelliJ IDEA, check File > Project Structure and ensure the project/module uses an installed JDK, not an empty or invalid SDK selection.

Putting the file outside a source root

In a Gradle project, production Kotlin files normally belong under:

src/main/kotlin

A file in an unrelated folder may not be compiled as part of the intended module. Move it into the source directory or mark the intended directory as a Sources Root when appropriate.

Mixing IntelliJ configuration with Gradle configuration

If the project uses Gradle, edit build.gradle.kts and then refresh the Gradle project. Manual IDE-only changes can be overwritten during the next Gradle sync.

Trying to fix the issue by changing main

Both of these are valid:

fun main() { }
fun main(args: Array<String>) { }

Changing the main signature does not normally resolve a missing println; that error concerns library resolution.

• println("text") is a Kotlin standard-library function.
• It is available through Kotlin's default imports; no import is usually needed.
• For Kotlin/JVM, configure a JDK, not just a JRE.
• A Gradle Kotlin source file usually belongs in src/main/kotlin.
• In a Gradle project, declare dependencies in build.gradle.kts, then refresh/sync Gradle.
• Use a simple entry point when no command-line arguments are needed:

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

• If println is unresolved, check project setup before changing application code.
• If a library dependency is unresolved, add it to the build configuration instead of copying JAR files into random folders.

Why is println unresolved in Kotlin?

println comes from Kotlin's standard library. The usual cause is that the file's module does not have Kotlin properly configured, does not include the standard library, has no valid JDK, or is outside a recognized source root.

Do I need to import println in Kotlin?

No. println is available through Kotlin's default imports. Adding an import is normally unnecessary.

Does Kotlin require Java?

Kotlin can target several platforms. For Kotlin/JVM projects in IntelliJ IDEA, you need a JDK because Kotlin compiles to JVM bytecode and uses JVM tooling.

Should I use fun main() or fun main(args: Array<String>)?

Use fun main() when you do not need command-line arguments. Use the version with args when your program reads arguments passed from the command line. Both are valid.

Where should Kotlin files go in a Gradle project?

Production source files usually go in src/main/kotlin. Test files usually go in src/test/kotlin.

How do I add Kotlin support to an existing IntelliJ module?

Use IntelliJ's module/project configuration to add Kotlin support, or preferably migrate/configure the module with Gradle using the Kotlin JVM plugin. Also ensure a JDK is assigned to the project/module.

Why does IntelliJ show errors after I edit build.gradle.kts?

The IDE may not have reloaded the build configuration yet. Refresh the Gradle project so IntelliJ downloads dependencies and updates its classpath.

• Kotlin standard library — The library that provides println, collections, strings, and many everyday Kotlin functions.
• JDK vs JRE — Kotlin/JVM projects require a configured Java Development Kit for compilation and execution tooling.
• Gradle dependencies — The standard way to declare libraries that Kotlin code can reference.
• Source roots — Directories IntelliJ and build tools recognize as compilable application or test code.
• Kotlin main function — The entry point used to start a Kotlin console application.
• Imports and default imports — Explain why many common Kotlin names work without explicit import statements.
• Compile classpath — The set of libraries the compiler searches when resolving functions and types.
• Unresolved reference errors — A compiler diagnostic that usually means a name is misspelled, out of scope, or absent from available dependencies.