Compiler

Kotlin classes can't be subclassed unless you write 'open'. Spring and Hibernate need to subclass your classes to add behavior. The all-open and no-arg plugins make the needed classes open and give them an empty constructor automatically.

K2 is a rewritten Kotlin compiler frontend. It understands your code faster and more consistently. It became the stable default starting with Kotlin 2.0.

Some Kotlin APIs are marked experimental and may change. The compiler warns or errors when you use them. To say 'I accept the risk', you add @OptIn(TheMarker::class) above your function or class.

Add the serialization compiler plugin in the Gradle plugins block and add the runtime library as a dependency. Then mark classes with @Serializable.

all-open removes 'final' so classes can be subclassed. no-arg adds an empty constructor so frameworks can create the object. kotlin-spring is an all-open preset for Spring; kotlin-jpa is a no-arg preset (plus all-open) for JPA entities.

For each @Serializable class the plugin generates the code that knows how to read and write that class's fields. Because the code is built at compile time, it doesn't inspect classes with reflection at runtime, so it's faster and works where reflection is limited.

allWarningsAsErrors makes every compiler warning fail the build, keeping code clean. freeCompilerArgs is an escape hatch list for passing extra/experimental -X compiler flags that don't have a typed DSL property yet.

languageVersion controls which Kotlin syntax/features the compiler accepts; apiVersion controls which version of the standard library you're allowed to call. You usually lower them to stay compatible with older consumers.

Apply the base allopen or noarg plugin and list your own annotations in its Gradle config block. Any class with those annotations then becomes open, or gets an empty constructor, just like the Spring/JPA presets do.

FIR is the single data structure K2 uses to represent your code while analyzing it. All checking — names, types, smart casts — happens on this one model, which keeps results consistent and fast.

The frontend reads and understands your code — names, types, errors. The backend turns that into runnable output like bytecode. Because K2 only rewrote the frontend, correct programs still produce the same kind of output.

You make your own annotation and mark it with @RequiresOptIn. Then you put that annotation on the API you want to flag. You can set a message and choose whether use is a warning or an error.

You can tell the compiler to accept a marker everywhere in the module using a build setting instead of writing @OptIn on every spot. It's convenient but you lose the per-use record of where the risky API is used.

Check that the serialization plugin version matches the new Kotlin version, that the plugin is actually applied, and that the runtime library is present. Mismatches or a missing plugin are the usual cause.

jvmToolchain(n) tells Gradle to use a specific JDK version to compile and run everything, and it automatically sets Kotlin's bytecode target and Java's compatibility to match. That keeps Kotlin and Java in one module consistent.

It controls whether Kotlin interface methods with bodies become real Java default methods in the bytecode, instead of being copied into a synthetic DefaultImpls class. The modes trade binary compatibility against cleaner Java interop.

kotlin-jpa makes entities open and gives them an empty constructor, but data classes auto-generate equals/hashCode/copy from all properties. With lazy loading and mutable IDs that breaks equality and causes surprises, so plain classes are recommended for entities.

K2 tracks the types of values more carefully, so smart casts work in more places — for example after combining conditions with logical operators or across local variables — where the old compiler sometimes gave up.

Re-annotating with the marker passes the 'please opt in' requirement on to whoever calls your code. Using @OptIn stops the requirement at your code — your callers don't have to do anything.

The plugin reads annotations like @SerialName (rename a field or class), @Transient (skip a field), and @Required, plus default values, and bakes those rules into the generated serializer and its descriptor so encoding/decoding follow them.

They run inside the Kotlin compiler while building each module, changing the generated bytecode. They aren't libraries and don't run at runtime. A module only gets the effect if it applies the plugin, and the change is invisible in your source.

Bump to Kotlin 2.0 so K2 is the default, update plugins like kapt/serialization to K2-compatible versions, fix the small set of newly-rejected code, and run the full test/build matrix to confirm nothing broke before rolling out.

Use opt-in markers to label which parts of your API are still experimental, so users must consciously accept the risk. Keep stable APIs unmarked, and have a clear plan for graduating experimental APIs to stable.

Choose kotlinx.serialization when you need Kotlin multiplatform, fast startup, and shrinker-friendly builds, or want first-class Kotlin support. The cost is more generated code, longer compiles, and a less mature ecosystem of format adapters than Jackson.