Main function as entry point in Kotlin - Deep Dive

Overview - Main function as entry point

What is it?

The main function in Kotlin is the starting point where the program begins running. It is a special function that the Kotlin runtime looks for to start executing your code. Without a main function, the program has no defined place to begin. It usually looks like fun main() { } and contains the instructions the program will follow first.

Why it matters

The main function exists to tell the computer where to start running your program. Without it, the computer wouldn't know which part of your code to execute first, making your program useless. It organizes your code's flow and ensures your program runs predictably. This is like having a front door to a house; without it, no one knows how to enter.

Where it fits

Before learning about the main function, you should understand basic Kotlin syntax and functions. After mastering the main function, you can learn about program structure, classes, and how to organize larger Kotlin applications.

Mental Model

Core Idea

The main function is the front door of your Kotlin program where execution always begins.

Think of it like...

Think of your Kotlin program as a play, and the main function is the stage entrance where actors first appear to start the show.

┌───────────────┐
│ Kotlin Program│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  main() func  │  <-- Entry point where execution starts
└───────────────┘
       │
       ▼
┌───────────────┐
│ Other functions│
│ and statements │
└───────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding Kotlin Functions

Concept: Learn what a function is and how to write one in Kotlin.

In Kotlin, a function is a block of code that performs a task. You write a function using the fun keyword, followed by the function name and parentheses. For example: fun greet() { println("Hello!") } This function prints a greeting when called.

Result

You can create reusable blocks of code that perform specific tasks.

Understanding functions is essential because the main function itself is just a special function where your program starts.

2

Foundation

What is the Main Function?

Concept: Introduce the main function as the program's starting point.

The main function is a special function named main that Kotlin looks for to start running your program. It usually looks like this: fun main() { println("Program started") } When you run your Kotlin program, this function runs first.

Result

Your program has a clear starting point where execution begins.

Knowing that main is the entry point helps you organize your code and understand program flow.

3

Intermediate

Main Function with Arguments

🤔Before reading on: do you think the main function can receive input from outside the program? Commit to your answer.

Concept: Learn how main can accept command-line arguments as input.

Kotlin's main function can accept an array of strings as arguments, which lets users pass information when running the program. It looks like this: fun main(args: Array) { println("Number of arguments: ${args.size}") for (arg in args) { println(arg) } } This prints how many arguments were passed and lists them.

Result

Your program can receive input from outside, making it more flexible.

Understanding arguments in main lets you build programs that respond to user input or commands.

4

Intermediate

Main Function Variants

🤔Before reading on: do you think Kotlin allows main functions without parameters? Commit to your answer.

Concept: Explore different valid forms of the main function in Kotlin.

Kotlin allows two main function forms: 1. Without parameters: fun main() { println("Hello") } 2. With parameters: fun main(args: Array) { println("Hello with args") } Both are valid entry points. The version with args is useful for command-line input.

Result

You know how to write main functions that fit your program's needs.

Knowing these variants helps you choose the right main function style for your application.

5

Advanced

Main Function in Kotlin Scripts and JVM

🤔Before reading on: do you think the main function behaves the same in Kotlin scripts and JVM applications? Commit to your answer.

Concept: Understand how main works differently in Kotlin scripts versus JVM applications.

In Kotlin JVM applications, main is the entry point for the Java Virtual Machine to start execution. In Kotlin scripts (.kts files), you don't need a main function; the script runs top to bottom. However, when compiling to JVM bytecode, main is required to start the program. Example JVM main: fun main() { println("Running on JVM") } In scripts, just write: println("Running script")

Result

You understand when and why main is necessary depending on how you run Kotlin code.

Knowing this prevents confusion when switching between scripts and full applications.

6

Expert

Main Function and Kotlin Native/Multiplatform

🤔Before reading on: do you think the main function is always the same across all Kotlin platforms? Commit to your answer.

Concept: Explore how main functions differ in Kotlin Native and multiplatform projects.

In Kotlin Native and multiplatform projects, the main function can have platform-specific signatures. For example, Kotlin Native requires main to return an Int for exit codes: fun main(): Int { println("Native main") return 0 } Multiplatform projects may define expect/actual main functions to handle platform differences. This flexibility allows Kotlin to run on many platforms with proper entry points.

Result

You can write Kotlin programs that run correctly on multiple platforms with proper main functions.

Understanding platform-specific main functions is key to mastering Kotlin multiplatform development.

Under the Hood

When you run a Kotlin program on the JVM, the Kotlin compiler generates a Java class with a static main method that the JVM calls to start execution. This static main method calls your Kotlin main function. The args parameter corresponds to the command-line arguments passed to the JVM. For Kotlin Native, the compiler generates platform-specific entry points that call your main function. This setup ensures your Kotlin code integrates smoothly with the underlying platform's execution model.

Why designed this way?

The main function design follows the conventions of the underlying platform (like JVM or Native) to ensure compatibility and ease of use. JVM requires a static main method as an entry point, so Kotlin adapts by generating this method automatically. Allowing main to accept arguments matches common programming practices for command-line tools. The design balances simplicity for beginners with flexibility for advanced use cases.

┌─────────────────────────────┐
│ Kotlin Source Code          │
│ fun main(args: Array<String>)│
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│ Kotlin Compiler             │
│ Generates JVM class with    │
│ static main(String[] args)  │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│ JVM Runtime                 │
│ Calls static main method    │
│ Starts program execution    │
└─────────────────────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Is it true that Kotlin programs can run without a main function? Commit to yes or no.

Common Belief: Some people think Kotlin programs can run without a main function because scripts don't require it.

Reality: While Kotlin scripts run top to bottom without main, compiled Kotlin applications targeting JVM or Native require a main function as the entry point.

Why it matters: Confusing scripts with applications can cause runtime errors or programs that never start when compiled.

Quick: Do you think the main function must always have arguments? Commit to yes or no.

Common Belief: Many believe main must always accept arguments like args: Array.

Reality: Kotlin allows main functions both with and without arguments; both are valid entry points.

Why it matters: Assuming arguments are mandatory can lead to unnecessary complexity or confusion when writing simple programs.

Quick: Is the main function the same on all Kotlin platforms? Commit to yes or no.

Common Belief: Some think the main function signature and behavior are identical across JVM, Native, and multiplatform Kotlin.

Reality: Main function signatures and requirements differ by platform, such as returning Int on Native or using expect/actual in multiplatform.

Why it matters: Ignoring platform differences can cause build failures or runtime issues in multiplatform projects.

Expert Zone

1

In Kotlin JVM, the main function is compiled into a static method inside a class named after the file or object, which affects reflection and interop.

2

Kotlin allows suspend main functions for coroutine support, enabling asynchronous code to run at program start without blocking.

3

In multiplatform projects, expect/actual declarations for main allow platform-specific entry points while sharing common logic.

When NOT to use

The main function is not used in Kotlin scripts where code runs top to bottom without an explicit entry point. For Android apps, the entry point is different (Activity lifecycle methods), so main is not used. For serverless functions or frameworks, custom entry points replace main. Use platform or framework-specific entry points instead.

Production Patterns

In production Kotlin JVM applications, main often delegates to a framework or dependency injection container to start the app. For CLI tools, main parses arguments and calls command handlers. In multiplatform projects, main is split using expect/actual to handle platform-specific startup logic cleanly.

Connections

Program Counter (CPU Architecture)

The main function is the software-level equivalent of the CPU's program counter starting at the first instruction.

Understanding main as the program's starting point mirrors how CPUs begin execution, linking software structure to hardware operation.

Operating System Process Entry Point

Main function corresponds to the OS process entry point where the OS hands control to the program.

Knowing how OS launches programs helps understand why main must exist and how arguments are passed from OS to program.

Theatre Play Script

Main function is like the opening scene that sets the stage for the entire play.

Recognizing main as the start of a story helps grasp program flow and sequencing.

Common Pitfalls

#1 Writing a Kotlin application without a main function.

Wrong approach:

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

// No main function defined

Correct approach:

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

Root cause:

Not understanding that compiled Kotlin applications require a main function as the entry point.

#2 Defining main with incorrect parameter type.

Wrong approach:

fun main(args: List) {
println(args.size)
}

Correct approach:

fun main(args: Array) {
println(args.size)
}

Root cause:

Confusing Kotlin's main function signature with other collection types; main must accept Array.

#3 Using main function in Android app as entry point.

Wrong approach:

fun main() {
println("Start app")
}
// Trying to run Android app from main

Correct approach:

// Android apps start with Activity lifecycle methods, not main function

Root cause:

Misunderstanding platform-specific entry points; Android uses Activities, not main.

Key Takeaways

The main function is the required starting point where Kotlin programs begin execution.

Kotlin allows main functions both with and without command-line arguments for flexibility.

Different Kotlin platforms may require different main function signatures or entry points.

Understanding main helps organize program flow and connect with underlying platform execution.

Confusing scripts, applications, or platforms leads to common errors around main function usage.