Repository: JetBrains/kotlin-web-site
Pull request #4844: Kotlin 2.2.0-RC release details and What's new
Author: login: AlejandraPedroza
Created: 2025-05-15T12:53:35Z | Merged: 2025-05-16T11:00:24Z

This PR adds release details and What's new for Kotlin 2.2.0-RC


Diff:
diff --git a/docs/images/whatsnew/gradle-console-rich-output.png b/docs/images/whatsnew/gradle-console-rich-output.png
new file mode 100644
index 00000000000..7b6717e21a2
Binary files /dev/null and b/docs/images/whatsnew/gradle-console-rich-output.png differ
diff --git a/docs/kr.tree b/docs/kr.tree
index d041e8e8c17..9457e9c1327 100644
--- a/docs/kr.tree
+++ b/docs/kr.tree
@@ -34,7 +34,7 @@
 	<toc-element toc-title="What's new in Kotlin">
 		<toc-element toc-title="Kotlin 2.1.20" accepts-web-file-names="whatsnew.html" topic="whatsnew2120.md"/>
 		<toc-element toc-title="Kotlin 2.1.0" topic="whatsnew21.md"/>
-		<toc-element toc-title="Kotlin 2.2.0-Beta2" topic="whatsnew-eap.md"/>
+		<toc-element toc-title="Kotlin 2.2.0-RC" topic="whatsnew-eap.md"/>
 		<toc-element toc-title="Earlier versions">
 			<toc-element toc-title="Kotlin 2.0.20" topic="whatsnew2020.md"/>
 			<toc-element toc-title="Kotlin 2.0.0" topic="whatsnew20.md"/>
diff --git a/docs/topics/eap.md b/docs/topics/eap.md
index 0a5b456f38e..d4fb9b6842e 100644
--- a/docs/topics/eap.md
+++ b/docs/topics/eap.md
@@ -54,13 +54,13 @@ In this channel, you can also get notifications about new EAP builds.
         <th>Build highlights</th>
     </tr>
     <tr>
-        <td><strong>2.2.0-Beta2</strong>
-            <p>Released: <strong>April 30, 2025</strong></p>
-            <p><a href="https://github.com/JetBrains/kotlin/releases/tag/v2.2.0-Beta2" target="_blank">Release on GitHub</a></p>
+        <td><strong>2.2.0-RC</strong>
+            <p>Released: <strong>May 16, 2025</strong></p>
+            <p><a href="https://github.com/JetBrains/kotlin/releases/tag/v2.2.0-RC" target="_blank">Release on GitHub</a></p>
         </td>
         <td>
             <p>A language release with previews of new features and tooling updates.</p>
-            <p>For more details, please refer to the <a href="https://github.com/JetBrains/kotlin/releases/tag/v2.2.0-Beta2">changelog</a> or <a href="whatsnew-eap.md">What's new in Kotlin 2.2.0-Beta2</a>.</p>
+            <p>For more details, please refer to the <a href="https://github.com/JetBrains/kotlin/releases/tag/v2.2.0-RC">changelog</a> or <a href="whatsnew-eap.md">What's new in Kotlin 2.2.0-RC</a>.</p>
         </td>
     </tr>
 </table>
\ No newline at end of file
diff --git a/docs/topics/whatsnew/whatsnew-eap.md b/docs/topics/whatsnew/whatsnew-eap.md
index 5028562df86..f4c8a289186 100644
--- a/docs/topics/whatsnew/whatsnew-eap.md
+++ b/docs/topics/whatsnew/whatsnew-eap.md
@@ -12,8 +12,9 @@ _[Released: %kotlinEapReleaseDate%](eap.md#build-details)_
 The Kotlin %kotlinEapVersion% release is out!
 Here are some details of this EAP release:
 
+* [Language: preview of context parameters](#preview-of-context-parameters)
 * [Kotlin compiler: unified management of compiler warnings](#kotlin-compiler-unified-management-of-compiler-warnings)
-* [Kotlin/JVM: changes to default method generation for interface functions](#kotlin-jvm-changes-to-default-method-generation-for-interface-functions)
+* [Kotlin/JVM: changes to default method generation for interface functions](#changes-to-default-method-generation-for-interface-functions)
 * [Gradle: integration of Problems API within KGP diagnostics](#integration-of-problems-api-within-kgp-diagnostics)
   and [KGP compatibility with '--warning-mode'](#kgp-compatibility-with-warning-mode)
 
@@ -25,6 +26,146 @@ All you need to do is to [change the Kotlin version](configure-build-for-eap.md)
 
 See [Update to a new release](releases.md#update-to-a-new-kotlin-version) for details.
 
+## Language
+
+This release promotes some language features as stable and brings context parameters in preview.
+
+### Stable features: guard conditions, non-local break and continue, and multi-dollar interpolation
+
+In Kotlin 2.1.0, several new language features were introduced in preview. 
+We're happy to announce that these language features became 
+[Stable](components-stability.md#stability-levels-explained) in this release:
+
+* [Guard conditions in `when` with a subject](whatsnew21.md#guard-conditions-in-when-with-a-subject)
+* [Non-local `break` and `continue`](whatsnew21.md#non-local-break-and-continue)
+* [Multi-dollar interpolation: improved handling of `$` in string literals](whatsnew21.md#multi-dollar-string-interpolation)
+
+[See the full list of Kotlin language design features and proposals](kotlin-language-features-and-proposals.md).
+
+### Preview of context parameters
+
+<primary-label ref="experimental-general"/>
+
+In this release, context parameters are introduced in preview.
+Context parameters allow functions and properties to declare dependencies that are implicitly available in the 
+surrounding context.
+
+This feature replaces an older experimental feature called context receivers. To migrate from context receivers to context 
+parameters, you can use assisted support in IntelliJ IDEA, as described in 
+the [blog post](https://blog.jetbrains.com/kotlin/2025/04/update-on-context-parameters/).
+
+#### How to declare context parameters
+
+You can declare context parameters for properties and functions using the `context` keyword
+followed by a list of parameters, each of the form `name: Type`. Here is an example with a dependency on the `UserService` interface:
+
+```kotlin
+// `UserService` defines the dependency required in context 
+interface UserService {
+    fun log(message: String)
+    fun findUserById(id: Int): String
+}
+
+// Declares a function with a context parameter
+context(users: UserService)
+fun outputMessage(message: String) {
+    // Uses `log` from the context
+    users.log("Log: $message")
+}
+
+// Declares a property with a context parameter
+context(users: UserService)
+val firstUser: String
+    // Uses `findUserById` from the context    
+    get() = users.findUserById(1)
+```
+
+You can use `_` as a context parameter name. In this case, the parameter's value is available for resolution but is not accessible by name inside the block:
+
+```kotlin
+// Uses `_` as context parameter name
+context(_: UserService)
+fun logWelcome() {
+    // Resolution still finds the appropriate `log` function from UserService
+    outputMessage("Welcome!")
+}
+```
+
+#### Context parameters resolution
+
+Kotlin resolves context parameters at the call site by searching for matching context values in the current scope. Kotlin matches them by their type.
+If multiple compatible values exist at the same scope level, the compiler reports an ambiguity:
+
+```kotlin
+// `UserService` defines the dependency required in context
+interface UserService {
+    fun log(message: String)
+}
+
+// Declares a function with a context parameter
+context(users: UserService)
+fun outputMessage(message: String) {
+    users.log("Log: $message")
+}
+
+fun main() {
+    // Implements `UserService` 
+    val serviceA = object : UserService {
+        override fun log(message: String) = println("A: $message")
+    }
+
+    // Implements `UserService`
+    val serviceB = object : UserService {
+        override fun log(message: String) = println("B: $message")
+    }
+
+    // Both `serviceA` and `serviceB` match the expected `UserService` type at the call site
+    context(serviceA, serviceB) {
+        outputMessage("This will not compile")
+        // Ambiguity error
+    }
+}
+```
+
+#### Restrictions
+
+Context parameters are in continuous improvement; some of the current restrictions are:
+
+* Constructors cannot declare context parameters
+* Properties with context parameters can't have backing fields or initializers
+* Properties with context parameters can't use delegation
+
+However, context parameters in Kotlin represent a significant improvement in managing dependencies through simplified dependency injection,
+improved DSL design, and scoped operations. For more information, see the feature's [KEEP](https://github.com/Kotlin/KEEP/blob/context-parameters/proposals/context-parameters.md).
+
+#### How to enable context parameters
+
+To enable context parameters in your project, use the following compiler option in the command line:
+
+```Bash
+-Xcontext-parameters
+```
+
+Or add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xcontext-parameters")
+    }
+}
+```
+
+> Specifying both `-Xcontext-receivers` and `-Xcontext-parameters` compiler options simultaneously leads to an error.
+>
+{style="warning"}
+
+#### Leave your feedback
+
+This feature is planned to be stabilized and improved in future Kotlin releases.
+We would appreciate your feedback in our issue tracker [YouTrack](https://youtrack.jetbrains.com/issue/KT-10468/Context-Parameters-expanding-extension-receivers-to-work-with-scopes).
+
 ## Kotlin compiler: unified management of compiler warnings
 
 <primary-label ref="experimental-general"/>
@@ -45,7 +186,7 @@ The new compiler option has the following syntax:
 ```
 
 * `error`: raises the specified warning to an error.
-* `warning`: emits a warning, and is enabled by default.
+* `warning`: emits a warning and is enabled by default.
 * `disabled`: completely suppresses the specified warning module-wide.
 
 Keep in mind that you can only configure the severity level of _warnings_ with the new compiler option.
@@ -86,7 +227,9 @@ In case you have many warnings you want to exclude from general rules, you can l
 
 The new compiler option is still [Experimental](components-stability.md#stability-levels-explained). Please report any problems to our issue tracker, [YouTrack](https://kotl.in/issue).
 
-## Kotlin/JVM: changes to default method generation for interface functions
+## Kotlin/JVM
+
+### Changes to default method generation for interface functions
 
 Starting from Kotlin %kotlinEapVersion%, functions declared in interfaces are compiled to JVM default methods unless configured otherwise.
 This change affects how Kotlin's interface functions with implementations are compiled to bytecode.
@@ -108,8 +251,204 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native's [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target. As a result, both targets were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate `build/wasm` directory.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+You can now work with the Wasm target independently of the JavaScript target, which simplifies the configuration.
+
+This change is enabled by default and requires no additional configuration.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`.
+You can use the `copy()` function to manipulate objects.
+
+However, the initial implementation of `copy()` was not compatible with inheritance, and this
+caused issues when a `@JsPlainObject` interface extended other interfaces.
+
+To avoid limitations on plain objects, the `copy()` function has been moved from the object itself to its companion object:
+
+```kotlin
+@JsPlainObject
+external interface User {
+    val name: String
+    val age: Int
+}
+
+fun main() {
+    val user = User(name = "SomeUser", age = 21)
+    // This syntax is not valid anymore
+    val copy = user.copy(age = 35)      
+    // This is the correct syntax
+    val copy = User.copy(user, age = 35)
+}
+```
+
+This change resolves conflicts in the inheritance hierarchy and eliminates ambiguity. 
+It is enabled by default starting from Kotlin %kotlinEapVersion%.
+
+### Support for typealiases in files with @JsModule annotation
+
+Previously, files annotated with `@JsModule` to import declarations from JavaScript modules
+were restricted to external declarations only. Meaning, you couldn't declare a `typealias` in such files.
+
+Starting with Kotlin %kotlinEapVersion%, you can declare typealiases inside files marked with `@JsModule`:
+
+```kotlin
+@file:JsModule("somepackage")
+package somepackage
+typealias SomeClass = Any
+```
+
+This change reduces an aspect of Kotlin/JS interoperability limitations, and more improvements are planned for future releases.
+
+Support for typealiases in files with `@JsModule` is enabled by default.
+
 ## Gradle
 
+Kotlin %kotlinEapVersion% is fully compatible with Gradle 7.6.3 through 8.14. You can also use Gradle versions up to the latest Gradle release. However, be aware that doing so may result in deprecation warnings, and some new Gradle features might not work.
+
+### Support for rich output in console for Kotlin Gradle plugin
+
+In Kotlin %kotlinEapVersion%, we support color and other rich output in the console during the Gradle build process, making it easier to read and understand the reported diagnostics. 
+Rich output is available in supported terminal emulators for Linux and macOS. We're working on adding support for Windows.
+
+![Gradle console](gradle-console-rich-output.png){width=600}
+
+This feature is enabled by default, but if you want to override it, add the following Gradle property to your `gradle.properties` file:
+
+```
+org.gradle.console=plain
+```
+
+For more information about this property and its options, see Gradle's documentation on [Customizing log format](https://docs.gradle.org/current/userguide/command_line_interface.html#sec:command_line_customizing_log_format).
+
 ### Integration of Problems API within KGP diagnostics
 
 Previously, the Kotlin Gradle Plugin (KGP) reported diagnostics—such as warnings and errors—only as plain text output to the console or logs.
@@ -130,6 +469,7 @@ Now, KGP diagnostics are compatible with the `--warning-mode` option, providing
 you can convert all warnings into errors or disable warnings entirely.
 
 With this change, KGP diagnostics adjust the output based on the selected warning mode:
+
 * When you set `--warning-mode=fail`, diagnostics with `Severity.Warning` are now elevated to `Severity.Error`.
 * When you set `--warning-mode=none`, diagnostics with `Severity.Warning` are not logged.
 
@@ -137,11 +477,80 @@ This behavior is enabled by default starting with %kotlinEapVersion%.
 
 To ignore the `--warning-mode` option, set `kotlin.internal.diagnostics.ignoreWarningMode=true` in your Gradle properties.
 
-## How to update to Kotlin %kotlinEapVersion%
+## Kotlin standard library: Stable Base64 and HexFormat APIs
+
+In Kotlin %kotlinEapVersion%, the [`Base64` API](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.io.encoding/-base64/) and [`HexFormat` API](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.text/-hex-format/) are now [Stable](components-stability.md#stability-levels-explained).
+
+### Base64 encoding and decoding
+
+Kotlin 1.8.20 introduced [Experimental support for Base64 encoding and decoding](whatsnew1820.md#support-for-base64-encoding).
+In Kotlin %kotlinEapVersion%, the [Base64 API](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.io.encoding/-base64/) is now Stable and
+includes four encoding schemes, with the new `Base64.Pem` added in this release:
+
+* [`Base64.Default`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.io.encoding/-base64/-default/) uses the standard [Base64 encoding scheme](https://www.rfc-editor.org/rfc/rfc4648#section-4).
+
+  > The `Base64.Default` is the companion object of the `Base64` class.
+  > As a result, you can call its functions with `Base64.encode()` and `Base64.decode()` instead of `Base64.Default.encode()` and `Base64.Default.decode()`.
+  >
+  {style="tip"}
+
+* [`Base64.UrlSafe`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.io.encoding/-base64/-default/-url-safe.html) uses the ["URL and Filename safe"](https://www.rfc-editor.org/rfc/rfc4648#section-5) encoding scheme.
+* [`Base64.Mime`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.io.encoding/-base64/-default/-mime.html) uses the [MIME](https://www.rfc-editor.org/rfc/rfc2045#section-6.8) encoding scheme, inserting a line separator every 76 characters during encoding and skipping illegal characters during decoding.
+* `Base64.Pem` encodes data like `Base64.Mime` but limits the line length to 64 characters.
+
+You can use the Base64 API to encode binary data into a Base64 string and decode it back into bytes.
+
+Here's an example:
 
-Starting from IntelliJ IDEA 2023.3 and Android Studio Iguana (2023.2.1) Canary 15, the Kotlin plugin is distributed as a
-bundled plugin included in your IDE. This means that you can't install the plugin from JetBrains Marketplace anymore.
-The bundled plugin supports upcoming Kotlin EAP releases.
+```kotlin
+val foBytes = "fo".map { it.code.toByte() }.toByteArray()
+Base64.Default.encode(foBytes) // "Zm8="
+// Alternatively:
+// Base64.encode(foBytes)
+
+val foobarBytes = "foobar".map { it.code.toByte() }.toByteArray()
+Base64.UrlSafe.encode(foobarBytes) // "Zm9vYmFy"
+
+Base64.Default.decode("Zm8=") // foBytes
+// Alternatively:
+// Base64.decode("Zm8=")
+
+Base64.UrlSafe.decode("Zm9vYmFy") // foobarBytes
+```
+
+On the JVM, use the `.encodingWith()` and `.decodingWith()` extension functions to encode and decode Base64 with input and output streams:
+
+```kotlin
+import kotlin.io.encoding.*
+import java.io.ByteArrayOutputStream
+
+fun main() {
+    val output = ByteArrayOutputStream()
+    val base64Output = output.encodingWith(Base64.Default)
+
+    base64Output.use { stream ->
+        stream.write("Hello World!!".encodeToByteArray())
+    }
+
+    println(output.toString())
+    // SGVsbG8gV29ybGQhIQ==
+}
+```
+
+### Hexadecimal parsing and formatting with the HexFormat API
+
+The [`HexFormat` API](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.text/-hex-format/) introduced in [Kotlin 1.9.0](whatsnew19.md#new-hexformat-class-to-format-and-parse-hexadecimals) is now [Stable](components-stability.md#stability-levels-explained).
+You can use it to convert between numerical values and hexadecimal strings.
+
+For example:
+
+```kotlin
+fun main() {
+    //sampleStart
+    println(93.toHexString())
+    //sampleEnd
+}
+```
+{kotlin-runnable="true"}
 
-To update to the new Kotlin EAP version, [change the Kotlin version](configure-build-for-eap.md#adjust-the-kotlin-version)
-to %kotlinEapVersion% in your build scripts.
\ No newline at end of file
+For more information, see [New HexFormat class to format and parse hexadecimals](whatsnew19.md#new-hexformat-class-to-format-and-parse-hexadecimals).
diff --git a/docs/v.list b/docs/v.list
index 7af1cc5d04d..9b0af968f08 100644
--- a/docs/v.list
+++ b/docs/v.list
@@ -14,8 +14,8 @@
     <var name="apiVersion" value="2.1" type="string"/>
 
     <!-- Kotlin EAP -->
-    <var name="kotlinEapVersion" value="2.2.0-Beta2" type="string"/>
-    <var name="kotlinEapReleaseDate" value="April 30, 2025" type="string"/>
+    <var name="kotlinEapVersion" value="2.2.0-RC" type="string"/>
+    <var name="kotlinEapReleaseDate" value="May 16, 2025" type="string"/>
 
     <!-- Libraries and Frameworks -->
     <var name="coroutinesVersion" value="1.10.2" type="string"/>


Reviews:
user: login: danil-pavlov
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-15T13:59:22Z
user: login: koshachy
state: CHANGES_REQUESTED
author_association: COLLABORATOR
submitted_at: 2025-05-15T16:22:50Z
user: login: AlejandraPedroza
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-16T06:20:42Z
user: login: AlejandraPedroza
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-16T06:35:36Z
user: login: koshachy
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-05-16T07:26:10Z

Review comments:
diff_hunk: @@ -25,6 +26,146 @@ All you need to do is to [change the Kotlin version](configure-build-for-eap.md)
 
 See [Update to a new release](releases.md#update-to-a-new-kotlin-version) for details.
 
+## Language
+
+In this release, we promote some language features as stable and introduce the preview of context parameters.
+
+### Stable features: guard conditions, non-local break and continue, and multi-dollar interpolation
+
+In Kotlin 2.1.0, we introduced several new language features in preview. 
+We're happy to announce that these language features became 
+[Stable](components-stability.md#stability-levels-explained) in this release:
+
+* [Guard conditions in `when` with a subject](whatsnew21.md#guard-conditions-in-when-with-a-subject)
+* [Non-local `break` and `continue`](whatsnew21.md#non-local-break-and-continue)
+* [Multi-dollar interpolation: improved handling of `$` in string literals](whatsnew21.md#multi-dollar-string-interpolation)
+
+[See the full list of Kotlin language design features and proposals](kotlin-language-features-and-proposals.md).
+
+### Preview of context parameters
+
+<primary-label ref="experimental-general"/>
+
+In this release, we introduce the preview of context parameters.
+Context parameters allow functions and properties to declare dependencies that are implicitly available in the 
+surrounding context.
+
+This feature replaces an older experimental feature called context receivers. To migrate from context receivers to context 
+parameters, you can use assisted support in IntelliJ IDEA, as described in 
+this [blog post](https://blog.jetbrains.com/kotlin/2025/04/update-on-context-parameters/).
+
+#### How to declare context parameters
+
+You can declare context parameters for properties and functions using the `context` keyword
+followed by a list of parameters, each of the form `name: Type`. Let's look at an example with a dependency on the `UserService` interface:
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
followed by a list of parameters, each of the form `name: Type`. Here is an example with a dependency on the `UserService` interface:
```
created_at: 2025-05-15T13:42:06Z
author_association: COLLABORATOR
diff_hunk: @@ -25,6 +26,146 @@ All you need to do is to [change the Kotlin version](configure-build-for-eap.md)
 
 See [Update to a new release](releases.md#update-to-a-new-kotlin-version) for details.
 
+## Language
+
+In this release, we promote some language features as stable and introduce the preview of context parameters.
+
+### Stable features: guard conditions, non-local break and continue, and multi-dollar interpolation
+
+In Kotlin 2.1.0, we introduced several new language features in preview. 
+We're happy to announce that these language features became 
+[Stable](components-stability.md#stability-levels-explained) in this release:
+
+* [Guard conditions in `when` with a subject](whatsnew21.md#guard-conditions-in-when-with-a-subject)
+* [Non-local `break` and `continue`](whatsnew21.md#non-local-break-and-continue)
+* [Multi-dollar interpolation: improved handling of `$` in string literals](whatsnew21.md#multi-dollar-string-interpolation)
+
+[See the full list of Kotlin language design features and proposals](kotlin-language-features-and-proposals.md).
+
+### Preview of context parameters
+
+<primary-label ref="experimental-general"/>
+
+In this release, we introduce the preview of context parameters.
+Context parameters allow functions and properties to declare dependencies that are implicitly available in the 
+surrounding context.
+
+This feature replaces an older experimental feature called context receivers. To migrate from context receivers to context 
+parameters, you can use assisted support in IntelliJ IDEA, as described in 
+this [blog post](https://blog.jetbrains.com/kotlin/2025/04/update-on-context-parameters/).
+
+#### How to declare context parameters
+
+You can declare context parameters for properties and functions using the `context` keyword
+followed by a list of parameters, each of the form `name: Type`. Let's look at an example with a dependency on the `UserService` interface:
+
+```kotlin
+// `UserService` defines the dependency required in context 
+interface UserService {
+    fun log(message: String)
+    fun findUserById(id: Int): String
+}
+
+// Declares a function with a context parameter
+context(users: UserService)
+fun outputMessage(message: String) {
+    // Uses `log` from the context
+    users.log("Log: $message")
+}
+
+// Declares a property with a context parameter
+context(users: UserService)
+val firstUser: String
+    // Uses `findUserById` from the context    
+    get() = users.findUserById(1)
+```
+
+You can use `_` as a context parameter name. In this case, the parameter's value is available for resolution but is not accessible by name inside the block:
+
+```kotlin
+// Uses `_` as context parameter name
+context(_: UserService)
+fun logWelcome() {
+    // Resolution still finds the appropriate `log` function from UserService
+    outputMessage("Welcome!")
+}
+```
+
+#### Context parameters resolution
+
+Kotlin resolves context parameters at the call site by searching for matching context values in the current scope. Kotlin matches them by their type.
+If multiple compatible values exist at the same scope level, the compiler reports an ambiguity:
+
+```kotlin
+// `UserService` defines the dependency required in context
+interface UserService {
+    fun log(message: String)
+}
+
+// Declares a function with a context parameter
+context(users: UserService)
+fun outputMessage(message: String) {
+    users.log("Log: $message")
+}
+
+fun main() {
+    // Implements `UserService` 
+    val serviceA = object : UserService {
+        override fun log(message: String) = println("A: $message")
+  }
+
+  // Implements `UserService`
+  val serviceB = object : UserService {
+      override fun log(message: String) = println("B: $message")
+  }
+
+  // Both `serviceA` and `serviceB` match the expected `UserService` type at the call site
+  context(serviceA, serviceB) {
+      outputMessage("This will not compile")
+      // Ambiguity error
+  }
+}
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
    }

    // Implements `UserService`
    val serviceB = object : UserService {
        override fun log(message: String) = println("B: $message")
    }

    // Both `serviceA` and `serviceB` match the expected `UserService` type at the call site
    context(serviceA, serviceB) {
        outputMessage("This will not compile")
        // Ambiguity error
    }
}
```
created_at: 2025-05-15T13:43:35Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` Gradle option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: danil-pavlov
body: ```suggestion
The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
```
created_at: 2025-05-15T13:59:22Z
author_association: CONTRIBUTOR
diff_hunk: @@ -25,6 +26,146 @@ All you need to do is to [change the Kotlin version](configure-build-for-eap.md)
 
 See [Update to a new release](releases.md#update-to-a-new-kotlin-version) for details.
 
+## Language
+
+In this release, we promote some language features as stable and introduce the preview of context parameters.
+
+### Stable features: guard conditions, non-local break and continue, and multi-dollar interpolation
+
+In Kotlin 2.1.0, we introduced several new language features in preview. 
+We're happy to announce that these language features became 
+[Stable](components-stability.md#stability-levels-explained) in this release:
+
+* [Guard conditions in `when` with a subject](whatsnew21.md#guard-conditions-in-when-with-a-subject)
+* [Non-local `break` and `continue`](whatsnew21.md#non-local-break-and-continue)
+* [Multi-dollar interpolation: improved handling of `$` in string literals](whatsnew21.md#multi-dollar-string-interpolation)
+
+[See the full list of Kotlin language design features and proposals](kotlin-language-features-and-proposals.md).
+
+### Preview of context parameters
+
+<primary-label ref="experimental-general"/>
+
+In this release, we introduce the preview of context parameters.
+Context parameters allow functions and properties to declare dependencies that are implicitly available in the 
+surrounding context.
+
+This feature replaces an older experimental feature called context receivers. To migrate from context receivers to context 
+parameters, you can use assisted support in IntelliJ IDEA, as described in 
+this [blog post](https://blog.jetbrains.com/kotlin/2025/04/update-on-context-parameters/).
+
+#### How to declare context parameters
+
+You can declare context parameters for properties and functions using the `context` keyword
+followed by a list of parameters, each of the form `name: Type`. Let's look at an example with a dependency on the `UserService` interface:
+
+```kotlin
+// `UserService` defines the dependency required in context 
+interface UserService {
+    fun log(message: String)
+    fun findUserById(id: Int): String
+}
+
+// Declares a function with a context parameter
+context(users: UserService)
+fun outputMessage(message: String) {
+    // Uses `log` from the context
+    users.log("Log: $message")
+}
+
+// Declares a property with a context parameter
+context(users: UserService)
+val firstUser: String
+    // Uses `findUserById` from the context    
+    get() = users.findUserById(1)
+```
+
+You can use `_` as a context parameter name. In this case, the parameter's value is available for resolution but is not accessible by name inside the block:
+
+```kotlin
+// Uses `_` as context parameter name
+context(_: UserService)
+fun logWelcome() {
+    // Resolution still finds the appropriate `log` function from UserService
+    outputMessage("Welcome!")
+}
+```
+
+#### Context parameters resolution
+
+Kotlin resolves context parameters at the call site by searching for matching context values in the current scope. Kotlin matches them by their type.
+If multiple compatible values exist at the same scope level, the compiler reports an ambiguity:
+
+```kotlin
+// `UserService` defines the dependency required in context
+interface UserService {
+    fun log(message: String)
+}
+
+// Declares a function with a context parameter
+context(users: UserService)
+fun outputMessage(message: String) {
+    users.log("Log: $message")
+}
+
+fun main() {
+    // Implements `UserService` 
+    val serviceA = object : UserService {
+        override fun log(message: String) = println("A: $message")
+  }
+
+  // Implements `UserService`
+  val serviceB = object : UserService {
+      override fun log(message: String) = println("B: $message")
+  }
+
+  // Both `serviceA` and `serviceB` match the expected `UserService` type at the call site
+  context(serviceA, serviceB) {
+      outputMessage("This will not compile")
+      // Ambiguity error
+  }
+}
+```
+
+#### Restrictions
+
+Context parameters are in continuous improvement; some of the current restrictions are:
+
+* Constructors cannot declare context parameters
+* Properties with context parameters can't have backing fields or initializers
+* Properties with context parameters can't use delegation
+
+However, context parameters in Kotlin represent a significant improvement in managing dependencies through simplified dependency injection,
+improved DSL design, and scoped operations. For more information, see the feature's [KEEP](https://github.com/Kotlin/KEEP/blob/context-parameters/proposals/context-parameters.md).
+
+#### How to enable context parameters
+
+To enable context parameters in your project, use the following compiler option in the command line:
+
+```Bash
+-Xcontext-parameters
+```
+
+Or add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xcontext-parameters")
+    }
+}
+```
+
+> Specifying both `-Xcontext-receivers` and `-Xcontext-parameters` compiler options simultaneously leads to an error.
+>
+{style="warning"}
+
+#### Leave your feedback
+
+We plan to stabilize and improve this feature in future Kotlin releases.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: Just a thought: there are too many "we" in the text about the Language updates.
created_at: 2025-05-15T16:05:09Z
author_association: COLLABORATOR
diff_hunk: @@ -25,6 +26,146 @@ All you need to do is to [change the Kotlin version](configure-build-for-eap.md)
 
 See [Update to a new release](releases.md#update-to-a-new-kotlin-version) for details.
 
+## Language
+
+In this release, we promote some language features as stable and introduce the preview of context parameters.
+
+### Stable features: guard conditions, non-local break and continue, and multi-dollar interpolation
+
+In Kotlin 2.1.0, we introduced several new language features in preview. 
+We're happy to announce that these language features became 
+[Stable](components-stability.md#stability-levels-explained) in this release:
+
+* [Guard conditions in `when` with a subject](whatsnew21.md#guard-conditions-in-when-with-a-subject)
+* [Non-local `break` and `continue`](whatsnew21.md#non-local-break-and-continue)
+* [Multi-dollar interpolation: improved handling of `$` in string literals](whatsnew21.md#multi-dollar-string-interpolation)
+
+[See the full list of Kotlin language design features and proposals](kotlin-language-features-and-proposals.md).
+
+### Preview of context parameters
+
+<primary-label ref="experimental-general"/>
+
+In this release, we introduce the preview of context parameters.
+Context parameters allow functions and properties to declare dependencies that are implicitly available in the 
+surrounding context.
+
+This feature replaces an older experimental feature called context receivers. To migrate from context receivers to context 
+parameters, you can use assisted support in IntelliJ IDEA, as described in 
+this [blog post](https://blog.jetbrains.com/kotlin/2025/04/update-on-context-parameters/).
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
the [blog post](https://blog.jetbrains.com/kotlin/2025/04/update-on-context-parameters/).
```
created_at: 2025-05-15T16:06:19Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
Kotlin/Native's [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
```
created_at: 2025-05-15T16:08:46Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: The sentence is too big. Can we break it down into smaller parts?
created_at: 2025-05-15T16:10:37Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
Additionally, the Wasm-related project files and NPM dependencies are now in a separate `build/wasm` directory.
```
created_at: 2025-05-15T16:11:58Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
You can now work with the Wasm target independently of the JavaScript target, which simplifies the configuration.
```
created_at: 2025-05-15T16:13:50Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
This change is enabled by default and requires no additional configuration.
```
created_at: 2025-05-15T16:16:01Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()` function is useful for manipulating objects.
```
created_at: 2025-05-15T16:16:31Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: Why is it useful? Can we say:

You can use the copy() function to manipulate objects.
created_at: 2025-05-15T16:17:08Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
+
+However, the initial implementation of `copy()` was not compatible with inheritance, and this
+caused issues when a `@JsPlainObject` interface was inherited from other interfaces.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
caused issues when a `@JsPlainObject` interface was inherited from other interfaces.
```

Please, double-check this one.
We usually say that a class is **inherited**, but the interface is **implemented**.
created_at: 2025-05-15T16:18:38Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
+
+However, the initial implementation of `copy()` was not compatible with inheritance, and this
+caused issues when a `@JsPlainObject` interface was inherited from other interfaces.
+
+To avoid limitations on plain objects, the `copy()` function has been moved from the object itself to its companion object:
+
+```kotlin
+@JsPlainObject
+external interface User {
+    val name: String
+    val age: Int
+}
+
+fun main() {
+    val user = User(name = "SomeUser", age = 21)
+    // This syntax is not valid anymore
+    val copy = user.copy(age = 35)      
+    // This is the correct syntax
+    val copy = User.copy(user, age = 35)
+}
+```
+
+This resolves conflicts in the inheritance hierarchy and eliminates ambiguity.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
This change resolves conflicts in the inheritance hierarchy and eliminates ambiguity. It is enabled by default starting from Kotlin %kotlinEapVersion%.
```
created_at: 2025-05-15T16:20:10Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
+
+However, the initial implementation of `copy()` was not compatible with inheritance, and this
+caused issues when a `@JsPlainObject` interface was inherited from other interfaces.
+
+To avoid limitations on plain objects, the `copy()` function has been moved from the object itself to its companion object:
+
+```kotlin
+@JsPlainObject
+external interface User {
+    val name: String
+    val age: Int
+}
+
+fun main() {
+    val user = User(name = "SomeUser", age = 21)
+    // This syntax is not valid anymore
+    val copy = user.copy(age = 35)      
+    // This is the correct syntax
+    val copy = User.copy(user, age = 35)
+}
+```
+
+This resolves conflicts in the inheritance hierarchy and eliminates ambiguity.
+
+This change is enabled by default starting from Kotlin %kotlinEapVersion%.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
```
created_at: 2025-05-15T16:20:21Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
+
+However, the initial implementation of `copy()` was not compatible with inheritance, and this
+caused issues when a `@JsPlainObject` interface was inherited from other interfaces.
+
+To avoid limitations on plain objects, the `copy()` function has been moved from the object itself to its companion object:
+
+```kotlin
+@JsPlainObject
+external interface User {
+    val name: String
+    val age: Int
+}
+
+fun main() {
+    val user = User(name = "SomeUser", age = 21)
+    // This syntax is not valid anymore
+    val copy = user.copy(age = 35)      
+    // This is the correct syntax
+    val copy = User.copy(user, age = 35)
+}
+```
+
+This resolves conflicts in the inheritance hierarchy and eliminates ambiguity.
+
+This change is enabled by default starting from Kotlin %kotlinEapVersion%.
+
+### Support for typealiases in files with @JsModule annotation
+
+Previously, files annotated with `@JsModule` to import declarations from JavaScript modules
+were restricted to external declarations only. Meaning, you couldn't declare a `typealias` in such files.
+
+Starting with Kotlin %kotlinEapVersion%, you can declare typealiases inside files marked with `@JsModule`:
+
+```kotlin
+@file:JsModule("somepackage")
+package somepackage
+typealias SomeClass = Any
+```
+
+This change reduces an aspect of Kotlin/JS interoperability limitations, and more improvements are planned for future releases.
+
+Support for typealiases in files with `@JsModule` is enabled by default.
+
 ## Gradle
 
+Kotlin %kotlinEapVersion% is fully compatible with Gradle 7.6.3 through 8.14. You can also use Gradle versions up to the latest Gradle release. However, be aware that doing so may result in deprecation warnings, and some new Gradle features might not work.
+
+### Support for rich output in console for Kotlin Gradle plugin
+
+In Kotlin %kotlinEapVersion%, we support color and other rich output in the console during the Gradle build process, making it easier to read and understand the reported diagnostics. Rich output is available in supported terminal emulators for Linux and macOS. We’re working on adding support for Windows.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
In Kotlin %kotlinEapVersion%, we support color and other rich output in the console during the Gradle build process, making it easier to read and understand the reported diagnostics. Rich output is available in supported terminal emulators for Linux and macOS. We're working on adding support for Windows.
```
created_at: 2025-05-15T16:21:14Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
+
+However, the initial implementation of `copy()` was not compatible with inheritance, and this
+caused issues when a `@JsPlainObject` interface was inherited from other interfaces.
+
+To avoid limitations on plain objects, the `copy()` function has been moved from the object itself to its companion object:
+
+```kotlin
+@JsPlainObject
+external interface User {
+    val name: String
+    val age: Int
+}
+
+fun main() {
+    val user = User(name = "SomeUser", age = 21)
+    // This syntax is not valid anymore
+    val copy = user.copy(age = 35)      
+    // This is the correct syntax
+    val copy = User.copy(user, age = 35)
+}
+```
+
+This resolves conflicts in the inheritance hierarchy and eliminates ambiguity.
+
+This change is enabled by default starting from Kotlin %kotlinEapVersion%.
+
+### Support for typealiases in files with @JsModule annotation
+
+Previously, files annotated with `@JsModule` to import declarations from JavaScript modules
+were restricted to external declarations only. Meaning, you couldn't declare a `typealias` in such files.
+
+Starting with Kotlin %kotlinEapVersion%, you can declare typealiases inside files marked with `@JsModule`:
+
+```kotlin
+@file:JsModule("somepackage")
+package somepackage
+typealias SomeClass = Any
+```
+
+This change reduces an aspect of Kotlin/JS interoperability limitations, and more improvements are planned for future releases.
+
+Support for typealiases in files with `@JsModule` is enabled by default.
+
 ## Gradle
 
+Kotlin %kotlinEapVersion% is fully compatible with Gradle 7.6.3 through 8.14. You can also use Gradle versions up to the latest Gradle release. However, be aware that doing so may result in deprecation warnings, and some new Gradle features might not work.
+
+### Support for rich output in console for Kotlin Gradle plugin
+
+In Kotlin %kotlinEapVersion%, we support color and other rich output in the console during the Gradle build process, making it easier to read and understand the reported diagnostics. Rich output is available in supported terminal emulators for Linux and macOS. We’re working on adding support for Windows.
+
+![Gradle console](gradle-console-rich-output.png){width=600}
+
+This feature is enabled by default, but if you want to override it, you can use the following Gradle property in your `gradle.properties` file:
+
+```
+org.gradle.console=plain
+```
+
+For more information about this property and its options, see Gradle’s documentation on [Customizing log format](https://docs.gradle.org/current/userguide/command_line_interface.html#sec:command_line_customizing_log_format).
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
For more information about this property and its options, see Gradle's documentation on [Customizing log format](https://docs.gradle.org/current/userguide/command_line_interface.html#sec:command_line_customizing_log_format).
```
created_at: 2025-05-15T16:21:33Z
author_association: COLLABORATOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
+
+However, the initial implementation of `copy()` was not compatible with inheritance, and this
+caused issues when a `@JsPlainObject` interface was inherited from other interfaces.
+
+To avoid limitations on plain objects, the `copy()` function has been moved from the object itself to its companion object:
+
+```kotlin
+@JsPlainObject
+external interface User {
+    val name: String
+    val age: Int
+}
+
+fun main() {
+    val user = User(name = "SomeUser", age = 21)
+    // This syntax is not valid anymore
+    val copy = user.copy(age = 35)      
+    // This is the correct syntax
+    val copy = User.copy(user, age = 35)
+}
+```
+
+This resolves conflicts in the inheritance hierarchy and eliminates ambiguity.
+
+This change is enabled by default starting from Kotlin %kotlinEapVersion%.
+
+### Support for typealiases in files with @JsModule annotation
+
+Previously, files annotated with `@JsModule` to import declarations from JavaScript modules
+were restricted to external declarations only. Meaning, you couldn't declare a `typealias` in such files.
+
+Starting with Kotlin %kotlinEapVersion%, you can declare typealiases inside files marked with `@JsModule`:
+
+```kotlin
+@file:JsModule("somepackage")
+package somepackage
+typealias SomeClass = Any
+```
+
+This change reduces an aspect of Kotlin/JS interoperability limitations, and more improvements are planned for future releases.
+
+Support for typealiases in files with `@JsModule` is enabled by default.
+
 ## Gradle
 
+Kotlin %kotlinEapVersion% is fully compatible with Gradle 7.6.3 through 8.14. You can also use Gradle versions up to the latest Gradle release. However, be aware that doing so may result in deprecation warnings, and some new Gradle features might not work.
+
+### Support for rich output in console for Kotlin Gradle plugin
+
+In Kotlin %kotlinEapVersion%, we support color and other rich output in the console during the Gradle build process, making it easier to read and understand the reported diagnostics. Rich output is available in supported terminal emulators for Linux and macOS. We’re working on adding support for Windows.
+
+![Gradle console](gradle-console-rich-output.png){width=600}
+
+This feature is enabled by default, but if you want to override it, you can use the following Gradle property in your `gradle.properties` file:
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: koshachy
body: ```suggestion
This feature is enabled by default, but if you want to override it, add the following Gradle property to your `gradle.properties` file:
```
created_at: 2025-05-15T16:21:44Z
author_association: COLLABORATOR
diff_hunk: @@ -25,6 +26,146 @@ All you need to do is to [change the Kotlin version](configure-build-for-eap.md)
 
 See [Update to a new release](releases.md#update-to-a-new-kotlin-version) for details.
 
+## Language
+
+In this release, we promote some language features as stable and introduce the preview of context parameters.
+
+### Stable features: guard conditions, non-local break and continue, and multi-dollar interpolation
+
+In Kotlin 2.1.0, we introduced several new language features in preview. 
+We're happy to announce that these language features became 
+[Stable](components-stability.md#stability-levels-explained) in this release:
+
+* [Guard conditions in `when` with a subject](whatsnew21.md#guard-conditions-in-when-with-a-subject)
+* [Non-local `break` and `continue`](whatsnew21.md#non-local-break-and-continue)
+* [Multi-dollar interpolation: improved handling of `$` in string literals](whatsnew21.md#multi-dollar-string-interpolation)
+
+[See the full list of Kotlin language design features and proposals](kotlin-language-features-and-proposals.md).
+
+### Preview of context parameters
+
+<primary-label ref="experimental-general"/>
+
+In this release, we introduce the preview of context parameters.
+Context parameters allow functions and properties to declare dependencies that are implicitly available in the 
+surrounding context.
+
+This feature replaces an older experimental feature called context receivers. To migrate from context receivers to context 
+parameters, you can use assisted support in IntelliJ IDEA, as described in 
+this [blog post](https://blog.jetbrains.com/kotlin/2025/04/update-on-context-parameters/).
+
+#### How to declare context parameters
+
+You can declare context parameters for properties and functions using the `context` keyword
+followed by a list of parameters, each of the form `name: Type`. Let's look at an example with a dependency on the `UserService` interface:
+
+```kotlin
+// `UserService` defines the dependency required in context 
+interface UserService {
+    fun log(message: String)
+    fun findUserById(id: Int): String
+}
+
+// Declares a function with a context parameter
+context(users: UserService)
+fun outputMessage(message: String) {
+    // Uses `log` from the context
+    users.log("Log: $message")
+}
+
+// Declares a property with a context parameter
+context(users: UserService)
+val firstUser: String
+    // Uses `findUserById` from the context    
+    get() = users.findUserById(1)
+```
+
+You can use `_` as a context parameter name. In this case, the parameter's value is available for resolution but is not accessible by name inside the block:
+
+```kotlin
+// Uses `_` as context parameter name
+context(_: UserService)
+fun logWelcome() {
+    // Resolution still finds the appropriate `log` function from UserService
+    outputMessage("Welcome!")
+}
+```
+
+#### Context parameters resolution
+
+Kotlin resolves context parameters at the call site by searching for matching context values in the current scope. Kotlin matches them by their type.
+If multiple compatible values exist at the same scope level, the compiler reports an ambiguity:
+
+```kotlin
+// `UserService` defines the dependency required in context
+interface UserService {
+    fun log(message: String)
+}
+
+// Declares a function with a context parameter
+context(users: UserService)
+fun outputMessage(message: String) {
+    users.log("Log: $message")
+}
+
+fun main() {
+    // Implements `UserService` 
+    val serviceA = object : UserService {
+        override fun log(message: String) = println("A: $message")
+  }
+
+  // Implements `UserService`
+  val serviceB = object : UserService {
+      override fun log(message: String) = println("B: $message")
+  }
+
+  // Both `serviceA` and `serviceB` match the expected `UserService` type at the call site
+  context(serviceA, serviceB) {
+      outputMessage("This will not compile")
+      // Ambiguity error
+  }
+}
+```
+
+#### Restrictions
+
+Context parameters are in continuous improvement; some of the current restrictions are:
+
+* Constructors cannot declare context parameters
+* Properties with context parameters can't have backing fields or initializers
+* Properties with context parameters can't use delegation
+
+However, context parameters in Kotlin represent a significant improvement in managing dependencies through simplified dependency injection,
+improved DSL design, and scoped operations. For more information, see the feature's [KEEP](https://github.com/Kotlin/KEEP/blob/context-parameters/proposals/context-parameters.md).
+
+#### How to enable context parameters
+
+To enable context parameters in your project, use the following compiler option in the command line:
+
+```Bash
+-Xcontext-parameters
+```
+
+Or add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xcontext-parameters")
+    }
+}
+```
+
+> Specifying both `-Xcontext-receivers` and `-Xcontext-parameters` compiler options simultaneously leads to an error.
+>
+{style="warning"}
+
+#### Leave your feedback
+
+We plan to stabilize and improve this feature in future Kotlin releases.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: AlejandraPedroza
body: Great catch. I replaced some.
created_at: 2025-05-16T06:20:42Z
author_association: CONTRIBUTOR
diff_hunk: @@ -108,8 +251,203 @@ kotlin {
 }
 ```
 
+### Support for reading and writing annotations in Kotlin metadata
+
+<primary-label ref="experimental-general"/>
+
+Previously, you had to read annotations from compiled JVM class files using reflection or bytecode analysis and manually match them to metadata entries based on signatures.
+This process was error-prone, especially for overloaded functions.
+
+Now, in Kotlin %kotlinEapVersion%, the [Kotlin Metadata JVM library](metadata-jvm.md) introduces support for reading annotations stored in Kotlin metadata.
+
+To make annotations available in the metadata for your compiled files, add the following compiler option:
+
+```kotlin
+-Xannotations-in-metadata
+```
+
+Alternatively, add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotations-in-metadata")
+    }
+}
+```
+
+With this option enabled, the Kotlin compiler writes annotations into metadata alongside the JVM bytecode, making them accessible to the `kotlin-metadata-jvm` library.
+
+The library provides the following APIs for accessing annotations:
+
+* `KmClass.annotations`
+* `KmFunction.annotations`
+* `KmProperty.annotations`
+* `KmConstructor.annotations`
+* `KmPropertyAccessorAttributes.annotations`
+* `KmValueParameter.annotations`
+* `KmFunction.extensionReceiverAnnotations`
+* `KmProperty.extensionReceiverAnnotations`
+* `KmProperty.backingFieldAnnotations`
+* `KmProperty.delegateFieldAnnotations`
+* `KmEnumEntry.annotations`
+
+These APIs are [Experimental](components-stability.md#stability-levels-explained).
+To opt in, use the `@OptIn(ExperimentalAnnotationsInMetadata::class)` annotation.
+
+Here's an example of reading annotations from Kotlin metadata:
+
+```kotlin
+@file:OptIn(ExperimentalAnnotationsInMetadata::class)
+
+import kotlin.metadata.ExperimentalAnnotationsInMetadata
+import kotlin.metadata.jvm.KotlinClassMetadata
+
+annotation class Label(val value: String)
+
+@Label("Message class")
+class Message
+
+fun main() {
+    val metadata = Message::class.java.getAnnotation(Metadata::class.java)
+    val kmClass = (KotlinClassMetadata.readStrict(metadata) as KotlinClassMetadata.Class).kmClass
+    println(kmClass.annotations)
+    // [@Label(value = StringValue("Message class"))]
+}
+```
+
+> If you use the `kotlin-metadata-jvm` library in your projects, we recommend testing and updating your code to support annotations.
+> Otherwise, when annotations in metadata become [enabled by default](https://youtrack.jetbrains.com/issue/KT-75736) in a future Kotlin version, your projects may produce invalid or incomplete metadata.
+>
+> If you experience any problems, please report them in our [issue tracker](https://youtrack.jetbrains.com/issue/KT-31857).
+>
+{style="warning"}
+
+## Kotlin/Native
+
+### Per-object memory allocation
+
+<primary-label ref="experimental-opt-in"/>
+
+Kotlin/Native’s [memory allocator](https://github.com/JetBrains/kotlin/blob/master/kotlin-native/runtime/src/alloc/custom/README.md) can now reserve memory on a per-object basis. In some cases, it may help you avoid strict memory limitations or high memory consumption on the application's startup.
+
+The new feature is designed to replace the `-Xallocator=std` compiler option that enabled the system memory allocator instead of the default one. Now you can disable buffering (paging of allocations) without switching memory allocators.
+
+The feature is currently [Experimental](components-stability.md#stability-levels-explained).
+To enable it, set the following option in your `gradle.properties` file:
+
+```none
+kotlin.native.binary.pagedAllocator=false
+```
+
+Please report any problems to our issue tracker [YouTrack](https://kotl.in/issue).
+
+### LLVM update from 16 to 19
+
+In Kotlin %kotlinEapVersion%, we updated LLVM from version 16 to 19.
+The new version includes performance improvements, bug fixes, and security updates.
+
+This update shouldn't affect your code, but if you encounter any issues, please report them to our [issue tracker](http://kotl.in/issue).
+
+## Kotlin/Wasm: wasmJs target separated from js target
+
+Before, the `wasmJs` target shared the same infrastructure as the `js` target, meaning that both were hosted in the same
+directory (`build/js`) and used the same NPM tasks and configurations.
+
+Now, the `wasmJs` target has its own infrastructure separate from the `js` target. This allows the
+Wasm tasks and types to be distinct from the JavaScript ones, enabling independent configuration.
+
+Additionally, the Wasm-related project files and NPM dependencies are now in a separate directory: `build/wasm`.
+
+New NPM-related tasks have been introduced for Wasm, while existing JavaScript tasks are now dedicated only to JavaScript:
+
+| **Wasm tasks**         | **JavaScript tasks** |
+|------------------------|----------------------|
+| `kotlinWasmNpmInstall` | `kotlinNpmInstall`   |
+| `wasmRootPackageJson`  | `rootPackageJson`    |
+
+Similarly, new Wasm-specific declarations are introduced:
+
+| **Wasm declarations**     | **JavaScript declarations** |
+|---------------------------|-----------------------------|
+| `WasmNodeJsRootPlugin`    | `NodeJsRootPlugin`          |
+| `WasmNodeJsPlugin`        | `NodeJsPlugin`              |
+| `WasmYarnPlugin`          | `YarnPlugin`                |
+| `WasmNodeJsRootExtension` | `NodeJsRootExtension`       |
+| `WasmNodeJsEnvSpec`       | `NodeJsEnvSpec`             |
+| `WasmYarnRootEnvSpec`     | `YarnRootEnvSpec`           |
+
+This change allows you to work with the Wasm target independently of the JavaScript target, simplifying the configuration.
+
+You don't require additional setup; this change is enabled by default.
+
+## Kotlin/JS
+
+### Fix for copy() in @JsPlainObject interfaces
+
+Kotlin/JS has an experimental plugin called `js-plain-objects`, which introduced a `copy()` function for interfaces annotated with `@JsPlainObject`. The `copy()`  function is useful for manipulating objects.
+
+However, the initial implementation of `copy()` was not compatible with inheritance, and this
+caused issues when a `@JsPlainObject` interface was inherited from other interfaces.
path: docs/topics/whatsnew/whatsnew-eap.md
user: login: AlejandraPedroza
body: Corrected.
created_at: 2025-05-16T06:35:35Z
author_association: CONTRIBUTOR

PR comments:
user: login: AlexanderPrendota
created_at: 2025-05-15T12:58:37Z
body: Bad samples
Snippets:
File: docs/topics/whatsnew/whatsnew-eap.md

```kotlin
import kotlin.io.encoding.*
import java.io.ByteArrayOutputStream

//sampleStart
fun main() {
    val output = ByteArrayOutputStream()
    val base64Output = output.encodingWith(Base64.Default)

    base64Output.use { stream ->
        stream.write("Hello World!!".encodeToByteArray())
    }

    println(output.toString())
    // SGVsbG8gV29ybGQhIQ==
}
//sampleEnd
```

(6:30, 6:42) **ERROR** This declaration needs opt-in. Its usage must be marked with '@kotlin.io.encoding.ExperimentalEncodingApi' or '@OptIn(kotlin.io.encoding.ExperimentalEncodingApi::class)'
(6:50, 6:57) **ERROR** This declaration needs opt-in. Its usage must be marked with '@kotlin.io.encoding.ExperimentalEncodingApi' or '@OptIn(kotlin.io.encoding.ExperimentalEncodingApi::class)'
    
------


author_association: CONTRIBUTOR
user: login: AlejandraPedroza
created_at: 2025-05-15T15:14:42Z
body: @daniCsorbaJB  We've got an error in a code sample from Kotlin standard library. Could you please take a look? Thank you!
https://github.com/JetBrains/kotlin-web-site/pull/4844#issuecomment-2883726626

author_association: CONTRIBUTOR
user: login: AlexanderPrendota
created_at: 2025-05-15T15:21:36Z
body: Bad samples
Snippets:
File: docs/topics/whatsnew/whatsnew-eap.md

```kotlin
import kotlin.io.encoding.*
import java.io.ByteArrayOutputStream

//sampleStart
fun main() {
    val output = ByteArrayOutputStream()
    val base64Output = output.encodingWith(Base64.Default)

    base64Output.use { stream ->
        stream.write("Hello World!!".encodeToByteArray())
    }

    println(output.toString())
    // SGVsbG8gV29ybGQhIQ==
}
//sampleEnd
```

(6:30, 6:42) **ERROR** This declaration needs opt-in. Its usage must be marked with '@kotlin.io.encoding.ExperimentalEncodingApi' or '@OptIn(kotlin.io.encoding.ExperimentalEncodingApi::class)'
(6:50, 6:57) **ERROR** This declaration needs opt-in. Its usage must be marked with '@kotlin.io.encoding.ExperimentalEncodingApi' or '@OptIn(kotlin.io.encoding.ExperimentalEncodingApi::class)'
    
------


author_association: CONTRIBUTOR
user: login: AlexanderPrendota
created_at: 2025-05-16T06:50:32Z
body: Bad samples
Snippets:
File: docs/topics/whatsnew/whatsnew-eap.md

```kotlin
import kotlin.io.encoding.*
import java.io.ByteArrayOutputStream

//sampleStart
fun main() {
    val output = ByteArrayOutputStream()
    val base64Output = output.encodingWith(Base64.Default)

    base64Output.use { stream ->
        stream.write("Hello World!!".encodeToByteArray())
    }

    println(output.toString())
    // SGVsbG8gV29ybGQhIQ==
}
//sampleEnd
```

(6:30, 6:42) **ERROR** This declaration needs opt-in. Its usage must be marked with '@kotlin.io.encoding.ExperimentalEncodingApi' or '@OptIn(kotlin.io.encoding.ExperimentalEncodingApi::class)'
(6:50, 6:57) **ERROR** This declaration needs opt-in. Its usage must be marked with '@kotlin.io.encoding.ExperimentalEncodingApi' or '@OptIn(kotlin.io.encoding.ExperimentalEncodingApi::class)'
    
------


author_association: CONTRIBUTOR