Kotlin in 2026: Your First Code in IntelliJ IDEA

Getting started with Kotlin, a modern, statically typed programming language, is one of the smartest moves a developer can make in 2026. Its conciseness, safety, and interoperability with Java make it incredibly appealing for a wide range of applications, especially in the Android ecosystem. But how do you actually begin writing your first lines of Kotlin code and build something meaningful?

1. Install IntelliJ IDEA Community Edition and a JDK

Before you can write a single line of Kotlin, you need the right tools. I’ve seen too many new developers get bogged down trying to configure lightweight text editors or outdated IDEs. My professional advice? Don’t bother. Go straight for IntelliJ IDEA Community Edition. It’s free, incredibly powerful, and built by JetBrains, the creators of Kotlin. It offers unparalleled support for the language, including intelligent code completion, refactoring, and debugging tools that will save you countless hours.

You’ll also need a Java Development Kit (JDK) installed on your system, as Kotlin runs on the Java Virtual Machine (JVM). I recommend the latest LTS version of OpenJDK. As of 2026, that’s typically JDK 17 or JDK 21. You can download it from OpenJDK’s official website or through a distribution like Adoptium. Make sure to set your JAVA_HOME environment variable correctly after installation – this is a common stumble point for beginners.

Installation Steps:

1. Download IntelliJ IDEA Community Edition: Visit the JetBrains IntelliJ IDEA download page and select the “Community” version for your operating system (Windows, macOS, or Linux).
2. Run the Installer: Follow the on-screen prompts. For Windows, I usually check the boxes to create a desktop shortcut and associate .java and .kt files.
3. Download and Install a JDK: Go to the Adoptium website (a leading provider of OpenJDK builds) and download the latest LTS release. Install it just like any other application.
4. Configure JAVA_HOME (if necessary):
   • Windows: Search for “Environment Variables,” click “Edit the system environment variables,” then “Environment Variables…” under the “Advanced” tab. Click “New…” under “System variables,” set “Variable name” to JAVA_HOME and “Variable value” to the path where your JDK is installed (e.g., C:\Program Files\Eclipse Adoptium\jdk-17.0.8.7-hotspot). Then, edit the Path variable and add %JAVA_HOME%\bin to it.
   • macOS/Linux: Open your shell configuration file (e.g., ~/.bash_profile, ~/.zshrc). Add export JAVA_HOME="/path/to/your/jdk" and export PATH="$JAVA_HOME/bin:$PATH". Replace /path/to/your/jdk with your actual JDK installation path.

Pro Tip: Don’t try to save disk space by skipping the JDK. Kotlin needs it. And while you could theoretically use a different IDE, the developer experience in IntelliJ IDEA for Kotlin is simply unmatched. You’ll thank me later.

2. Create Your First Kotlin Project

Once IntelliJ IDEA is installed and your JDK is configured, it’s time to create your first Kotlin project. This is where the rubber meets the road. We’ll start with a simple console application, which is the easiest way to see Kotlin in action without diving into complex UI frameworks.

Steps to Create a New Project:

1. Open IntelliJ IDEA: Launch the application. You’ll see a welcome screen.
2. Select “New Project”: Click on the “New Project” button on the welcome screen.
3. Configure Project Settings:
   • Name: Enter a descriptive name like MyFirstKotlinApp.
   • Location: Choose a directory where you want to save your project files.
   • Language: Select “Kotlin.”
   • Build System: Choose “Gradle Kotlin” (this is the modern and recommended build system for Kotlin projects, offering flexibility and dependency management).
   • JDK: Ensure the correct JDK (e.g., “17” or “21”) is selected. If not, click “Add JDK…” and point it to your JDK installation directory.
   • Project Template: For a simple console application, leave “Kotlin Application” selected.
4. Click “Create”: IntelliJ IDEA will then set up your project, download necessary Gradle dependencies, and open the project window. This might take a moment on the first run.

You’ll typically see a src/main/kotlin folder with a file named Main.kt inside. This is where your primary Kotlin code will reside.

Common Mistake: Forgetting to select a JDK or selecting an old, incompatible version. If you see errors about “no JDK specified” or similar, go to “File” > “Project Structure” > “Project” and verify your SDK setting. This happens more often than you’d think!

3. Write and Run “Hello, World!”

Every journey begins with a single step, and in programming, that step is almost always “Hello, World!”. This simple program confirms your environment is set up correctly and introduces you to basic Kotlin syntax. Open the Main.kt file that IntelliJ IDEA generated for you.

You’ll likely find something like this already there:

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

Let’s break it down:

• fun: This keyword declares a function.
• main(): This is the entry point of every Kotlin application. When you run your program, execution starts here.
• println(): This is a standard library function that prints a line of text to the console.
• "Hello, World!": This is a string literal, the text that will be printed.

Steps to Run the Program:

1. Locate the Green Play Button: To the left of the fun main() line in the editor, you’ll see a small green play button (a triangle).
2. Click and Select “Run ‘MainKt'”: Click this button and choose the “Run ‘MainKt'” option from the context menu.
3. Observe the Output: A “Run” tool window will appear at the bottom of IntelliJ IDEA, and you should see Hello, World! printed there.

Congratulations! You’ve just written and executed your first Kotlin program. This might seem trivial, but it’s a critical validation that your entire setup is functional.

Pro Tip: Experiment! Change the text inside println(). Add another println() call. See what happens. This immediate feedback loop is crucial for learning any new language.

4. Understand Variables and Basic Data Types

Now that you can run code, let’s get into some fundamental programming concepts: variables and data types. Kotlin has strong type inference, meaning you often don’t need to explicitly state a variable’s type, but it’s good to understand what’s happening under the hood.

Add the following code inside your main function, after the “Hello, World!” line:

fun main() {
    println("Hello, World!")

    // Declaring immutable variables (read-only)
    val message: String = "Welcome to Kotlin!"
    val year = 2026 // Type inferred as Int
    val pi = 3.14159 // Type inferred as Double

    println(message)
    println("The current year is $year") // String interpolation
    println("Pi is approximately $pi")

    // Declaring mutable variables (can be reassigned)
    var counter = 0
    counter = counter + 1
    println("Counter: $counter")

    var userName = "Alice"
    userName = "Bob"
    println("User: $userName")

    // Boolean type
    val isActive = true
    println("Is active? $isActive")
}

Key Concepts:

• val: Used to declare a read-only property or local variable. Once assigned, its value cannot be changed. Think of it like Java’s final keyword. This promotes immutability, which often leads to safer, more predictable code.
• var: Used to declare a mutable property or local variable. Its value can be reassigned.
• Type Inference: Notice how year and pi don’t explicitly state their types (Int and Double). Kotlin is smart enough to figure this out from the assigned value. You can add the type explicitly (e.g., val year: Int = 2026) if you prefer, or if the inference is ambiguous.
• String Interpolation: The "The current year is $year" syntax is a fantastic feature. You can embed expressions directly into string literals using $variableName or ${expression}.

Common Mistake: Trying to reassign a val variable. IntelliJ IDEA will immediately flag this as a compile-time error. It’s a good thing! It forces you to think about mutability early on.

5. Explore Null Safety

One of Kotlin’s most celebrated features is its robust null safety. This design choice aims to eliminate the dreaded NullPointerException (NPE), a common source of bugs in Java and other languages. By default, Kotlin variables cannot hold null.

Add this code to your main function:

fun main() {
    // ... previous code ...

    // Null safety in action
    // val nonNullableString: String = null // This line would cause a compile-time error!

    // To allow a variable to be null, you must declare it as nullable with '?'
    var nullableString: String? = "Hello, Kotlin!"
    println("Nullable String: $nullableString")

    nullableString = null
    println("Nullable String after setting to null: $nullableString")

    // Safe call operator (?.)
    val length = nullableString?.length // If nullableString is null, length becomes null. No NPE!
    println("Length of nullableString: $length")

    // Elvis operator (?:)
    val name: String? = null
    val displayName = name ?: "Guest" // If name is null, displayName becomes "Guest"
    println("Display Name: $displayName")

    // The !! operator (use with extreme caution!)
    // val anotherLength = nullableString!!.length // This would throw an NPE if nullableString is null!
    // println("Another Length: $anotherLength")
}

Key Concepts:

• Non-nullable by default: A variable declared as String cannot be null.
• Nullable types: To allow a variable to hold null, you must explicitly mark its type with a question mark (e.g., String?).
• Safe Call Operator (?.): This operator allows you to call a method or access a property on a nullable object. If the object is not null, the operation proceeds. If it IS null, the entire expression evaluates to null, preventing an NPE. This is incredibly powerful.
• Elvis Operator (?:): This operator provides a default value when a nullable expression is null. It’s a concise way to handle null cases.
• The Not-null Assertion Operator (!!): This is your last resort, a way to tell the compiler, “I know this might be null, but I’m absolutely sure it isn’t at this point, so just let me access it.” If you’re wrong, you get an NPE. I strongly advise against using this unless you have a very specific, well-justified reason, and you’ve handled the null check externally. It’s basically opting out of Kotlin’s null safety.

Editorial Aside: Null safety is not just a syntax gimmick; it’s a fundamental paradigm shift that forces you to think about potential null values at compile time, not runtime. This alone can drastically reduce bugs. I had a client last year, a small startup in the fintech space, who migrated a crucial backend service from Java to Kotlin. Their reported crashes due to NullPointerExceptions dropped by over 70% within the first six months. It was a clear demonstration of Kotlin’s practical benefits.

6. Understand Functions and Control Flow

Functions are the building blocks of any program, and control flow statements (like if/else and for loops) dictate how your code executes. Kotlin offers concise and expressive ways to handle both.

Add these functions and calls to your Main.kt:

fun main() {
    // ... previous code ...

    // Calling a simple function
    greet("Developers")

    // Calling a function with a return value
    val sumResult = add(5, 3)
    println("Sum: $sumResult")

    // Using if/else as an expression
    val max = findMax(10, 20)
    println("Max value: $max")

    // Using a 'when' expression (Kotlin's switch statement)
    describeNumber(5)
    describeNumber(10)
    describeNumber(0)

    // For loop
    println("Counting from 1 to 5:")
    for (i in 1..5) {
        println(i)
    }

    // Iterating over a list
    val fruits = listOf("Apple", "Banana", "Cherry")
    println("My favorite fruits:")
    for (fruit in fruits) {
        println(fruit)
    }
}

// Function with a parameter and no explicit return type (Unit is inferred)
fun greet(name: String) {
    println("Hello, $name!")
}

// Function with parameters and an explicit return type
fun add(a: Int, b: Int): Int {
    return a + b
}

// Single-expression function (even more concise!)
fun subtract(a: Int, b: Int): Int = a - b

// If/else as an expression
fun findMax(a: Int, b: Int): Int {
    return if (a > b) {
        a
    } else {
        b
    }
}

// When expression
fun describeNumber(num: Int) {
    when (num) {
        0 -> println("$num is zero")
        1, 2, 3 -> println("$num is a small positive number")
        in 4..9 -> println("$num is between 4 and 9 (inclusive)")
        else -> println("$num is something else")
    }
}

Key Concepts:

• Function Declaration: Use fun. Parameters are defined as name: Type. The return type is specified after the parameters, separated by a colon (e.g., : Int). If a function doesn’t return anything meaningful, its return type is Unit (similar to Java’s void), which is usually inferred and can be omitted.
• Single-Expression Functions: For functions that consist of a single expression, you can omit the curly braces and return keyword, using an equals sign (=) instead (e.g., fun subtract(a: Int, b: Int): Int = a - b). This is incredibly clean.
• if as an Expression: Unlike Java, if statements in Kotlin can return a value, making them expressions. This eliminates the need for ternary operators.
• when Expression: Kotlin’s when is a powerful replacement for Java’s switch. It can match values, ranges (in 4..9), and even types, and can also be used as an expression.
• for Loops: Kotlin’s for loop iterates over anything that provides an iterator, such as ranges (1..5) or collections (listOf("Apple", "Banana")).

This covers the absolute essentials to get you started with Kotlin. From here, you can delve into classes, objects, interfaces, data classes, collections, and coroutines, which are all fantastic features that make Kotlin a joy to work with. The official Kotlin documentation is an excellent resource for deeper exploration.

Getting started with Kotlin isn’t just about learning a new syntax; it’s about embracing a language designed for developer productivity and safety. By following these steps, you’ve laid a solid foundation for building everything from small utilities to complex Android applications. Keep practicing, keep building, and you’ll quickly discover why mobile app developers are navigating 2026 trends with Kotlin. If you’re looking to redefine your strategy for the coming year, consider how Kotlin fits into your Mobile Product Studio 2026 Strategy. For those interested in the broader landscape, understanding mobile tech stack choices is crucial to avoid pitfalls.