How Kotlin compiles to JVM bytecode - Mechanics & Internals

Overview - How Kotlin compiles to JVM bytecode

What is it?

Kotlin is a modern programming language that runs on the Java Virtual Machine (JVM). When you write Kotlin code, it is transformed into JVM bytecode, which the JVM understands and executes. This process allows Kotlin programs to run anywhere Java runs, using the same underlying platform.

Why it matters

Without compiling Kotlin to JVM bytecode, Kotlin programs could not run on the JVM, losing compatibility with the vast Java ecosystem. This compilation bridges Kotlin's modern features with the mature, widely-used JVM platform, enabling developers to write expressive code that runs efficiently on many devices and servers.

Where it fits

Before learning this, you should understand basic Kotlin syntax and the JVM concept. After this, you can explore Kotlin's interoperability with Java, advanced JVM optimizations, and Kotlin Native for compiling to other platforms.

Mental Model

Core Idea

Kotlin source code is translated into JVM bytecode, a low-level set of instructions the JVM executes, enabling Kotlin programs to run on any JVM platform.

Think of it like...

It's like writing a recipe in your native language (Kotlin), then translating it into a universal cooking language (JVM bytecode) that any chef (JVM) anywhere can understand and follow.

Kotlin Source Code
      ↓
[Kotlin Compiler]
      ↓
  JVM Bytecode (.class files)
      ↓
[Java Virtual Machine]
      ↓
  Program runs on any JVM platform

Build-Up - 7 Steps

1

Foundation

What is JVM Bytecode

Concept: Introduce JVM bytecode as the language the JVM understands.

JVM bytecode is a set of instructions designed for the Java Virtual Machine. It is not human-readable like Kotlin or Java code but is a low-level, platform-independent code that the JVM executes. Every Java or Kotlin program running on the JVM is first compiled into this bytecode.

Result

You understand that JVM bytecode is the bridge between high-level Kotlin code and the JVM's execution engine.

Knowing JVM bytecode is the target of Kotlin compilation helps you see how Kotlin runs on the JVM and why it can interoperate with Java.

2

Foundation

Role of the Kotlin Compiler

Concept: Explain how the Kotlin compiler transforms Kotlin code into JVM bytecode.

The Kotlin compiler reads your Kotlin source files and translates them into JVM bytecode. This process includes syntax checking, optimization, and generating .class files that contain the bytecode. These files are then ready to be run by the JVM.

Result

You see the compiler as the translator converting Kotlin into JVM-understandable instructions.

Understanding the compiler's role clarifies how Kotlin code becomes executable on the JVM platform.

3

Intermediate

How Kotlin Features Map to JVM Bytecode

🤔Before reading on: do you think all Kotlin features have direct equivalents in JVM bytecode? Commit to your answer.

Concept: Explore how Kotlin's modern features are represented in JVM bytecode, sometimes requiring special handling.

Some Kotlin features like data classes, coroutines, and null safety do not have direct JVM bytecode instructions. The compiler generates additional code or uses JVM features like annotations and interfaces to implement these. For example, coroutines are compiled into state machines using classes and methods.

Result

You learn that Kotlin extends JVM capabilities by generating extra bytecode patterns to support its features.

Knowing this helps you understand why Kotlin bytecode can look more complex than Java's and how Kotlin achieves its expressive power on the JVM.

4

Intermediate

Compilation Output: .class and .jar Files

Concept: Describe the output files from Kotlin compilation and their role.

After compilation, Kotlin produces .class files containing JVM bytecode for each Kotlin class or object. These files can be packaged into .jar archives for distribution. The JVM loads these .class files at runtime to execute the program.

Result

You understand the physical files that hold the compiled Kotlin bytecode and how they are used.

Recognizing these outputs connects the compilation process to the actual files you run or share.

5

Intermediate

Kotlin Compiler Options Affecting Bytecode

🤔Before reading on: do you think compiler options can change the generated bytecode? Commit to your answer.

Concept: Show how compiler flags influence the bytecode generation and runtime behavior.

The Kotlin compiler offers options like targeting different JVM versions, enabling optimizations, or generating metadata for reflection. For example, targeting JVM 1.8 or 11 changes the bytecode instructions used. These options affect compatibility and performance.

Result

You see that compilation is configurable to suit different JVM environments and needs.

Understanding compiler options helps you control how Kotlin code runs on various JVM versions and platforms.

6

Advanced

How Kotlin Coroutines Compile to Bytecode

🤔Before reading on: do you think coroutines compile into simple method calls or something more complex? Commit to your answer.

Concept: Explain the transformation of Kotlin coroutines into JVM bytecode state machines.

Kotlin coroutines are compiled into classes implementing continuation interfaces. The compiler generates state machine code that manages suspension and resumption points. This bytecode uses JVM features like interfaces and method calls to simulate asynchronous behavior without blocking threads.

Result

You understand the complex bytecode structure behind Kotlin's lightweight concurrency.

Knowing coroutine compilation reveals how Kotlin achieves efficient asynchronous code on the JVM without native support.

7

Expert

Bytecode Differences Between Kotlin and Java

🤔Before reading on: do you think Kotlin bytecode is always simpler than Java bytecode? Commit to your answer.

Concept: Compare Kotlin-generated bytecode with Java's to uncover subtle differences and optimizations.

Kotlin bytecode often includes extra metadata, synthetic methods, and null checks not present in Java bytecode. It uses annotations to support features like null safety and inline functions. These differences can affect debugging and interoperability but enable Kotlin's richer language features.

Result

You gain insight into the trade-offs Kotlin makes in bytecode to provide modern language capabilities.

Understanding these differences helps experts debug Kotlin-Java interop issues and optimize performance.

Under the Hood

The Kotlin compiler parses source code into an abstract syntax tree, performs semantic analysis, and then generates JVM bytecode instructions. It uses the ASM library internally to create .class files with bytecode that the JVM can load. The compiler also inserts additional code for Kotlin-specific features like null checks and coroutines, ensuring they run correctly on the JVM.

Why designed this way?

Kotlin was designed to leverage the existing JVM ecosystem, so compiling to JVM bytecode was the natural choice. This approach avoids building a new runtime and allows Kotlin to interoperate seamlessly with Java. The design balances adding modern language features while maintaining compatibility and performance on the JVM.

┌───────────────┐
│ Kotlin Source │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Parser &     │
│  Analyzer     │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Bytecode      │
│ Generator     │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ .class Files  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ JVM Runtime   │
│ Executes Bytecode │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do Kotlin programs run directly on the JVM without compilation? Commit to yes or no.

Common Belief: Kotlin code runs directly on the JVM without any compilation step.

Reality: Kotlin code must be compiled into JVM bytecode before the JVM can execute it.

Why it matters: Believing this leads to confusion about build processes and runtime errors when skipping compilation.

Quick: Do you think Kotlin bytecode is always simpler than Java bytecode? Commit to yes or no.

Common Belief: Kotlin bytecode is simpler and smaller than Java bytecode because Kotlin is more concise.

Reality: Kotlin bytecode often contains extra methods and metadata to support its features, making it sometimes more complex than Java bytecode.

Why it matters: Assuming simpler bytecode can cause surprises in debugging and performance tuning.

Quick: Do you think Kotlin features like coroutines are natively supported by the JVM? Commit to yes or no.

Common Belief: The JVM natively supports Kotlin features like coroutines.

Reality: The JVM does not natively support coroutines; Kotlin compiles them into bytecode using state machines and interfaces.

Why it matters: Misunderstanding this can lead to incorrect assumptions about performance and debugging complexity.

Quick: Do you think Kotlin bytecode is incompatible with Java bytecode? Commit to yes or no.

Common Belief: Kotlin bytecode is incompatible with Java bytecode and cannot interoperate.

Reality: Kotlin bytecode is fully compatible with Java bytecode, allowing seamless interoperability.

Why it matters: Believing otherwise limits the use of Kotlin in mixed Java-Kotlin projects.

Expert Zone

1

Kotlin generates synthetic methods and bridge methods in bytecode to maintain binary compatibility and support features like default arguments.

2

The compiler inserts null-check bytecode instructions to enforce Kotlin's null safety at runtime, which Java bytecode lacks.

3

Inline functions in Kotlin are handled by the compiler generating bytecode that replaces function calls with the function body to reduce overhead.

When NOT to use

Compiling to JVM bytecode is not suitable when targeting platforms without a JVM, such as iOS or embedded systems. In those cases, Kotlin Native or Kotlin/JS should be used instead.

Production Patterns

In production, Kotlin bytecode is often combined with Java bytecode in the same application, leveraging Kotlin's features while maintaining Java libraries. Developers use compiler options to target specific JVM versions and optimize bytecode for performance and size.

Connections

Java Virtual Machine (JVM)

Kotlin compilation produces bytecode that runs on the JVM, directly building on JVM concepts.

Understanding JVM internals helps grasp how Kotlin bytecode executes and interacts with Java code.

Compiler Design

Kotlin compilation to bytecode is an example of compiler phases: parsing, analysis, and code generation.

Knowing compiler design principles clarifies how source code transforms into executable instructions.

Operating System Process Execution

Just as an OS loads and runs machine code, the JVM loads and runs bytecode generated by Kotlin.

Seeing JVM bytecode execution as a specialized form of program execution deepens understanding of runtime environments.

Common Pitfalls

#1 Skipping compilation and trying to run Kotlin source directly on JVM.

Wrong approach:

java MyKotlinFile.kt

Correct approach:

kotlinc MyKotlinFile.kt -include-runtime -d MyProgram.jar
java -jar MyProgram.jar

Root cause:

Misunderstanding that JVM requires bytecode, not source code, to run programs.

#2 Assuming Kotlin bytecode is identical to Java bytecode and ignoring Kotlin-specific metadata.

Wrong approach:

Treating Kotlin .class files as plain Java classes without considering Kotlin metadata annotations.

Correct approach:

Use Kotlin-aware tools and understand Kotlin metadata in bytecode for accurate analysis and debugging.

Root cause:

Overgeneralizing Java bytecode knowledge without accounting for Kotlin's extensions.

#3 Targeting an incompatible JVM version without adjusting compiler settings.

Wrong approach:

kotlinc -jvm-target 1.8 MyFile.kt (when running on JVM 1.6)

Correct approach:

kotlinc -jvm-target 1.6 MyFile.kt (matching the runtime JVM version)

Root cause:

Ignoring JVM version compatibility leads to runtime errors.

Key Takeaways

Kotlin code is compiled into JVM bytecode, which the JVM executes to run programs.

The Kotlin compiler translates modern language features into JVM-compatible bytecode, sometimes adding extra code for support.

Understanding the compilation process helps in debugging, optimizing, and interoperating Kotlin with Java.

Kotlin bytecode differs from Java bytecode by including metadata and synthetic methods to support Kotlin's unique features.

Compiler options allow tailoring bytecode for different JVM versions and runtime environments.