Kotlin in 2026: Your First App in 5 Steps

Getting started with Kotlin, the modern, statically typed programming language, can feel like a daunting task for newcomers, but its pragmatic design and interoperability with Java make it an excellent choice for everything from Android development to server-side applications. We’re in 2026, and Kotlin’s ecosystem has matured significantly, offering developers powerful tools and a vibrant community. Ready to jump in and build something incredible?

1. Install the Java Development Kit (JDK)

Even though Kotlin is its own language, it runs on the Java Virtual Machine (JVM). This means you absolutely need a JDK installed on your machine. I always recommend going with the latest Long-Term Support (LTS) version. As of 2026, that’s JDK 21. Don’t skip this step; it’s the foundation.

To install, head over to the Oracle Java Downloads page or use an open-source distribution like Adoptium Temurin. For Windows, download the appropriate MSI installer. On macOS, use the DMG installer. Linux users can often install via their package manager (e.g., sudo apt install openjdk-21-jdk for Debian/Ubuntu or sudo dnf install java-21-openjdk for Fedora/RHEL).

Once installed, open your terminal or command prompt and type java -version. You should see output similar to this:

openjdk version "21.0.2" 2026-01-16 LTS
OpenJDK Runtime Environment (build 21.0.2+13-LTS)
OpenJDK 64-Bit Server VM (build 21.0.2+13-LTS, mixed mode, sharing)

If you don’t see something similar, double-check your installation and ensure your PATH environment variable is correctly configured to include the JDK’s bin directory. This is a common hiccup for many beginners, and it tripped me up too when I first moved from Python to JVM languages years ago.

Pro Tip: Consider using a Java Version Manager like SDKMAN! (for Linux/macOS) or Chocolatey (for Windows) to easily switch between different JDK versions. This becomes invaluable when you’re working on multiple projects with varying requirements.

Common Mistake: Installing just the Java Runtime Environment (JRE) instead of the full JDK. The JRE only allows you to run Java applications, not compile them or develop with Kotlin. Always ensure you’re getting the JDK.

2. Choose and Install Your Integrated Development Environment (IDE)

While you can write Kotlin in a plain text editor and compile it from the command line, it’s like trying to build a skyscraper with a hammer and nails. You need an IDE. For Kotlin, the undisputed champion is IntelliJ IDEA from JetBrains. They created Kotlin, so their IDE offers the best support, hands down.

Download the Community Edition, which is free and open-source, from the IntelliJ IDEA website. It has everything you need to get started with Kotlin, including excellent code completion, refactoring tools, and debugging capabilities.

Installation is straightforward: follow the prompts for your operating system. Once installed, launch IntelliJ IDEA. The first time you open it, you might be asked to import settings or choose a UI theme. Go with the defaults for now; you can always customize later.

IntelliJ IDEA comes with the Kotlin plugin pre-installed and enabled. You can verify this by going to File > Settings > Plugins (on Windows/Linux) or IntelliJ IDEA > Preferences > Plugins (on macOS). Search for “Kotlin” and ensure it’s checked and enabled.

3. Create Your First Kotlin Project

Now for the exciting part: building your first project. This will be a simple “Hello, World!” application, the traditional starting point for any new language.

1. From the IntelliJ IDEA welcome screen, click “New Project”.
2. In the “New Project” wizard, on the left-hand side, select “Kotlin”.
3. On the right, make sure “JVM | Gradle” is selected under “Project generator”. Gradle is a powerful build automation tool that handles dependencies and compilation for you. Trust me, it’s the right choice.
4. For “Name”, type MyFirstKotlinApp.
5. For “Location”, choose a directory on your computer where you want to store your projects. I usually create a dev/kotlin folder.
6. For “JDK”, ensure it points to the JDK 21 installation you completed in Step 1.
7. Leave “Build system” as “Gradle Kotlin” and “Gradle DSL” as “Kotlin”.
8. Click “Create”.

IntelliJ IDEA will now set up your project, download necessary dependencies via Gradle, and index files. This might take a minute or two, especially the first time. You’ll see a project structure similar to this in the “Project” pane on the left:

MyFirstKotlinApp
├── .gradle
├── .idea
├── build
├── gradle
├── src
│   └── main
│       └── kotlin
│           └── Main.kt
├── build.gradle.kts
├── gradle.properties
├── gradlew
├── gradlew.bat
└── settings.gradle.kts

The file we’re interested in is src/main/kotlin/Main.kt. This is where our Kotlin code will live.

Pro Tip: Always use Gradle for your Kotlin projects, even small ones. It standardizes dependency management and build processes, which saves immense headaches down the line when you start adding libraries or working with teams. I’ve seen too many projects flounder because developers tried to manually manage JARs.

4. Write and Run Your “Hello, World!” Program

Double-click on src/main/kotlin/Main.kt to open it in the editor. You’ll likely see some boilerplate code already there:

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

This is a complete, runnable Kotlin program! The fun main() block is the entry point for your application, similar to public static void main(String[] args) in Java, but much more concise. println() is how you print output to the console.

To run it, you have a few options:

1. Click the green play icon: Look for a small green triangle icon next to the fun main() declaration in the gutter (the left margin of the editor). Click it and select “Run ‘MainKt'”.
2. Right-click in the editor: Right-click anywhere within the Main.kt file and select “Run ‘MainKt'”.
3. Use the Run menu: Go to Run > Run ‘MainKt’ from the top menu bar.

After running, a “Run” tool window will appear at the bottom of IntelliJ IDEA, and you should see the output:

Hello, World!

Process finished with exit code 0

Congratulations! You’ve successfully set up your Kotlin environment and run your first program. That “exit code 0” means everything went smoothly. This is a foundational moment; remember it.

Common Mistake: Forgetting to save. While IntelliJ IDEA often saves automatically, especially when running, make sure your changes are saved if you’re not seeing expected output. A quick Ctrl+S (Cmd+S on macOS) never hurts.

5. Explore Core Kotlin Features

With your environment ready, it’s time to briefly touch upon why Kotlin is so beloved. Here are a few core features that make it a joy to work with:

Null Safety

Kotlin’s type system is designed to eliminate NullPointerExceptions (NPEs), which Tony Hoare famously called his “billion-dollar mistake.”

In Kotlin, types are non-nullable by default:

var name: String = "Alice"
// name = null // This line would cause a compilation error

To allow a variable to hold a null value, you declare its type with a question mark (?):

var nullableName: String? = "Bob"
nullableName = null // This is perfectly fine

When working with nullable types, Kotlin forces you to handle the null case explicitly, either with safe calls (?.), the Elvis operator (?:), or by asserting non-null (!! – use sparingly!).

val length = nullableName?.length // null if nullableName is null, otherwise its length
val nameOrDefault = nullableName ?: "Guest" // "Guest" if nullableName is null

This feature alone drastically reduces bugs and makes your code more robust. I had a client last year whose entire legacy Java codebase was plagued by NPEs, and a partial migration to Kotlin for new modules immediately cut down on runtime errors by over 40% in those sections. It’s a game-changer.

Data Classes

Kotlin’s data classes are a fantastic way to create classes primarily used to hold data. They automatically generate boilerplate code for you, such as equals(), hashCode(), toString(), copy(), and componentN() functions.

data class User(val name: String, val age: Int)

fun main() {
    val user1 = User("Alice", 30)
    val user2 = User("Alice", 30)

    println(user1) // Output: User(name=Alice, age=30)
    println(user1 == user2) // Output: true (equals() is generated)

    val user3 = user1.copy(age = 31)
    println(user3) // Output: User(name=Alice, age=31)
}

This saves an incredible amount of time and makes your code much cleaner compared to writing all those methods manually in Java.

Extension Functions

Extension functions allow you to add new functionality to an existing class without inheriting from the class or using design patterns like Decorator. This is incredibly powerful for making your code more readable and expressive.

fun String.addExclamation(): String {
    return this + "!"
}

fun main() {
    val greeting = "Hello"
    println(greeting.addExclamation()) // Output: Hello!
}

Here, we’ve “extended” the String class with a new method addExclamation(). This is a common pattern for utility functions, and it makes chained calls much more natural. We use this extensively in our internal libraries to add domain-specific methods to standard types, making our codebase feel much more coherent.

Coroutines for Asynchronous Programming

While a deeper dive is beyond this introductory guide, it’s worth mentioning that Kotlin’s built-in support for coroutines simplifies asynchronous programming significantly. They offer a lighter-weight alternative to threads and make complex concurrent operations much easier to reason about.

You’ll encounter coroutines heavily in Android development and server-side applications where non-blocking I/O is critical. They are a core reason many developers prefer Kotlin over Java for modern async tasks.

Kotlin is a language built on developer happiness. It takes the best parts of Java and adds modern features that eliminate common pain points. You’ll find yourself writing less code, with fewer bugs, and enjoying the process more. Keep building small projects, experimenting with different features, and don’t be afraid to break things. That’s how you truly learn.

To continue your learning journey, I highly recommend checking out the official Kotlin Documentation. It’s exceptionally well-written and comprehensive, covering everything from basic syntax to advanced topics like multiplatform development.