diff --git a/docs/kr.tree b/docs/kr.tree
index d0f5be27256..05a0ff25bb9 100644
--- a/docs/kr.tree
+++ b/docs/kr.tree
@@ -125,51 +125,32 @@
     </toc-element>
 
     <toc-element toc-title="Multiplatform development">
-        <toc-element toc-title="Kotlin Multiplatform for iOS and Android">
-            <toc-element id="multiplatform-mobile-getting-started.md" accepts-web-file-names="kmm-getting-started.html"/>
-            <toc-element id="multiplatform-mobile-setup.md" accepts-web-file-names="kmm-setup.html" toc-title="1. Set up an environment"/>
-            <toc-element id="multiplatform-mobile-create-first-app.md" accepts-web-file-names="kmm-create-first-app.html" toc-title="2. Create your first cross-platform app"/>
-            <toc-element id="multiplatform-mobile-dependencies.md" toc-title="3. Add dependencies"/>
-            <toc-element id="multiplatform-mobile-upgrade-app.md" toc-title="4. Upgrade your app"/>
-            <toc-element id="multiplatform-mobile-wrap-up.md" toc-title="5. Wrap up your project"/>
-            <toc-element id="multiplatform-mobile-understand-project-structure.md" accepts-web-file-names="kmm-understand-project-structure.html"/>
-            <toc-element id="multiplatform-mobile-integrate-in-existing-app.md" accepts-web-file-names="kmm-integrate-in-existing-app.html"/>
-            <toc-element id="multiplatform-mobile-publish-apps.md" accepts-web-file-names="kmm-publish-apps.html"/>
-            <toc-element id="multiplatform-mobile-ktor-sqldelight.md"/>
-        </toc-element>
-        <toc-element toc-title="Kotlin Multiplatform for other platforms">
-            <toc-element id="multiplatform-get-started.md" accepts-web-file-names="building-mpp-with-gradle.html,intro-to-kotlin-mpp.html,mpp-intro.html,mpp-get-started.html,multiplatform-tutorials.html"/>
-            <toc-element id="multiplatform-discover-project.md" accepts-web-file-names="mpp-discover-project.html"/>
-            <toc-element id="multiplatform-set-up-targets.md" toc-title="Set up targets manually" accepts-web-file-names="mpp-set-up-targets.html"/>
-            <toc-element id="multiplatform-full-stack-app.md" hidden="true"/>
-        </toc-element>
-        <toc-element toc-title="Creating multiplatform libraries">
-            <toc-element id="multiplatform-library.md" accepts-web-file-names="working-with-klib.html,multiplatform-create-lib.html,mpp-create-lib.html"/>
-            <toc-element id="multiplatform-publish-lib.md" accepts-web-file-names="mpp-publish-lib.html"/>
-        </toc-element>
-        <toc-element toc-title="Sharing code principles">
+        <toc-element id="multiplatform-get-started.md" accepts-web-file-names="building-mpp-with-gradle.html,intro-to-kotlin-mpp.html,mpp-intro.html,mpp-get-started.html,multiplatform-tutorials.html"/>
+        <toc-element id="multiplatform-discover-project.md" accepts-web-file-names="mpp-discover-project.html"/>
+        <toc-element id="multiplatform-set-up-targets.md" toc-title="Set up targets" accepts-web-file-names="mpp-set-up-targets.html"/>
+        <toc-element toc-title="Share code">
             <toc-element id="multiplatform-share-on-platforms.md" accepts-web-file-names="mpp-share-on-platforms.html"/>
             <toc-element id="multiplatform-expect-actual.md"/>
             <toc-element id="multiplatform-hierarchy.md" accepts-web-file-names="migrating-multiplatform-project-to-14.html"/>
-            <toc-element id="multiplatform-android-layout.md"/>
         </toc-element>
-        <toc-element toc-title="Adding dependencies">
+        <toc-element toc-title="Add dependencies">
             <toc-element id="multiplatform-add-dependencies.md" toc-title="On multiplatform libraries" accepts-web-file-names="mpp-add-dependencies.html"/>
             <toc-element id="multiplatform-mobile-android-dependencies.md" accepts-web-file-names="kmm-add-dependencies.html,multiplatform-mobile-add-dependencies.html" toc-title="For Android target platforms"/>
             <toc-element id="multiplatform-mobile-ios-dependencies.md" toc-title="For iOS target platforms"/>
         </toc-element>
-        <toc-element id="multiplatform-run-tests.md" toc-title="Running tests" accepts-web-file-names="mpp-run-tests.html"/>
-        <toc-element toc-title="Artifact compilation">
+        <toc-element toc-title="Compile artifacts">
             <toc-element id="multiplatform-configure-compilations.md" accepts-web-file-names="mpp-configure-compilations.html"/>
             <toc-element toc-title="[Experimental DSL] Build final native binaries" id="multiplatform-native-artifacts.md" hidden="true"/>
             <toc-element id="multiplatform-build-native-binaries.md" accepts-web-file-names="mpp-build-native-binaries.html"/>
         </toc-element>
-        <toc-element id="multiplatform-dsl-reference.md" accepts-web-file-names="mpp-dsl-reference.html,mpp-supported-platforms.html,multiplatform-supported-platforms.html"/>
-        <toc-element id="multiplatform-mobile-samples.md" toc-title="Samples" accepts-web-file-names="kmm-samples.html"/>
-        <toc-element id="multiplatform-mobile-faq.md" accepts-web-file-names="kmm-faq.html" toc-title="FAQ"/>
+        <toc-element id="multiplatform-publish-lib.md" accepts-web-file-names="mpp-publish-lib.html" toc-title="Publish libraries"/>
         <toc-element id="multiplatform-mobile-introduce-your-team.md" accepts-web-file-names="kmm-introduce-your-team.html"/>
-        <toc-element id="multiplatform-compatibility-guide.md" toc-title="Compatibility guide"/>
-        <toc-element id="multiplatform-mobile-plugin-releases.md" accepts-web-file-names="kmm-plugin-releases.html"/>
+        <toc-element toc-title="Reference">
+            <toc-element id="multiplatform-dsl-reference.md" accepts-web-file-names="mpp-dsl-reference.html,mpp-supported-platforms.html,multiplatform-supported-platforms.html"/>
+            <toc-element id="multiplatform-android-layout.md"/>
+            <toc-element id="multiplatform-compatibility-guide.md" toc-title="Compatibility guide"/>
+            <toc-element id="multiplatform-mobile-plugin-releases.md" accepts-web-file-names="kmm-plugin-releases.html"/>
+        </toc-element>
     </toc-element>
 
     <toc-element toc-title="Platforms">
diff --git a/docs/topics/android-overview.md b/docs/topics/android-overview.md
index 71e84b1b8a4..5bdde3c1195 100644
--- a/docs/topics/android-overview.md
+++ b/docs/topics/android-overview.md
@@ -35,4 +35,4 @@ on [the Google website for Android developers](https://developer.android.com/kot
 To start using Kotlin for:
 
 * Android development, read [Google's documentation for developing Android apps with Kotlin](https://developer.android.com/kotlin/get-started).
-* Developing cross-platform mobile applications, see [Get started with Kotlin Multiplatform for Android and iOS](multiplatform-mobile-getting-started.md).
+* Developing cross-platform mobile applications, see [Get started with Kotlin Multiplatform for Android and iOS](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html).
diff --git a/docs/topics/cross-platform-frameworks.md b/docs/topics/cross-platform-frameworks.md
index 9848deff1a2..1dc1a386351 100644
--- a/docs/topics/cross-platform-frameworks.md
+++ b/docs/topics/cross-platform-frameworks.md
@@ -70,7 +70,7 @@ Kotlin Multiplatform Mobile is an SDK developed by JetBrains for creating Androi
 
 Even though this cross-platform mobile development framework is the youngest on our list, it has a mature community. It's growing fast and is already making a distinct impression on today's market. Thanks to its regularly updated documentation and community support, you can always find answers to your questions. What's more, many [global companies and startups already use Kotlin Multiplatform Mobile](https://kotlinlang.org/lp/multiplatform/case-studies/) to develop multiplatform apps with a native-like user experience.
 
-> Create your first cross-platform mobile app with [Kotlin Multiplatform Mobile](multiplatform-mobile-getting-started.md).
+> Create your first cross-platform mobile app with [Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html).
 >
 {type="note"}
 
diff --git a/docs/topics/cross-platform-mobile-development.md b/docs/topics/cross-platform-mobile-development.md
index 4a88cf427b7..38078a62e86 100644
--- a/docs/topics/cross-platform-mobile-development.md
+++ b/docs/topics/cross-platform-mobile-development.md
@@ -149,7 +149,7 @@ Kotlin Multiplatform Mobile is an SDK for cross-platform mobile development prov
 * Full control over the UI, along with the ability to use the latest UI frameworks, such as SwiftUI and Jetpack Compose.
 * Easy access to Android and iOS SDKs without any restrictions.
 
-> Share the logic of your iOS and Android apps. Get started with [Kotlin Multiplatform Mobile](multiplatform-mobile-getting-started.md).
+> Share the logic of your iOS and Android apps. Get started with [Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html).
 >
 {type="note"}
 
diff --git a/docs/topics/getting-started.md b/docs/topics/getting-started.md
index 025b7da08e0..6f2ad1b3161 100644
--- a/docs/topics/getting-started.md
+++ b/docs/topics/getting-started.md
@@ -75,32 +75,32 @@ If you've encountered any difficulties or problems, report an issue to our [issu
 
 Here you'll learn how to develop and improve your cross-platform mobile application using [Kotlin Multiplatform](https://kotlinlang.org/lp/multiplatform/).
 
-1. **[Set up your environment for cross-platform mobile development](multiplatform-mobile-setup.md).**
+1. **[Set up your environment for cross-platform development](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-setup.html).**
 
 2. **Create your first application for iOS and Android:**
 
-   * To start from scratch, [create a basic cross-platform mobile application with the project wizard](multiplatform-mobile-create-first-app.md).
-   * If you have an existing Android application and want to make it cross-platform, complete the [Make your Android application work on iOS](multiplatform-mobile-integrate-in-existing-app.md) tutorial.
-   * If you prefer real-life examples, clone and play with an existing project, for example the networking and data storage project from the [Create a multiplatform app using Ktor and SQLdelight](multiplatform-mobile-ktor-sqldelight.md) tutorial or any [sample project](multiplatform-mobile-samples.md).
+   * To start from scratch, [create a basic cross-platform mobile application with the project wizard](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-create-first-app.html).
+   * If you have an existing Android application and want to make it cross-platform, complete the [Make your Android application work on iOS](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-integrate-in-existing-app.html) tutorial.
+   * If you prefer real-life examples, clone and play with an existing project, for example the networking and data storage project from the [Create a multiplatform app using Ktor and SQLdelight](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-ktor-sqldelight.html) tutorial or any [sample project](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-samples.html).
 
 3. **Use a wide set of multiplatform libraries** to implement the required business logic only once in the shared module. Learn more about [adding dependencies](multiplatform-add-dependencies.md).
 
-   |Library|Details|
-   |-------|-------| 
-   | Ktor | [Docs](https://ktor.io/docs/client.html)| 
-   | Serialization | [Docs](serialization.md) and [sample](multiplatform-mobile-ktor-sqldelight.md#create-an-application-data-model)|
-   | Coroutines | [Docs](coroutines-guide.md) and [sample](coroutines-and-channels.md)|
-   | DateTime | [Docs](https://github.com/Kotlin/kotlinx-datetime#readme)|
-   | SQLDelight | Third-party library. [Docs](https://cashapp.github.io/sqldelight/)|
+   |Library| Details                                                                                                                                                            |
+   |-------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------| 
+   | Ktor | [Docs](https://ktor.io/docs/client.html)                                                                                                                           | 
+   | Serialization | [Docs](serialization.md) and [sample](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-ktor-sqldelight.html#create-an-application-data-model) |
+   | Coroutines | [Docs](coroutines-guide.md) and [sample](coroutines-and-channels.md)                                                                                               |
+   | DateTime | [Docs](https://github.com/Kotlin/kotlinx-datetime#readme)                                                                                                          |
+   | SQLDelight | Third-party library. [Docs](https://cashapp.github.io/sqldelight/)                                                                                                 |
    
    > You can also find a multiplatform library in the [community-driven list](https://libs.kmp.icerock.dev/).
    > 
    {type="tip"}
 
-4. **Learn more about Kotlin Multiplatform for mobile:**
+4. **Learn more about Kotlin Multiplatform:**
    * Learn more about [Kotlin Multiplatform](multiplatform-get-started.md).
-   * Look through [samples on GitHub](multiplatform-mobile-samples.md).
-   * [Create and publish a multiplatform library](multiplatform-library.md).
+   * Look through [samples projects](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-samples.html).
+   * [Publish a multiplatform library](multiplatform-publish-lib.md).
    * Learn how Kotlin Multiplatform is used at [Netflix](https://netflixtechblog.com/netflix-android-and-ios-studio-apps-kotlin-multiplatform-d6d4d8d25d23), [VMware](https://kotlinlang.org/lp/multiplatform/case-studies/vmware/), [Yandex](https://kotlinlang.org/lp/multiplatform/case-studies/yandex/), and [many other companies](https://kotlinlang.org/lp/multiplatform/case-studies/).
 
 5. **Join the Kotlin Multiplatform community:**
@@ -130,9 +130,9 @@ Support for multiplatform programming is one of Kotlin's key benefits. It reduce
 
 Here you'll learn how to develop and publish a multiplatform library:
 
-1. **Create a multiplatform library:**
+1. **Publish a multiplatform library:**
 
-   * Complete the [Create and publish a multiplatform library](multiplatform-library.md) tutorial. It shows how to create a multiplatform library for JVM, JS, and Native platforms, test it and publish to a local Maven repository.
+   * See [Publish a multiplatform library](multiplatform-publish-lib.md) to learn more.
 
 2. **Use libraries in your application:**
 
diff --git a/docs/topics/gradle/gradle-configure-project.md b/docs/topics/gradle/gradle-configure-project.md
index f44719dc878..d0c50e1e734 100644
--- a/docs/topics/gradle/gradle-configure-project.md
+++ b/docs/topics/gradle/gradle-configure-project.md
@@ -567,7 +567,7 @@ plugins {
 </tabs>
 
 Learn more about [Kotlin Multiplatform for different platforms](multiplatform-get-started.md) and 
-[Kotlin Multiplatform for iOS and Android](multiplatform-mobile-getting-started.md).
+[Kotlin Multiplatform for iOS and Android](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html).
 
 ## Targeting Android
 
diff --git a/docs/topics/home.xml b/docs/topics/home.xml
index 090bc3c02d7..cde9359fb26 100644
--- a/docs/topics/home.xml
+++ b/docs/topics/home.xml
@@ -38,10 +38,10 @@
                 <a href="roadmap.md" description="Future plans on Kotlin development">Kotlin public roadmap</a>
             </group>
             <group type="cards">
-                <title>Kotlin Multiplatform for mobile</title>
-                <a href="multiplatform-mobile-getting-started.md" description="Useful links to help you start using the SDK">Get started</a>
+                <title>Kotlin Multiplatform</title>
+                <a href="multiplatform-get-started.md" description="Useful links to help you start using the SDK">Get started</a>
                 <a href="multiplatform-mobile-plugin-releases.md" description="Features of the Kotlin Multiplatform Mobile plugin">Plugin releases for Android Studio</a>
-                <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C" description="Videos about Kotlin Multiplatform for mobile on our YouTube channel">Kotlin Multiplatform Multiverse</a>
+                <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C" description="Videos about Kotlin Multiplatform on our YouTube channel">Kotlin Multiplatform Multiverse</a>
             </group>
             <group type="links" display="normal">
                 <link-collection>
@@ -61,7 +61,7 @@
                     <a href="https://www.youtube.com/channel/UCP7uiEZIqci43m22KDl0sNw" description="Official Kotlin YouTube channel">Kotlin YouTube channel</a>
                     <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmxOJL0GSSZ1Vot4KL2Vwe7x" description="Tutorials on using Kotlin with Spring">Kotlin in Spring Framework</a>
                     <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmx-dpq9nkdaVJX0GnrM1Mp1" description="Webinars on using Kotlin for server-side development">Webinars with experts</a>
-                    <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C" description="Tutorials on using Kotlin Multiplatform for mobile">Kotlin Multiplatform Multiverse</a>
+                    <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C" description="Tutorials on using Kotlin Multiplatform">Kotlin Multiplatform Multiverse</a>
                     <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmyQA0l15nAfE1-pnu6fSvvG" description="Kotlin for competitive programming">Competitive programming</a>
                     <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmy6Fz9aq-JMlzk34ce5hJrg" description="Tutorials on using the standard library">Kotlin standard library</a>
                     <a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmz1TwkP9SKCHU978dqLTANB" description="Talking Kotlin podcast">Talking Kotlin podcast</a>
diff --git a/docs/topics/kotlin-hands-on.md b/docs/topics/kotlin-hands-on.md
index 724a5ce7b9c..950a2e17140 100644
--- a/docs/topics/kotlin-hands-on.md
+++ b/docs/topics/kotlin-hands-on.md
@@ -39,12 +39,6 @@ Learn how to serve files, use templating engines such as Freemarker and the kotl
 
 [**Start**](https://ktor.io/docs/creating-interactive-website.html)
 
-## Building a full stack web app with Kotlin Multiplatform
-
-Create an application with Kotlin/JVM and Kotlin/JS, and explore topics around code sharing, serialization, server- and client-side development.
-
-[**Start**](multiplatform-full-stack-app.md)
-
 ## Introduction to Kotlin coroutines and channels
 
 Learn about coroutines in Kotlin and how you can communicate between them using channels.
@@ -61,10 +55,10 @@ Create a simple HTTP client that can run natively on multiple platforms using Ko
 
 Learn how to create a mobile application for Android and iOS using Kotlin Multiplatform with Ktor and SQLDelight.
 
-[**Start**](multiplatform-mobile-ktor-sqldelight.md)
+[**Start**](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-ktor-sqldelight.html)
 
 ## Targeting iOS and Android with Kotlin Multiplatform
 
 Learn how to create a mobile application that can target both iOS and Android using Kotlin Multiplatform.
 
-[**Start**](multiplatform-mobile-create-first-app.md)
\ No newline at end of file
+[**Start**](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-create-first-app.html)
\ No newline at end of file
diff --git a/docs/topics/kotlin-ide.md b/docs/topics/kotlin-ide.md
index 3b117befce9..d42c4d2b9b7 100644
--- a/docs/topics/kotlin-ide.md
+++ b/docs/topics/kotlin-ide.md
@@ -53,5 +53,5 @@ Also, you could use package managers, such as [Homebrew](command-line.md#homebre
 ## What's next?
 
 * [Start your first project using IntelliJ IDEA IDE](jvm-get-started.md)
-* [Create your first cross-platform mobile app using Android Studio](multiplatform-mobile-create-first-app.md)
+* [Create your first cross-platform mobile app using Android Studio](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-create-first-app.html)
 * Learn how to [install EAP version of the Kotlin plugin](install-eap-plugin.md)
\ No newline at end of file
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-android-dependencies.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-android-dependencies.md
index 56a41f1e96c..637d3dc2d6a 100644
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-android-dependencies.md
+++ b/docs/topics/multiplatform-mobile/multiplatform-mobile-android-dependencies.md
@@ -4,7 +4,7 @@ The workflow for adding Android-specific dependencies to a Kotlin Multiplatform
 Android projects: declare the dependency in your Gradle file and import the project. After that, you can use this
 dependency in your Kotlin code.
 
-We recommend declaring Android dependencies in Multiplatform Mobile projects by adding them to a specific Android source
+We recommend declaring Android dependencies in Kotlin Multiplatform projects by adding them to a specific Android source
 set. For that, update your `build.gradle(.kts)` file in the `shared` directory of your project:
 
 <tabs group="build-script">
@@ -32,7 +32,7 @@ sourceSets {
 </tab>
 </tabs>
 
-Moving what was a top-level dependency in an Android project to a specific source set in a Multiplatform Mobile project
+Moving what was a top-level dependency in an Android project to a specific source set in a multiplatform project
 might be difficult if the top-level dependency had a non-trivial configuration name. For example, to move
 a `debugImplementation` dependency from the top level of an Android project, you'll need to add an implementation
 dependency to the source set named `androidDebug`. To minimize the effort you have to put in to deal with migration
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-create-first-app.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-create-first-app.md
deleted file mode 100644
index bef37210716..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-create-first-app.md
+++ /dev/null
@@ -1,185 +0,0 @@
-[//]: # (title: Create your first cross-platform app)
-
-<microformat>
-    <p>This is the second part of the <strong>Getting started with Kotlin Multiplatform for mobile</strong> tutorial. Before proceeding, make sure you've completed the previous step.</p>
-    <p><img src="icon-1-done.svg" width="20" alt="First step"/> <a href="multiplatform-mobile-setup.md">Set up an environment</a><br/><img src="icon-2.svg" width="20" alt="Second step"/> <strong>Create your first cross-platform app</strong><br/><img src="icon-3-todo.svg" width="20" alt="Third step"/> Add dependencies<br/><img src="icon-4-todo.svg" width="20" alt="Fourth step"/> Upgrade your app<br/><img src="icon-5-todo.svg" width="20" alt="Fifth step"/> Wrap up your project</p>
-</microformat>
-
-Here you will learn how to create and run your first Kotlin Multiplatform application using Android Studio.
-
-## Create the project from a template
-
-> You can also watch the [video version of this tutorial](https://www.youtube.com/watch?v=GcqFhoUuNNI) created by Ekaterina
-> Petrova, Kotlin Product Marketing Manager.
->
-{type="tip"}
-
-1. In Android Studio, select **File | New | New Project**.
-2. Select **Kotlin Multiplatform App** in the list of project templates, and click **Next**.  
-
-    ![Mobile Multiplatform project template](multiplatform-mobile-project-wizard-1.png){width=700}
-    
-3. Specify a name for your first application, and click **Next**.  
-
-    ![Mobile Multiplatform project - general settings](multiplatform-mobile-project-wizard-2.png){width=700}
-
-4. In the **iOS framework distribution** list, select the **Regular framework** option.
-
-   ![Mobile Multiplatform project - additional settings](multiplatform-mobile-project-wizard-3.png){width=700}
-
-   > We recommend using the regular framework for your first project, as this option doesn't require third-party tools and
-   > has fewer installation issues.
-   > 
-   > For more complex projects, you might need the CocoaPods dependency manager that helps handle library dependencies.
-   > To learn more about CocoaPods and how to set up an environment for them, see [CocoaPods overview and setup](native-cocoapods.md).
-   >
-   {type="tip"}
-
-5. Keep the default names for the application and shared folders. Click **Finish**.
-
-The project will be set up automatically. It may take some time to download and set up the required components when you
-do this for the first time.
-
-## Examine the project structure
-
-To view the full structure of your mobile multiplatform project, switch the view from **Android** to **Project**.
-
-![Select the Project view](select-project-view.png){width=200}  
-
-Each Kotlin Multiplatform project includes three modules:
-
-* _shared_ is a Kotlin module that contains the logic common for both Android and iOS applications – the code you share
-  between platforms. It uses [Gradle](gradle.md) as the build system that helps you automate your build process. The _shared_
-  module builds into an Android library and an iOS framework.
-* _androidApp_ is a Kotlin module that builds into an Android application. It uses Gradle as the build system.
-  The _androidApp_ module depends on and uses the shared module as a regular Android library.
-* _iosApp_ is an Xcode project that builds into an iOS application. It depends on and uses the shared module as an iOS
-  framework. The shared module can be used as a regular framework or as a [CocoaPods dependency](native-cocoapods.md),
-  based on what you've chosen in the previous step in **iOS framework distribution**. In this tutorial, it's a regular
-  framework dependency.
-
-![Basic Multiplatform Mobile project structure](basic-project-structure.png){width=500}
-
-The shared module consists of three source sets: `androidMain`, `commonMain`, and `iosMain`. _Source set_ is a Gradle
-concept for a number of files logically grouped together where each group has its own dependencies. In Kotlin Multiplatform,
-different source sets in a shared module can target different platforms.
-
-![Source sets and modules structure](basic-project-structure-2.png){width=200}
-
-> This is an example structure of a Multiplatform Mobile project that you create with the project wizard in IntelliJ IDEA
-> or Android Studio. Real-life projects can have more complex structures.
->
-{type="note"}
-
-## Run your application
-
-You can run your multiplatform application on [Android](#run-your-application-on-android) or [iOS](#run-your-application-on-ios).
-
-### Run your application on Android
-
-1. Create an [Android virtual device](https://developer.android.com/studio/run/managing-avds#createavd).
-2. In the list of run configurations, select **androidApp**.
-3. Choose your Android virtual device and click **Run**.  
-    
-    ![Run multiplatform app on Android](run-android.png){width=400}
-    
-    ![First mobile multiplatform app on Android](first-multiplatform-project-on-android-1.png){width=300}
-
-#### Run on a different Android simulated device {initial-collapse-state="collapsed"}
-
-Learn how to [configure the Android Emulator and run your application on a different simulated device](https://developer.android.com/studio/run/emulator#runningapp).
-    
-#### Run on a real Android device {initial-collapse-state="collapsed"}
-
-Learn how to [configure and connect a hardware device and run your application on it](https://developer.android.com/studio/run/device).
-
-### Run your application on iOS
-
-1. Launch Xcode in a separate window. The first time you may also need to accept its license terms and allow it to perform
-   some necessary initial tasks.
-2. In Android Studio, select **iosApp** in the list of run configurations and click **Run**.
-   
-   If you don't have an available iOS configuration in the list, add a [new iOS simulated device](#run-on-a-new-ios-simulated-device).
-    
-    ![Run multiplatform app on iOS](run-ios.png){width=450}
-    
-    ![First mobile multiplatform app on Android](first-multiplatform-project-on-ios-1.png){width=300}
-
-#### Run on a new iOS simulated device {initial-collapse-state="collapsed"}
-
-If you want to run your application on a simulated device, you can add a new run configuration.
-
-1. In the list of run configurations, click **Edit Configurations**.
-
-    ![Edit run configurations](ios-edit-configurations.png){width=450}
-
-2. Click the **+** button above the list of configurations and select **iOS Application**.
-
-    ![New run configuration for iOS application](ios-new-configuration.png)
-
-3. Name your configuration.
-4. Select the **Xcode project file**. For that, navigate to your project, for example **KotlinMultiplatformSandbox**,
-   open the`iosApp` folder and select the `.xcodeproj` file.
-
-5. In the **Execution target** list, select a simulated device and click **OK**.
-
-    ![New run configuration with iOS simulator](ios-new-simulator.png)
-    
-6. Click **Run** to run your application on the new simulated device.
-    
-#### Run on a real iOS device {initial-collapse-state="collapsed"}
-
-1. Connect a real iPhone device to Xcode.
-2. Make sure to code sign your app. For more information, see the [official Apple documentation](https://developer.apple.com/documentation/xcode/running-your-app-in-simulator-or-on-a-device/).
-3. [Create a run configuration](#run-on-a-new-ios-simulated-device) by selecting an iPhone in the **Execution target** list.
-4. Click **Run** to run your application on the iPhone device.
-
-> If your build fails, follow the workaround described in [this issue](https://youtrack.jetbrains.com/issue/KT-40907).
->
-{type="note"}
-
-## Update your application
-
-1. In `shared/src/commonMain/kotlin`, open the `Greeting.kt` file in the project folder. This directory stores the shared
-code for both Android and iOS. If you make changes to the shared code, you will see them reflected in both applications.
-
-   ![Common Kotlin file](common-kotlin-file.png)
-
-2. Update the shared code by using `[reversed()](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/reversed.html)`,
-the Kotlin standard library function for reversing text that works on all platforms:
-
-    ```kotlin
-    class Greeting {
-        private val platform: Platform = getPlatform()
-        
-        fun greet(): String {
-            return "Guess what it is! > ${platform.name.reversed()}!"
-        }
-    }
-    ```
-
-3. Re-run the **androidApp** configuration to see the updated application in the Android simulated device.
-
-    ![Updated mobile multiplatform app on Android](first-multiplatform-project-on-android-2.png){width=300}
-    
-4. In Android Studio, switch to **iosApp** and re-run it to see the updated application in the iOS simulated device.  
-
-    ![Updated mobile multiplatform app on iOS](first-multiplatform-project-on-ios-2.png){width=300}
-
-## Next step
-
-In the next part of the tutorial, you'll learn about dependencies and add a third-party library to expand
-the functionality of your project.
-
-**[Proceed to the next part](multiplatform-mobile-dependencies.md)**
-
-### See also
-
-* See how to [create and run multiplatform tests](multiplatform-run-tests.md) to check that the code works correctly.
-* Learn more about the [project structure](multiplatform-mobile-understand-project-structure.md), the shared module's
-artifacts, and how the Android and iOS apps are produced.
-
-## Get help
-
-* **Kotlin Slack**. Get an [invite](https://surveys.jetbrains.com/s3/kotlin-slack-sign-up) and join the [#multiplatform](https://kotlinlang.slack.com/archives/C3PQML5NU) channel.
-* **Kotlin issue tracker**. [Report a new issue](https://youtrack.jetbrains.com/newIssue?project=KT).
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-dependencies.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-dependencies.md
deleted file mode 100644
index 22202f6e7c4..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-dependencies.md
+++ /dev/null
@@ -1,109 +0,0 @@
-[//]: # (title: Add dependencies to your project)
-
-<microformat>
-    <p>This is the third part of the <strong>Getting started with Kotlin Multiplatform for mobile</strong> tutorial. Before proceeding, make sure you've completed previous steps.</p>
-    <p><img src="icon-1-done.svg" width="20" alt="First step"/> <a href="multiplatform-mobile-setup.md">Set up an environment</a><br/><img src="icon-2-done.svg" width="20" alt="Second step"/> <a href="multiplatform-mobile-create-first-app.md">Create your first cross-platform app</a><br/><img src="icon-3.svg" width="20" alt="Third step"/> <strong>Add dependencies</strong><br/><img src="icon-4-todo.svg" width="20" alt="Fourth step"/> Upgrade your app<br/><img src="icon-5-todo.svg" width="20" alt="Fifth step"/> Wrap up your project</p>
-</microformat>
-
-You've already created your first cross-platform Kotlin Multiplatform project! Now let's learn how to add dependencies
-to third-party libraries, which is necessary for building successful cross-platform applications.
-
-## Dependency types
-
-There are two types of dependencies that you can use in Multiplatform Mobile projects:
-
-* _Multiplatform dependencies_. These are multiplatform libraries that support multiple targets and can be used in the
-  common source set, `commonMain`.
-
-  Many modern Android libraries already have multiplatform support, like [Koin](https://insert-koin.io/),
-  [Apollo](https://www.apollographql.com/), and [Okio](https://square.github.io/okio/).
-* _Native dependencies_. These are regular libraries from relevant ecosystems. You usually work with them in native iOS
-   projects using CocoaPods or another dependency manager and in Android projects using Gradle.
-
-When you work with a shared module, you can also depend on native dependencies and use them in the native source sets,
-`androidMain` and `iosMain`. Typically, you'll need these dependencies when you want to work with platform APIs,
-for example, security storage, and there is common logic.
-
-For both types of dependencies, you can use local and external repositories.
-
-## Add a multiplatform dependency
-
-> If you have experience developing Android apps, adding a multiplatform dependency is similar to adding a
-> Gradle dependency in a regular Android project. The only difference is that you need to specify the source set.
->
-{type="tip"}
-
-Let's now go back to the app and make the greeting a little more festive. In addition to the device information, add a
-function to display the number of days left until New Year's Day. The `kotlinx-datetime` library, which has full
-multiplatform support, is the most convenient way to work with dates in your shared code.
-
-1. Navigate to the `build.gradle.kts` file in the `shared` directory.
-2. Add the following dependency to the `commonMain` source set dependencies:
-
-   ```kotlin
-   kotlin {
-       sourceSets {
-           val commonMain by getting {
-               dependencies {
-                   implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.4.0")
-               }
-           } 
-       }
-   }
-   ```
-
-3. Synchronize the Gradle files by clicking **Sync Now** in the notification.
-
-   ![Synchronize the Gradle files](gradle-sync.png)
-
-4. In `shared/src/commonMain/kotlin`, create a new file `NewYear.kt` in the project folder.
-5. Update the file with a short function that calculates
-   the number of days from today until the New Year using the `date-time` date arithmetic:
-   
-   ```kotlin
-   import kotlinx.datetime.*
-   
-   fun daysUntilNewYear(): Int {
-       val today = Clock.System.todayIn(TimeZone.currentSystemDefault())
-       val closestNewYear = LocalDate(today.year + 1, 1, 1)
-       return today.daysUntil(closestNewYear)
-   }
-   ```
-
-6. In `Greeting.kt`, update the `greet()` function to see the result:
-    
-    ```kotlin
-    class Greeting {
-        private val platform: Platform = getPlatform()
-         
-        fun greet(): String {
-            return "Guess what it is! > ${platform.name.reversed()}!" +
-                    "\nThere are only ${daysUntilNewYear()} days left until New Year! 🎆"
-        }
-    }
-    ```
-
-7. To see the results, re-run your **androidApp** and **iosApp** configurations from Android Studio:
-
-![Updated mobile multiplatform app with external dependencies](first-multiplatform-project-3.png){width=500}
-
-## Next step
-
-In the next part of the tutorial, you'll add more dependencies and more complex logic to your project.
-
-**[Proceed to the next part](multiplatform-mobile-upgrade-app.md)**
-
-### See also
-
-* Discover how to work with multiplatform dependencies of all
-  kinds: [Kotlin libraries, Kotlin Multiplatform libraries, and other multiplatform projects](multiplatform-add-dependencies.md).
-* Learn how to [add Android dependencies](multiplatform-mobile-android-dependencies.md)
-  and [iOS dependencies with or without CocoaPods](multiplatform-mobile-ios-dependencies.md) for use in
-  platform-specific source sets.
-* Check out the examples of [how to use Android and iOS libraries](multiplatform-mobile-samples.md) in sample projects
-  (be sure to check the Platform APIs column).
-
-## Get help
-
-* **Kotlin Slack**. Get an [invite](https://surveys.jetbrains.com/s3/kotlin-slack-sign-up) and join the [#multiplatform](https://kotlinlang.slack.com/archives/C3PQML5NU) channel.
-* **Kotlin issue tracker**. [Report a new issue](https://youtrack.jetbrains.com/newIssue?project=KT).
\ No newline at end of file
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-faq.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-faq.md
deleted file mode 100644
index a064d1fc5cb..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-faq.md
+++ /dev/null
@@ -1,108 +0,0 @@
-[//]: # (title: Kotlin Multiplatform for mobile FAQ)
-
-### What is Kotlin Multiplatform for mobile?
-
-_Kotlin Multiplatform for mobile_ is an SDK for cross-platform mobile development. You can develop 
-multiplatform mobile applications and share parts of your applications between Android and iOS, such as core layers, 
-business logic, presentation logic, and more.
-
-Kotlin Mobile uses the [multiplatform abilities of Kotlin](multiplatform.md) and the features 
-designed for mobile development, such as CocoaPods integration and the [Android Studio Plugin](#what-is-the-kotlin-multiplatform-mobile-plugin).
-
-You may want to watch this introductory [video](https://www.youtube.com/watch?v=mdN6P6RI__k), in which Kotlin Product Marketing Manager Ekaterina Petrova explains in detail what Kotlin Multiplatform for mobile is and how you can use it in your projects. 
-With Ekaterina, you'll set up an environment and prepare for creating your first cross-platform mobile application with Kotlin Multiplatform.
-
-### Can I share UIs with Kotlin Multiplatform?
-
-Yes, you can share UIs using [Compose Multiplatform](https://www.jetbrains.com/lp/compose-multiplatform/),
-JetBrains' declarative UI framework based on Kotlin and [Jetpack Compose](https://developer.android.com/jetpack/compose). 
-This framework allows you to create shared UI components for platforms like iOS, Android, desktop, and web, helping you 
-to maintain a consistent user interface across different devices and platforms.
-
-Check out the [Compose Multiplatform FAQ](https://github.com/JetBrains/compose-multiplatform/blob/master/docs/FAQ.md#compose-multiplatform-faq)
-to learn more.
-
-### What is the Kotlin Multiplatform Mobile plugin?
-
-The _[Kotlin Multiplatform Mobile plugin](https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform-mobile)_
-for Android Studio helps you develop applications that work on both Android and iOS. 
-
-With the Kotlin Multiplatform Mobile plugin, you can:
-* Run, test, and debug the iOS part of your application on iOS targets straight from Android Studio.
-* Quickly create a new multiplatform project.
-* Add a multiplatform module into an existing project.
-
-The Kotlin Multiplatform Mobile plugin works only on macOS. This is because iOS simulators, per the Apple requirement, can run only on macOS 
-but not on any other operating systems, such as Microsoft Windows or Linux.
-
-The good news is that you can work with cross-platform projects on Android even without the Kotlin Multiplatform Mobile plugin. If you are going to work 
-with shared code or Android-specific code, you can work on any operating system supported by Android Studio.
-
-### What is Kotlin/Native and how does it relate to Kotlin Multiplatform?
-
-_[Kotlin/Native](native-overview.md)_ is a technology for compiling Kotlin code to native 
-binaries, which can run without a virtual machine. It consists of an [LLVM](https://llvm.org/)-based backend for the 
-Kotlin compiler and a native implementation of the Kotlin standard library.
-
-Kotlin/Native is primarily designed to allow compilation for platforms where virtual machines are not desirable or 
-possible, such as embedded devices and iOS. It is particularly suitable for situations when the developer needs to produce 
-a self-contained program that does not require an additional runtime or virtual machine. And that is exactly the case with 
-iOS development.
-
-Shared code, written in Kotlin, is compiled to JVM bytecode for Android with Kotlin/JVM and to native binaries for iOS 
-with Kotlin/Native. It makes the integration with Kotlin Multiplatform seamless on both platforms.
-![Kotlin/Native and Kotlin/JVM binaries](kotlin-native-and-jvm-binaries.png)
-
-### What are the plans for the technology evolution?
-
-Kotlin Multiplatform is one of the focus areas of the [Kotlin roadmap](roadmap.md). To see which parts we're 
-working on right now, check out the [roadmap details](roadmap.md#roadmap-details). 
-Most of the recent changes affect the **Kotlin Multiplatform** and **Kotlin/Native** sections.
-
-The following video presents the current state and our plans for the Kotlin Multiplatform for mobile development: 
-
-<video href="CngKDGBlFxk" title="Kotlin Multiplatform Mobile Is in Beta – Start Using It Now!"/>
-
-### Can I run an iOS application on Microsoft Windows or Linux?
-
-If you want to write iOS-specific code and run an iOS application on a simulated or real device, use a Mac with a macOS
-([use the Kotlin Multiplatform Mobile plugin for it](#what-is-the-kotlin-multiplatform-mobile-plugin)). This is because iOS simulators can run only on macOS, per 
-the Apple requirement, but cannot run on other operating systems, such as Microsoft Windows or Linux.
-
-If you are going to work with shared code or Android-specific code, you can work on any operating system supported by Android Studio.
-
-### Where can I get complete examples to play with?
-
-* [Curated samples](multiplatform-mobile-samples.md)
-* [Create a multiplatform app using Ktor and SQLDelight – tutorial](multiplatform-mobile-ktor-sqldelight.md)
-
-### In which IDE should I work on my cross-platform app?
-
-You can work in [Android Studio](https://developer.android.com/studio). Android Studio allows the use of the 
-[Kotlin Multiplatform Mobile plugin](#what-is-the-kotlin-multiplatform-mobile-plugin), which is a part of the Kotlin ecosystem. Enable the Kotlin Multiplatform Mobile plugin in Android Studio 
-if you want to write iOS-specific code and launch an iOS application on a simulated or real device. The plugin can be used only on macOS.
-
-Most of our adopters use Android Studio. However, if there is any reason for you not to use it, there is another option: 
-you can use [IntelliJ IDEA](https://www.jetbrains.com/idea/download). IntelliJ IDEA provides the ability to create 
-a multiplatform mobile application from the Project Wizard, but you won't be able to launch an iOS application from the IDE.
-
-### How can I write concurrent code in Kotlin Multiplatform projects?
-
-You can easily write concurrent code in your cross-platform mobile projects with the new [Kotlin/Native memory manager](native-memory-manager.md)
-that lifted previous limitations and aligned the behaviour between Kotlin/JVM and Kotlin/Native. The new memory manager
-has been enabled by default since Kotlin 1.7.20.
-
-### How can I speed up my Kotlin Multiplatform module compilation for iOS?
-See these [tips for improving Kotlin/Native compilation times](native-improving-compilation-time.md).
-
-## What platforms do you support?
-
-Kotlin Multiplatform supports development for:
-
-* Android applications and libraries
-* [Android NDK](https://developer.android.com/ndk) (ARM64 and ARM32)
-* Apple iOS devices and simulators
-* Apple watchOS devices and simulators
-
-The [Kotlin Multiplatform](multiplatform.md) technology also supports [other platforms](multiplatform-dsl-reference.md#targets),
-including JavaScript, Linux, Windows, and WebAssembly.
\ No newline at end of file
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-getting-started.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-getting-started.md
deleted file mode 100644
index 73d6d510106..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-getting-started.md
+++ /dev/null
@@ -1,63 +0,0 @@
-[//]: # (title: Get started with Kotlin Multiplatform for mobile)
-[//]: # (description: Simplify cross-platform app development with Kotlin Multiplatform. Create a single codebase
-for the business logic of your iOS and Android apps.)
-
-> Kotlin Multiplatform is in [Beta](components-stability.md). It is almost stable, but migration steps may be required
-> in the future. We'll do our best to minimize any changes you have to make.
->
-{type="note"}
-
-Kotlin Multiplatform technology simplifies the development of cross-platform projects.
-The Kotlin applications will work on different operating systems like iOS, Android, macOS, Windows, Linux, watchOS, and others.
-
-One of the major Kotlin Multiplatform use cases is sharing code between mobile platforms.
-You can share application logic between iOS and Android apps and write platform-specific code only when you need to implement a native UI or work with platform APIs.
-
-[Compose Multiplatform](https://www.jetbrains.com/lp/compose-multiplatform/), a JetBrains' declarative UI framework based on Kotlin
-and [Jetpack Compose](https://developer.android.com/jetpack/compose), gives you the option to push the sharing capabilities 
-of Kotlin Multiplatform beyond application logic. It allows you to implement your user interface once and then use it for all the platforms you target – iOS, Android, desktop, and web.
-
-* Check out our [Kotlin Multiplatform Mobile Is in Beta](https://www.youtube.com/watch?v=CngKDGBlFxk) video
-  to learn about the current state and future plans for the technology.
-* See how [different companies](https://kotlinlang.org/lp/multiplatform/case-studies) are already using Kotlin for
-  cross-platform app development in production.
-* Try [Compose Multiplatform](https://www.jetbrains.com/lp/compose-multiplatform/),
-  JetBrains' declarative UI framework based on Kotlin and [Jetpack Compose](https://developer.android.com/jetpack/compose)
-  to share UIs among iOS, Android, desktop, and web.
-
-Get to know Kotlin Multiplatform and create a mobile app that works on both Android and iOS by completing these steps:
-
-> This tutorial describes how to share application logic between iOS and Android using Kotlin Multiplatform.
-> To learn about the full capabilities of the technology, check out [other use cases](multiplatform.md).
->
-{type="tip"}
-
-![First step](icon-1.svg){width=25}{type="joined"} [Set up an environment for cross-platform mobile development](multiplatform-mobile-setup.md)
-
-![Second step](icon-2.svg){width=25}{type="joined"} [Create your first app that works both on Android and iOS with the IDE](multiplatform-mobile-create-first-app.md)
-
-![Third step](icon-3.svg){width=25}{type="joined"} [Add dependencies to your project](multiplatform-mobile-dependencies.md)
-
-![Fourth step](icon-4.svg){width=25}{type="joined"} [Upgrade your app](multiplatform-mobile-upgrade-app.md)
-
-![Fifth step](icon-5.svg){width=25}{type="joined"} [Wrap up your project](multiplatform-mobile-wrap-up.md)
-
-## Next step
-
-Start by setting up an environment for mobile development.
-
-**[Proceed to the next part](multiplatform-mobile-setup.md)**
-
-### See also
-
-If you want to convert your existing Android project into a cross-platform app, follow these steps to make it work on iOS:
-
-![First step](icon-1.svg){width=25}{type="joined"} [Set up an environment for cross-platform mobile development](multiplatform-mobile-setup.md)
-
-![Second step](icon-2.svg){width=25}{type="joined"} [Complete this tutorial to make your Android app cross-platform](multiplatform-mobile-integrate-in-existing-app.md)
-
-## Join the community
-
-* ![Slack](slack.svg){width=25}{type="joined"} **Kotlin Slack**: get an [invitation](https://surveys.jetbrains.com/s3/kotlin-slack-sign-up) and join the [#multiplatform](https://kotlinlang.slack.com/archives/C3PQML5NU) channel
-* ![Stack Overflow](stackoverflow.svg){width=25}{type="joined"} **Stack Overflow**: subscribe to the ["kotlin-multiplatform" tag](https://stackoverflow.com/questions/tagged/kotlin-multiplatform)
-* ![YouTube](youtube.svg){width=25}{type="joined"} **Kotlin YouTube channel**: subscribe and watch videos about [Kotlin Multiplatform](https://www.youtube.com/playlist?list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C)
\ No newline at end of file
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-integrate-in-existing-app.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-integrate-in-existing-app.md
deleted file mode 100644
index 39cc1a5c52c..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-integrate-in-existing-app.md
+++ /dev/null
@@ -1,442 +0,0 @@
-[//]: # (title: Make your Android application work on iOS – tutorial)
-
-Learn how to make your existing Android application cross-platform so that it works both on Android and iOS.
-You'll be able to write code and test it for both Android and iOS only once, in one place.
-
-This tutorial uses a [sample Android application](https://github.com/Kotlin/kmm-integration-sample) with a single screen
-for entering a username and password. The credentials are validated and saved to an in-memory database.
-
-> If you aren't familiar with Kotlin Multiplatform for mobile, learn how to [set up environment and create a cross-platform application from scratch](multiplatform-mobile-getting-started.md)
-> first.
-> 
-{type="tip"}
-
-## Prepare an environment for development
-
-1. [Install all the necessary tools and update them to the latest versions](multiplatform-mobile-setup.md).
-
-   > You will need a Mac with macOS to complete certain steps in this tutorial, which include writing iOS-specific code
-   > and running an iOS application. These steps can't be performed on other operating systems, such as Microsoft Windows.
-   > This is due to an Apple requirement.
-   >
-   {type="note"}
-
-2. In Android Studio, create a new project from version control:
-
-   ```text
-   https://github.com/Kotlin/kmm-integration-sample
-   ```
-
-   > The `master` branch contains the project's initial state — a simple Android application. To see the final state
-   > with the iOS application and the shared module, switch to the `final` branch.
-   >
-   {type="tip"}
-
-3. Switch to the **Project** view.
-
-   ![Project view](project-view-for-integrate.png){width=200}
-
-## Make your code cross-platform
-
-To make your application work on iOS, you'll first make your code cross-platform, and then you'll reuse your
-cross-platform code in a new iOS application.
-
-To make your code cross-platform:
-
-1. [Decide what code to make cross-platform](#decide-what-code-to-make-cross-platform).
-2. [Create a shared module for cross-platform code](#create-a-shared-module-for-cross-platform-code).
-3. [Add a dependency on the shared module to your Android application](#add-a-dependency-on-the-shared-module-to-your-android-application).
-4. [Make the business logic cross-platform](#make-the-business-logic-cross-platform).
-5. [Run your cross-platform application on Android](#run-your-cross-platform-application-on-android).
-
-### Decide what code to make cross-platform
-
-Decide which code of your Android application is better to share for iOS and which to keep native. A simple rule is:
-share what you want to reuse as much as possible. The business logic is often the same for both Android and iOS,
-so it's a great candidate for reuse.
-
-In your sample Android application, the business logic is stored in the package `com.jetbrains.simplelogin.androidapp.data`.
-Your future iOS application will use the same logic, so you should make it cross-platform, as well.
-
-![Business logic to share](business-logic-to-share.png){width=350}
-
-### Create a shared module for cross-platform code
-
-The cross-platform code that is used for both iOS and Android _is stored_ in the shared module.
-The Kotlin Multiplatform plugin provides a special wizard for creating such modules.
-
-In your Android project, create a Kotlin Multiplatform shared module for your cross-platform code. Later you'll connect
-it to your existing Android application and your future iOS application.
-
-1. In Android Studio, click **File** | **New** | **New Module**.
-2. In the list of templates, select **Kotlin Multiplatform Shared Module**, enter the module name `shared`, and select
-   the **Regular framework** in the list of iOS framework distribution options.  
-   This is required for connecting the shared module to the iOS application.
-
-   ![Kotlin Multiplatform shared module](multiplatform-mobile-module-wizard.png){width=700}
-
-3. Click **Finish**.
-
-The wizard will create the Kotlin Multiplatform shared module, update the configuration files, and create files with
-classes that demonstrate the benefits of Kotlin Multiplatform.
-You can learn more about the [project structure](multiplatform-mobile-understand-project-structure.md).
-
-### Add a dependency on the shared module to your Android application
-
-To use cross-platform code in your Android application, connect the shared module to it, move the business logic code
-there, and make this code cross-platform.
-
-1. In the `build.gradle.kts` file of the shared module, ensure that `compileSdk` and `minSdk` are the same as those in
-   the `build.gradle.kts` of your Android application in the `app` module.
-
-   If they're different, update them in the `build.gradle.kts` of the shared module. Otherwise, you'll encounter a
-   compile error.
-
-2. Add a dependency on the shared module to the `build.gradle.kts` of your Android application.
-
-    ```kotlin
-    dependencies {
-        implementation (project(":shared"))
-    }
-    ```
-
-3. Synchronize the Gradle files by clicking **Sync Now** in the notification.
-
-   ![Synchronize the Gradle files](gradle-sync.png)
-
-4. In the `app/src/main/java/` directory, open the `LoginActivity` class in the `com.jetbrains.simplelogin.androidapp.ui.login`
-   package.
-5. To make sure that the shared module is successfully connected to your application, dump the `greet()` function
-   result to the log by updating the `onCreate()` method:
-
-    ```kotlin
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-
-        Log.i("Login Activity", "Hello from shared module: " + (Greeting().greet()))
-    }
-    ```
-6. Follow Android Studio suggestions to import missing classes.
-7. Debug the `app`. On the **Logcat** tab, search for `Hello` in the log, and you'll find the greeting from the shared
-   module.
-
-   ![Greeting from the shared module](shared-module-greeting.png)
-
-### Make the business logic cross-platform
-
-You can now extract the business logic code to the Kotlin Multiplatform shared module and make it platform-independent.
-This is necessary for reusing the code for both Android and iOS.
-
-1. Move the business logic code `com.jetbrains.simplelogin.androidapp.data` from the `app` directory to
-   the `com.jetbrains.simplelogin.shared` package in the `shared/src/commonMain` directory.
-   You can drag and drop the package or refactor it by moving everything from one directory to another.
-
-   ![Drag and drop the package with the business logic code](moving-business-logic.png){width=350}
-
-2. When Android Studio asks what you'd like to do, select to move the package, and then approve the refactoring.
-
-   ![Refactor the business logic package](refactor-business-logic-package.png){width=500}
-
-3. Ignore all warnings about platform-dependent code and click **Continue**.
-
-   ![Warnings about platform-dependent code](warnings-android-specific-code.png){width=450}
-
-4. Remove Android-specific code by replacing it with cross-platform Kotlin code or connecting to Android-specific APIs
-   using [expected and actual declarations](multiplatform-expect-actual.md). See the following sections for details:
-
-#### Replace Android-specific code with cross-platform code {initial-collapse-state="collapsed"}
-
-To make your code work well on both Android and iOS, replace all JVM dependencies with Kotlin dependencies in the
-moved `data` directory wherever possible.
-
-1. In the `LoginDataSource` class, replace `IOException` in the `login()` function with `RuntimeException`.
-   `IOException` is not available in Kotlin.
-
-    ```kotlin
-    // Before
-    return Result.Error(IOException("Error logging in", e))
-    ```
-
-    ```kotlin
-    // After
-    return Result.Error(RuntimeException("Error logging in", e))
-    ```
-
-2. In the `LoginDataValidator` class, replace the `Patterns` class from the `android.utils` package with a Kotlin
-   regular expression matching the pattern for email validation:
-
-    ```kotlin
-    // Before
-    private fun isEmailValid(email: String) = Patterns.EMAIL_ADDRESS.matcher(email).matches()
-    ```
-
-    ```kotlin
-    // After
-    private fun isEmailValid(email: String) = emailRegex.matches(email)
-    
-    companion object {
-        private val emailRegex = 
-            ("[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
-                "\\@" +
-                "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
-                "(" +
-                "\\." +
-                "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
-                ")+").toRegex()
-    }
-    ```
-
-#### Connect to platform-specific APIs from the cross-platform code {initial-collapse-state="collapsed"}
-
-In the `LoginDataSource` class, a universally unique identifier (UUID) for `fakeUser` is generated using
-the `java.util.UUID` class, which is not available for iOS.
-
-```kotlin
-val fakeUser = LoggedInUser(java.util.UUID.randomUUID().toString(), "Jane Doe")
-```
-
-Since the Kotlin standard library doesn't provide functionality for generating UUIDs, you still need to use
-platform-specific functionality for this case.
-
-Provide the `expect` declaration for the `randomUUID()` function in the shared code and its `actual` implementations for
-each platform – Android and iOS – in the corresponding source sets.
-Learn more about [expected and actual declarations](multiplatform-expect-actual.md).
-
-1. Remove the `java.util.UUID` class from the common code:
-
-    ```kotlin
-    val fakeUser = LoggedInUser(randomUUID(), "Jane Doe")
-    ```
-
-2. Create the `Utils.kt` file in the `com.jetbrains.simplelogin.shared` package of the `shared/src/commonMain` directory
-   and provide the `expect` declaration:
-
-    ```kotlin
-    package com.jetbrains.simplelogin.shared
-    
-    expect fun randomUUID(): String
-    ```
-
-3. Create the `Utils.kt` file in the `com.jetbrains.simplelogin.shared` package of the `shared/src/androidMain`
-   directory and provide the `actual` implementation for `randomUUID()` in Android:
-
-    ```kotlin
-    package com.jetbrains.simplelogin.shared
-    
-    import java.util.*
-   
-    actual fun randomUUID() = UUID.randomUUID().toString()
-    ```
-
-4. Create the `Utils.kt` file in the `com.jetbrains.simplelogin.shared` of the `shared/src/iosMain` directory and
-   provide the `actual` implementation for `randomUUID()` in iOS:
-
-    ```kotlin
-    package com.jetbrains.simplelogin.shared
-    
-    import platform.Foundation.NSUUID
-   
-    actual fun randomUUID(): String = NSUUID().UUIDString()
-    ```
-
-5. All it's left to do is to explicitly import `randomUUID` in the `LoginDataSource.kt` file of the `shared/src/commonMain`
-   directory:
-
-   ```kotlin
-   import com.jetbrains.simplelogin.shared.randomUUID
-   ```
-  
-   For Android and iOS, Kotlin will use its different platform-specific implementations.
-
-### Run your cross-platform application on Android
-
-Run your cross-platform application for Android to make sure it works.
-
-![Android login application](android-login.png){width=300}
-
-## Make your cross-platform application work on iOS
-
-Once you've made your Android application cross-platform, you can create an iOS application and reuse the shared
-business logic in it.
-
-1. [Create an iOS project in Xcode](#create-an-ios-project-in-xcode).
-2. [Connect the framework to your iOS project](#connect-the-framework-to-your-ios-project).
-3. [Use the shared module from Swift](#use-the-shared-module-from-swift).
-
-### Create an iOS project in Xcode
-
-1. In Xcode, click **File** | **New** | **Project**.
-2. Select a template for an iOS app and click **Next**.
-
-   ![iOS project template](ios-project-wizard-1.png){width=700}
-
-3. As the product name, specify **simpleLoginIOS** and click **Next**.
-
-   ![iOS project settings](ios-project-wizard-2.png){width=700}
-
-4. As the location for your project, select the directory that stores your cross-platform application, for
-   example, `kmm-integration-sample`.
-
-In Android Studio, you'll get the following structure:
-
-![iOS project in Android Studio](ios-project-in-as.png){width=194}
-
-You can rename the `simpleLoginIOS` directory to `iosApp` for consistency with other top-level directories of your
-cross-platform project.
-
-![Renamed iOS project directory in Android Studio](ios-directory-renamed-in-as.png){width=194}
-
-### Connect the framework to your iOS project
-
-Once you have the framework, you can connect it to your iOS project manually.
-
-> An alternative is to [configure integration via CocoaPods](native-cocoapods.md), but that integration is beyond the
-> scope of this tutorial.
->
-{type="note"}
-
-Connect your framework to the iOS project manually:
-
-1. In Xcode, open the iOS project settings by double-clicking the project name.
-
-2. On the **Build Phases** tab of the project settings, click the **+** and add **New Run Script Phase**.
-
-   ![Add run script phase](xcode-run-script-phase-1.png){width=700}
-
-3. Add the following script:
-
-    ```text
-    cd "$SRCROOT/.."
-    ./gradlew :shared:embedAndSignAppleFrameworkForXcode
-    ```
-
-   ![Add the script](xcode-add-run-phase-2.png){width=700}
-
-4. Move the **Run Script** phase before the **Compile Sources** phase.
-
-   ![Move the Run Script phase](xcode-run-script-phase-3.png){width=700}
-
-5. On the **Build Settings** tab, switch to **All** build settings and specify the **Framework Search Path** under
-   **Search Paths**:
-
-   ```text
-   $(SRCROOT)/../shared/build/xcode-frameworks/$(CONFIGURATION)/$(SDK_NAME)
-   ```
-
-   ![Framework search path](xcode-add-framework-search-path.png){width=700}
-
-6. On the **Build Settings** tab, specify the **Other Linker flags** under **Linking**:
-
-   ```text
-   $(inherited) -framework shared
-   ```
-
-   ![Linker flag](xcode-add-flag.png){width=700}
-
-7. Build the project in Xcode. If everything is set up correctly, the project will successfully build.
-
-> If you have a custom build configuration different from the default `Debug` or `Release`, on the **Build Settings**
-> tab, add the `KOTLIN_FRAMEWORK_BUILD_TYPE` setting under **User-Defined** and set it to `Debug` or `Release`.
->
-{type="note"}
-
-### Use the shared module from Swift
-
-1. In Xcode, open the `ContentView.swift` file and import the `shared` module:
-
-   ```swift
-   import shared
-   ```
-
-2. To check that it is properly connected, use the `greet()` function from the shared module of your cross-platform app:
-
-   ```swift
-   import SwiftUI
-   import shared
-   
-   struct ContentView: View {
-       var body: some View {
-           Text(Greeting().greet())
-           .padding()
-       }
-   }
-   ```
-
-   ![Greeting from the shared module](xcode-iphone-hello.png){width=300}
-
-3. In `ContentView.swift`, write code for using data from the shared module and rendering the application UI:
-
-   ```kotlin
-   ```
-   {src="android-ios-tutorial/ContentView.swift" initial-collapse-state="collapsed"}
-
-4. In `simpleLoginIOSApp.swift`, import the `shared` module and specify the arguments for the `ContentView()` function:
-
-    ```swift
-    import SwiftUI
-    import shared
-    
-    @main
-    struct SimpleLoginIOSApp: App {
-        var body: some Scene {
-            WindowGroup {
-                ContentView(viewModel: .init(loginRepository: LoginRepository(dataSource: LoginDataSource()), loginValidator: LoginDataValidator()))
-            }
-        }
-    }
-    ```
-
-![Simple login application](xcode-iphone-login.png){width=300}
-
-## Enjoy the results – update the logic only once
-
-Now your application is cross-platform. You can update the business logic in one place and see results on both Android
-and iOS.
-
-1. In Android Studio, change the validation logic for a user's password in the `checkPassword()` function of
-   the `LoginDataValidator` class:
-
-   ```kotlin
-   package com.jetbrains.simplelogin.shared.data
-   
-   class LoginDataValidator {
-   //...
-       fun checkPassword(password: String): Result {
-           return when {
-               password.length < 5 -> Result.Error("Password must be >5 characters")
-               password.lowercase() == "password" -> Result.Error("Password shouldn't be \"password\"")
-               else -> Result.Success
-           }
-       }
-   //...
-   }
-   ```
-
-2. Run both the iOS and Android applications from Android Studio to see the changes:
-
-   ![iOS run configuration](ios-run-configuration-simplelogin.png){width=200}
-
-   ![iOS application password error](iphone-password-error.png){width=300}
-
-   ![Android application password error](android-password-error.png){width=300}
-
-You can review the [final code for this tutorial](https://github.com/Kotlin/kmm-integration-sample/tree/final).
-
-## What else to share?
-
-You've shared the business logic of your application, but you can also decide to share other layers of your application.
-For example, the `ViewModel` class code is almost the same for [Android](https://github.com/Kotlin/kmm-integration-sample/blob/final/app/src/main/java/com/jetbrains/simplelogin/androidapp/ui/login/LoginViewModel.kt)
-and [iOS applications](https://github.com/Kotlin/kmm-integration-sample/blob/final/iosApp/SimpleLoginIOS/ContentView.swift#L84),
-and you can share it if your mobile applications should have the same presentation layer.
-
-## What's next?
-
-Once you've made your Android application cross-platform, you can move on and:
-
-* [Add dependencies on multiplatform libraries](multiplatform-add-dependencies.md)
-* [Add Android dependencies](multiplatform-mobile-android-dependencies.md)
-* [Add iOS dependencies](multiplatform-mobile-ios-dependencies.md)
-
-You can also check out community resources:
-
-* [Video: 3 ways to get your Kotlin JVM code ready for Kotlin Multiplatform Mobile](https://www.youtube.com/watch?v=X6ckI1JWjqo)
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-introduce-your-team.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-introduce-your-team.md
index 46ca7c339cc..768752886a6 100644
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-introduce-your-team.md
+++ b/docs/topics/multiplatform-mobile/multiplatform-mobile-introduce-your-team.md
@@ -1,6 +1,6 @@
-[//]: # (title: Introduce cross-platform mobile development to your team)
+[//]: # (title: Introduce cross-platform development to your team)
 
-These recommendations will help you introduce your team to Kotlin Multiplatform for mobile:
+These recommendations will help you introduce your team to Kotlin Multiplatform:
 
 * [Start with empathy](#start-with-empathy)
 * [Explain how Kotlin Multiplatform works](#explain-how-it-works)
@@ -15,7 +15,7 @@ Software development is a team game, with each critical decision needing the app
 
 Understanding the people who work on your project is the first step to successful integration. Your boss is responsible for delivering features with the best quality in the shortest time possible. To them, any new technology is a risk. Your colleagues have a different perspective, as well. They have experience building apps with the "native" technology stack. They know how to write the UI and business logic, work with dependencies, test, and debug code in the IDE, and they are already familiar with the language. Switching to a different ecosystem is very uncomfortable, as it always means leaving your comfort zone.
 
-Given all that, be ready to face lots of biases and answer a lot of questions when advocating for the move to Kotlin Multiplatform for mobile. As you do, never lose sight of what your team needs. Some of the advice below might be useful for preparing your pitch.
+Given all that, be ready to face lots of biases and answer a lot of questions when advocating for the move to Kotlin Multiplatform. As you do, never lose sight of what your team needs. Some of the advice below might be useful for preparing your pitch.
 
 ## Explain how it works
 
@@ -29,25 +29,25 @@ Being able to explain _how_ technology works is important, as nobody likes when
 
 ## Show the value
 
-Understanding how the technology works is necessary, but not enough. Your team needs to see the gains of using it, and the way you present these gains should be related to your product. Kotlin Multiplatform allows you to use a single codebase for the business logic of iOS and Android apps. So if you develop a very thin client and the majority of the code is UI logic, then the main power of Kotlin Multiplatform Mobile will be unused in your project. However, if your application has complex business logic, for example if you have features like networking, data storage, payments, complex computations, or data synchronization, then this logic could easily be written and shared between iOS and Android so you can experience the real power of the technology.
+Understanding how the technology works is necessary, but not enough. Your team needs to see the gains of using it, and the way you present these gains should be related to your product. Kotlin Multiplatform allows you to use a single codebase for the business logic of iOS and Android apps. So if you develop a very thin client and the majority of the code is UI logic, then the main power of Kotlin Multiplatform will be unused in your project. However, if your application has complex business logic, for example if you have features like networking, data storage, payments, complex computations, or data synchronization, then this logic could easily be written and shared between iOS and Android so you can experience the real power of the technology.
 
 At this stage, you need to explain the main gains of using Kotlin Multiplatform in your product. One of the ways is to share stories of other companies who already benefit from the technology. The successful experience of these teams, especially ones with similar product objectives, could become a key factor in the final decision.
 
 Citing case studies of different companies who already use Kotlin Multiplatform in production could significantly help you make a compelling argument:
 
-*   **[Chalk.com](https://kotlinlang.org/lp/multiplatform/case-studies/chalk)** – The UI for each of the Chalk.com apps is native to the platform, but otherwise almost everything for their apps can be shared with Kotlin Multiplatform for mobile.
-*   **[Cash App](https://kotlinconf.com/2019/talks/video/2019/116027/)** – A lot of the app's business logic, including the ability to search through all transactions, is implemented with Kotlin Multiplatform for mobile.
-*   **[Yandex.Disk](https://kotlinlang.org/lp/multiplatform/case-studies/yandex)** – They started out by experimenting with the integration of a small feature, and as the experiment was considered successful, they implemented their whole data synchronization logic in Kotlin Multiplatform for mobile.
+*   **[Chalk.com](https://kotlinlang.org/lp/multiplatform/case-studies/chalk)** – The UI for each of the Chalk.com apps is native to the platform, but otherwise almost everything for their apps can be shared with Kotlin Multiplatform.
+*   **[Cash App](https://kotlinconf.com/2019/talks/video/2019/116027/)** – A lot of the app's business logic, including the ability to search through all transactions, is implemented with Kotlin Multiplatform.
+*   **[Yandex.Disk](https://kotlinlang.org/lp/multiplatform/case-studies/yandex)** – They started out by experimenting with the integration of a small feature, and as the experiment was considered successful, they implemented their whole data synchronization logic in Kotlin Multiplatform.
 
 Explore [the case studies page](https://kotlinlang.org/lp/multiplatform/case-studies) for inspirational references.
 
 ## Offer proof
 
 The theory is good, but putting it into practice is ultimately most important. As one option to make your case more convincing, you can take the risky choice of devoting some of your personal free time to creating something with Kotlin Multiplatform and then bringing in the results for your team to discuss. Your prototype could be some sort of test project, which you would write from scratch and which would demonstrate features that are needed in your application. 
-[Create a multiplatform app using Ktor and SQLDelight – tutorial](multiplatform-mobile-ktor-sqldelight.md) can guide you well on this process. 
+[Create a multiplatform app using Ktor and SQLDelight – tutorial](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-ktor-sqldelight.html) can guide you well on this process. 
 
 The more relevant examples could be produced by experimenting with your current project. You could take one existing feature implemented in Kotlin and make it cross-platform, or you could even create a new Multiplatform Module in your existing project, take one non-priority feature from the bottom of the backlog, and implement it in the shared module. 
-[Make your Android application work on iOS – tutorial](multiplatform-mobile-integrate-in-existing-app.md) provides a step-by-step guide based on a sample project.
+[Make your Android application work on iOS – tutorial](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-integrate-in-existing-app.html) provides a step-by-step guide based on a sample project.
 
 The new [Kotlin Multiplatform Mobile plugin for Android Studio](https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform-mobile) will allow you to accomplish either of these tasks in the shortest amount of time by using the **Kotlin Multiplatform App** or **Kotlin Multiplatform Library** wizards.
 
@@ -67,13 +67,13 @@ Also, in basic scenarios, you simply need to configure your project at the start
 
 When only the Android part of the team works with shared code, the iOS developers don't even need to learn Kotlin. But when you are ready for your team to move to the next stage, where everyone contributes to the shared code, making the transition won't take much time. The similarities between the syntax and functionality of Swift and Kotlin greatly reduce the work required to learn how to read and write shared Kotlin code. [Try it yourself!](https://play.kotlinlang.org/koans/overview)
 
-**Q: I heard that Kotlin Multiplatform for mobile is experimental technology. Does that mean that we shouldn't use it for production?**
+**Q: I heard that Kotlin Multiplatform is experimental technology. Does that mean that we shouldn't use it for production?**
 
-A: Experimental status means we and the whole Kotlin community are just trying out an idea, but if it doesn't work, it may be dropped anytime. However, after the release of Kotlin 1.4, **Kotlin Multiplatform for mobile is in Alpha** status. This means the Kotlin team is fully committed to working to improve and evolve this technology and will not suddenly drop it. However, before going Beta, there could be some migration issues yet. But even experimental status doesn't prevent a feature from being used successfully in production, as long as you understand all the risks. Check [the Kotlin evolution page](kotlin-evolution.md) for information about the stability statuses of Kotlin Multiplatform components.
+A: Experimental status means we and the whole Kotlin community are just trying out an idea, but if it doesn't work, it may be dropped anytime. However, after the release of Kotlin 1.4, **Kotlin Multiplatform is in Alpha** status. This means the Kotlin team is fully committed to working to improve and evolve this technology and will not suddenly drop it. However, before going Beta, there could be some migration issues yet. But even experimental status doesn't prevent a feature from being used successfully in production, as long as you understand all the risks. Check [the Kotlin evolution page](kotlin-evolution.md) for information about the stability statuses of Kotlin Multiplatform components.
 
 **Q: There are not enough multiplatform libraries to implement the business logic, it's much easier to find native alternatives.**
 
-A: Of course, we can't compare the number of multiplatform libraries with React Native, for example. But it took five years for React Native to expand their ecosystem to its current size. Kotlin Multiplatform for mobile is still young, but the ecosystem has tremendous potential as there are already a lot of modern libraries written in Kotlin that can be easily ported to multiplatform. 
+A: Of course, we can't compare the number of multiplatform libraries with React Native, for example. But it took five years for React Native to expand their ecosystem to its current size. Kotlin Multiplatform is still young, but the ecosystem has tremendous potential as there are already a lot of modern libraries written in Kotlin that can be easily ported to multiplatform. 
 
 It's also a great time to be an iOS developer in the Kotlin Multiplatform open-source community because the iOS experience is in demand and there are plenty of opportunities to gain recognition from iOS-specific contributions.
 
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-ios-dependencies.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-ios-dependencies.md
index a9f6307d0ae..5aa9649a90f 100644
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-ios-dependencies.md
+++ b/docs/topics/multiplatform-mobile/multiplatform-mobile-ios-dependencies.md
@@ -1,7 +1,7 @@
 [//]: # (title: Adding iOS dependencies)
 
 Apple SDK dependencies (such as Foundation or Core Bluetooth) are available as a set of prebuilt libraries in Kotlin
-Multiplatform Mobile projects. They do not require any additional configuration.
+Multiplatform projects. They do not require any additional configuration.
 
 You can also reuse other libraries and frameworks from the iOS ecosystem in your iOS source sets. Kotlin supports
 interoperability with Objective-C dependencies and Swift dependencies if their APIs are exported to Objective-C with
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-ktor-sqldelight.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-ktor-sqldelight.md
deleted file mode 100644
index 5937195254b..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-ktor-sqldelight.md
+++ /dev/null
@@ -1,1007 +0,0 @@
-[//]: # (title: Create a multiplatform app using Ktor and SQLDelight – tutorial)
-
-This tutorial demonstrates how to use Android Studio to create a mobile application for iOS and Android using Kotlin
-Multiplatform Mobile with Ktor and SQLDelight.
-
-The application will include a module with shared code for both the iOS and Android platforms. The business logic and data
-access layers will be implemented only once in the shared module, while the UI of both applications will be native.
-
-The output will be an app that retrieves data over the internet from the
-public [SpaceX API](https://docs.spacexdata.com/?version=latest), saves it in a local database, and displays a list of
-SpaceX rocket launches together with the launch date, results, and a detailed description of the launch:
-
-![Emulator and Simulator](android-and-ios.png){width=600}
-
-You will use the following multiplatform libraries in the project:
-
-* [Ktor](https://ktor.io/docs/create-client.html) as an HTTP client for retrieving data over the internet.
-* [`kotlinx.serialization`](https://github.com/Kotlin/kotlinx.serialization) to deserialize JSON responses into objects
-  of entity classes.
-* [`kotlinx.coroutines`](https://github.com/Kotlin/kotlinx.coroutines) to write asynchronous code.
-* [SQLDelight](https://github.com/cashapp/sqldelight) to generate Kotlin code from SQL queries and create a type-safe
-  database API.
-
-> You can find the [template project](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage) as well as the
-> source code of the [final application](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage/tree/final)
-> on the corresponding GitHub repository.
->
-{type="note"}
-
-## Before you start
-
-1. Download and install [Android Studio](https://developer.android.com/studio/).
-2. Search for the [Kotlin Multiplatform Mobile plugin](https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform-mobile)
-   in the Android Studio Marketplace and install it.
-
-   ![Kotlin Multiplatform Mobile plugin](multiplatform-marketplace.png){width=700}
-
-3. Download and install [Xcode](https://developer.apple.com/xcode/).
-
-For more details, see the [Set up the environment](multiplatform-mobile-setup.md) section.
-
-## Create a Multiplatform project
-
-1. In Android Studio, select **File** | **New** | **New Project**. In the list of project templates, select **Kotlin
-   Multiplatform App** and then click **Next**.
-
-   ![Kotlin Multiplatform Mobile plugin wizard](multiplatform-mobile-project-wizard-1.png){width=700}
-
-2. Name your application and click **Next**.
-3. Select **Regular framework** in the list of **iOS framework distribution** options.
-
-   ![Kotlin Multiplatform Mobile plugin wizard. Final step](multiplatform-mobile-project-wizard-3.png){width=700}
-
-4. Keep all other options default. Click **Finish**.
-5. To view the complete structure of the multiplatform mobile project, switch the view from **Android** to **Project**.
-
-   ![Project view](select-project-view.png){width=200}
-
-For more on project features and how to use them, see [Understand the project structure](multiplatform-mobile-understand-project-structure.md).
-
-> You can find the configured project [on the `master` branch](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage).
->
-{type="note"}
-
-## Add dependencies to the multiplatform library
-
-To add a multiplatform library to the shared module, you need to add dependency instructions (`implementation`) for all
-libraries to the `dependencies` block of the relevant source sets in the `build.gradle.kts` file.
-
-Both the `kotlinx.serialization` and SQLDelight libraries also require additional configurations.
-
-1. In the `shared` directory, specify the dependencies on all the required libraries in the `build.gradle.kts` file:
-
-    ```kotlin
-    val coroutinesVersion = "%coroutinesVersion%"
-    val ktorVersion = "%ktorVersion%"
-    val sqlDelightVersion = "%sqlDelightVersion%"
-    val dateTimeVersion = "%dateTimeVersion%"
-
-    sourceSets {
-        commonMain {
-            dependencies {
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
-                implementation("io.ktor:ktor-client-core:$ktorVersion")
-                implementation("io.ktor:ktor-client-content-negotiation:$ktorVersion")
-                implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
-                implementation("com.squareup.sqldelight:runtime:$sqlDelightVersion")
-                implementation("org.jetbrains.kotlinx:kotlinx-datetime:$dateTimeVersion")
-            }
-        }
-        androidMain {
-            dependencies {
-                implementation("io.ktor:ktor-client-android:$ktorVersion")
-                implementation("com.squareup.sqldelight:android-driver:$sqlDelightVersion")
-            }
-        }
-        iosMain {
-            // ...
-            dependencies {
-                implementation("io.ktor:ktor-client-darwin:$ktorVersion")
-                implementation("com.squareup.sqldelight:native-driver:$sqlDelightVersion")
-            }
-        }
-    }
-    ```
-
-   * Each library requires a core artifact in the common source set.
-   * Both the SQLDelight and Ktor libraries need platform drivers in the iOS and Android source sets, as well.
-   * In addition, Ktor needs the [serialization feature](https://ktor.io/docs/serialization-client.html) to use
-     `kotlinx.serialization` for processing network requests and responses.
-
-2. At the very beginning of the `build.gradle.kts` file in the same `shared` directory, add the following lines to the
-   `plugins` block:
-
-   ```kotlin
-       plugins {
-       // ...
-       kotlin("plugin.serialization").version("%kotlinVersion%")
-       id("com.squareup.sqldelight").version("%sqlDelightVersion%")
-   }
-   ```
-
-3. Sync the Gradle project.
-
-Learn more about adding [dependencies on multiplatform libraries](multiplatform-add-dependencies.md).
-
-> You can find this state of the project [on the `final` branch](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage/tree/final).
->
-{type="note"}
-
-## Create an application data model
-
-The Kotlin Multiplatform app will contain the public `SpaceXSDK` class, the facade over networking and cache services.
-The application data model will have three entity classes with:
-
-* General information about the launch
-* A URL to external information
-* Information about the rocket
-
-1. In `shared/src/commonMain/kotlin`, add the `com.jetbrains.handson.kmm.shared.entity` package.
-2. Create the `Entity.kt` file inside the package.
-3. Declare all the data classes for basic entities:
-
-   ```kotlin
-   ```
-   {src="multiplatform-mobile-tutorial/Entity.kt" initial-collapse-state="collapsed" collapsed-title="data class RocketLaunch" lines="3-41" }
-
-Each serializable class must be marked with the `@Serializable` annotation. The `kotlinx.serialization` plugin
-automatically generates a default serializer for `@Serializable` classes unless you explicitly pass a link to a
-serializer through the annotation argument.
-
-However, you don't need to do that in this case. The `@SerialName` annotation allows you to redefine field names, which helps
-to declare properties in data classes with more easily readable names.
-
-> You can find the state of the project after this section [on the `final` branch](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage/tree/final).
->
-{type="note"}
-
-## Configure SQLDelight and implement cache logic
-
-### Configure SQLDelight
-
-The SQLDelight library allows you to generate a type-safe Kotlin database API from SQL queries. During compilation, the
-generator validates the SQL queries and turns them into Kotlin code that can be used in the shared module.
-
-The library is already in the project. To configure it, go to the `shared` directory and add the `sqldelight` block to
-the end of the `build.gradle.kts` file. The block will contain a list of databases and their parameters:
-
-```kotlin
-sqldelight {
-    database("AppDatabase") {
-        packageName = "com.jetbrains.handson.kmm.shared.cache"
-    }
-}
-```
-
-The `packageName` parameter specifies the package name for the generated Kotlin sources.
-
-> Consider installing the official [SQLite plugin](https://cashapp.github.io/sqldelight/multiplatform_sqlite/intellij_plugin/)
-> for working with `.sq` files.
->
-{type="tip"}
-
-### Generate the database API
-
-First, create the `.sq` file, which will contain all the needed SQL queries. By default, the SQLDelight plugin reads
-`.sq` from the `sqldelight` folder:
-
-1. In `shared/src/commonMain`, create a new `sqldelight` directory and add
-   the `com.jetbrains.handson.kmm.shared.cache` package.
-2. Inside the package, create an `.sq` file with the name of the database, `AppDatabase.sq`. All the SQL queries for
-   the application will be in this file.
-3. The database will contain a table with data about launches. To create the table, add the following
-   code to the `AppDatabase.sq` file:
-
-   ```text
-   CREATE TABLE Launch (
-       flightNumber INTEGER NOT NULL,
-       missionName TEXT NOT NULL,
-       details TEXT,
-       launchSuccess INTEGER AS Boolean DEFAULT NULL,
-       launchDateUTC TEXT NOT NULL,
-       patchUrlSmall TEXT,
-       patchUrlLarge TEXT,
-       articleUrl TEXT
-   );
-   ```
-
-4. To insert data into the tables, declare an SQL insert function:
-
-   ```text
-   insertLaunch:
-   INSERT INTO Launch(flightNumber, missionName, details, launchSuccess, launchDateUTC, patchUrlSmall, patchUrlLarge, articleUrl)
-   VALUES(?, ?, ?, ?, ?, ?, ?, ?);
-   ```
-
-5. To clear data in the tables, declare an SQL delete function:
-
-   ```text
-   removeAllLaunches:
-   DELETE FROM Launch;
-   ```
-
-6. In the same way, declare a function to retrieve data:
-
-   ```text
-   selectAllLaunchesInfo:
-   SELECT Launch.*
-   FROM Launch;
-   ```
-
-After the project is compiled, the generated Kotlin code will be stored in the `shared/build/generated/sqldelight`
-directory. The generator will create an interface named `AppDatabase`, as specified in `build.gradle.kts`.
-
-### Create platform database drivers
-
-To initialize `AppDatabase`, pass an `SqlDriver` instance to it. SQLDelight provides multiple platform-specific
-implementations of the SQLite driver, so you need to create them for each platform separately. You can do this by using
-[expected and actual declarations](multiplatform-expect-actual.md).
-
-1. Create an abstract factory for database drivers. To do this, in `shared/src/commonMain/kotlin`, create
-   the `com.jetbrains.handson.kmm.shared.cache` package and the `DatabaseDriverFactory` class inside it:
-
-   ```kotlin
-   package com.jetbrains.handson.kmm.shared.cache
-   
-   import com.squareup.sqldelight.db.SqlDriver
-
-   expect class DatabaseDriverFactory {
-       fun createDriver(): SqlDriver
-   }
-   ```
-
-   Now provide `actual` implementations for this expected class.
-
-2. On Android, the `AndroidSqliteDriver` class implements the SQLite driver. Pass the database information and the link
-   to the context to the `AndroidSqliteDriver` class constructor.
-
-   For this, in the `shared/src/androidMain/kotlin` directory, create the `com.jetbrains.handson.kmm.shared.cache`
-   package and a `DatabaseDriverFactory` class inside it with the actual implementation:
-
-   ```kotlin
-   package com.jetbrains.handson.kmm.shared.cache
-   
-   import android.content.Context
-   import com.squareup.sqldelight.android.AndroidSqliteDriver
-   import com.squareup.sqldelight.db.SqlDriver
-   
-   actual class DatabaseDriverFactory(private val context: Context) {
-       actual fun createDriver(): SqlDriver {
-           return AndroidSqliteDriver(AppDatabase.Schema, context, "test.db")
-       }
-   }
-   ```
-
-3. On iOS, the SQLite driver implementation is the `NativeSqliteDriver` class. In the `shared/src/iosMain/kotlin`
-   directory, create a `com.jetbrains.handson.kmm.shared.cache` package and a `DatabaseDriverFactory` class inside it with
-   the actual implementation:
-
-   ```kotlin
-   package com.jetbrains.handson.kmm.shared.cache
-   
-   import com.squareup.sqldelight.db.SqlDriver
-   import com.squareup.sqldelight.drivers.native.NativeSqliteDriver
-
-   actual class DatabaseDriverFactory {
-       actual fun createDriver(): SqlDriver {
-           return NativeSqliteDriver(AppDatabase.Schema, "test.db")
-       }
-   }
-   ```
-
-Instances of these factories will be created later in the code of your Android and iOS projects.
-
-You can navigate through the `expect` declarations and `actual` implementations by clicking the handy gutter icon:
-
-![Expect/Actual gutter](expect-actual-gutter-sql.png){width=500}
-
-### Implement cache
-
-So far, you have added platform database drivers and an `AppDatabase` class to perform database operations. Now create
-a `Database` class, which will wrap the `AppDatabase` class and contain the caching logic.
-
-1. In the common source set `shared/src/commonMain/kotlin`, create a new `Database` class in
-   the `com.jetbrains.handson.kmm.shared.cache` package. It will be common to both platform logics.
-
-2. To provide a driver for `AppDatabase`, pass an abstract `DatabaseDriverFactory` to the `Database` class constructor:
-
-   ```kotlin
-   package com.jetbrains.handson.kmm.shared.cache
-   
-   import com.jetbrains.handson.kmm.shared.entity.Links
-   import com.jetbrains.handson.kmm.shared.entity.Patch
-   import com.jetbrains.handson.kmm.shared.entity.RocketLaunch
-
-   internal class Database(databaseDriverFactory: DatabaseDriverFactory) {
-       private val database = AppDatabase(databaseDriverFactory.createDriver())
-       private val dbQuery = database.appDatabaseQueries
-   }
-   ```
-
-   This class's [visibility](visibility-modifiers.md#class-members) is set to internal, which means it is only
-   accessible from within the multiplatform module.
-
-3. Inside the `Database` class, implement some data handling operations. Add a function to clear all the tables in the
-   database in a single SQL transaction:
-
-   ```kotlin
-   internal fun clearDatabase() {
-       dbQuery.transaction {
-           dbQuery.removeAllLaunches()
-       }
-    }
-   ```
-
-4. Create a function to get a list of all the rocket launches:
-
-   ```kotlin
-   import com.jetbrains.handson.kmm.shared.entity.Links
-   import com.jetbrains.handson.kmm.shared.entity.Patch
-   import com.jetbrains.handson.kmm.shared.entity.RocketLaunch
-
-   internal fun getAllLaunches(): List<RocketLaunch> {
-       return dbQuery.selectAllLaunchesInfo(::mapLaunchSelecting).executeAsList()
-   }
-   
-   private fun mapLaunchSelecting(
-       flightNumber: Long,
-       missionName: String,
-       details: String?,
-       launchSuccess: Boolean?,
-       launchDateUTC: String,
-       patchUrlSmall: String?,
-       patchUrlLarge: String?,
-       articleUrl: String?
-   ): RocketLaunch {
-       return RocketLaunch(
-           flightNumber = flightNumber.toInt(),
-           missionName = missionName,
-           details = details,
-           launchDateUTC = launchDateUTC,
-           launchSuccess = launchSuccess,
-           links = Links(
-               patch = Patch(
-                   small = patchUrlSmall,
-                   large = patchUrlLarge
-               ),
-               article = articleUrl
-           )
-       )
-   }
-   ```
-
-   The argument passed to `selectAllLaunchesInfo` is a function that maps the database entity class to another type,
-   which in this case is the `RocketLaunch` data model class.
-
-5. Add a function to insert data into the database:
-
-    ```kotlin
-    internal fun createLaunches(launches: List<RocketLaunch>) {
-        dbQuery.transaction {
-            launches.forEach { launch ->
-                insertLaunch(launch)
-            }
-        }
-    }
-    
-    private fun insertLaunch(launch: RocketLaunch) {
-        dbQuery.insertLaunch(
-            flightNumber = launch.flightNumber.toLong(),
-            missionName = launch.missionName,
-            details = launch.details,
-            launchSuccess = launch.launchSuccess ?: false,
-            launchDateUTC = launch.launchDateUTC,
-            patchUrlSmall = launch.links.patch?.small,
-            patchUrlLarge = launch.links.patch?.large,
-            articleUrl = launch.links.article
-        )
-    }
-    ```
-
-The `Database` class instance will be created later, along with the SDK facade class.
-
-> You can find the state of the project after this section [on the `final` branch](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage/tree/final).
->
-{type="note"}
-
-## Implement an API service
-
-To retrieve data over the internet, you'll need the [SpaceX public API](https://github.com/r-spacex/SpaceX-API/tree/master/docs#rspacex-api-docs)
-and a single method to retrieve the list of all launches from the `v5/launches` endpoint.
-
-Create a class that will connect the application to the API:
-
-1. In the common source set `shared/src/commonMain/kotlin`, create the `com.jetbrains.handson.kmm.shared.network`
-   package and the `SpaceXApi` class inside it:
-
-   ```kotlin
-   package com.jetbrains.handson.kmm.shared.network
-
-   import com.jetbrains.handson.kmm.shared.entity.RocketLaunch
-   import io.ktor.client.*
-   import io.ktor.client.call.*
-   import io.ktor.client.plugins.contentnegotiation.*
-   import io.ktor.client.request.*
-   import io.ktor.serialization.kotlinx.json.*
-   import kotlinx.serialization.json.Json
-
-   class SpaceXApi {
-       private val httpClient = HttpClient {
-           install(ContentNegotiation) {
-               json(Json {
-                   ignoreUnknownKeys = true
-                   useAlternativeNames = false
-               })
-           }
-       }
-   }
-   ```
-
-    * This class executes network requests and deserializes JSON responses into entities from the `entity` package.
-      The Ktor `HttpClient` instance initializes and stores the `httpClient` property.
-    * This code uses the [Ktor `ContentNegotiation` plugin](https://ktor.io/docs/serialization-client.html)
-      to deserialize the `GET` request result. The plugin processes the request and the response payload as JSON,
-      serializing and deserializing them using a special serializer.
-
-2. Declare the data retrieval function that will return the list of `RocketLaunch`es:
-
-   ```kotlin
-   suspend fun getAllLaunches(): List<RocketLaunch> {
-       return httpClient.get("https://api.spacexdata.com/v5/launches").body()
-   }
-   ```
-
-   * The `getAllLaunches` function has the `suspend` modifier because it contains a call of the suspend function `get()`,
-     which includes an asynchronous operation to retrieve data over the internet and can only be called from a
-     coroutine or another suspend function. The network request will be executed in the HTTP client's thread pool.
-   * The URL is defined inside the `get()` function to send requests.
-
-### Add internet access permission
-
-To access the internet, the Android application needs the appropriate permission. Since all network requests are made
-from the shared module, adding the internet access permission to this module's manifest makes sense.
-
-In the `androidApp/src/main/AndroidManifest.xml` file, add the following permission to the manifest:
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <uses-permission android:name="android.permission.INTERNET" />
-    
-</manifest>
-```
-
-> You can find the state of the project after this section [on the `final` branch](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage/tree/final).
->
-{type="note"}
-
-# Build an SDK
-
-Your iOS and Android applications will communicate with the SpaceX API through the shared module, which will provide a
-public class.
-
-1. In the `com.jetbrains.handson.kmm.shared` package of the common source set, create the `SpaceXSDK` class:
-
-   ```kotlin
-   package com.jetbrains.handson.kmm.shared
-   
-   import com.jetbrains.handson.kmm.shared.cache.Database
-   import com.jetbrains.handson.kmm.shared.cache.DatabaseDriverFactory
-   import com.jetbrains.handson.kmm.shared.network.SpaceXApi
-
-   class SpaceXSDK (databaseDriverFactory: DatabaseDriverFactory) {
-       private val database = Database(databaseDriverFactory)
-       private val api = SpaceXApi()
-   }
-   ```
-
-   This class will be the facade over the `Database` and `SpaceXApi` classes.
-
-2. To create a `Database` class instance, you'll need to provide the `DatabaseDriverFactory` platform instance to it, so
-   you'll inject it from the platform code through the `SpaceXSDK` class constructor.
-
-   ```kotlin
-   import com.jetbrains.handson.kmm.shared.entity.RocketLaunch
-   
-   @Throws(Exception::class)
-   suspend fun getLaunches(forceReload: Boolean): List<RocketLaunch> {
-       val cachedLaunches = database.getAllLaunches()
-       return if (cachedLaunches.isNotEmpty() && !forceReload) {
-           cachedLaunches
-       } else {
-           api.getAllLaunches().also {
-               database.clearDatabase()
-               database.createLaunches(it)
-           }
-       }
-   }
-   ```
-
-   * The class contains one function for getting all launch information. Depending on the value of `forceReload`, it
-     returns cached values or loads the data from the internet and then updates the cache with the results. If there is
-     no cached data, it loads the data from the internet independently of the `forceReload` flag’s value.
-   * Clients of your SDK could use a `forceReload` flag to load the latest information about the launches, which would
-     allow the user to use the pull-to-refresh gesture.
-   * To handle exceptions produced by the Ktor client in Swift, the function is marked with the `@Throws` annotation.
-
-   All Kotlin exceptions are unchecked, while Swift has only checked errors. Thus, to make your Swift code aware of expected
-   exceptions, Kotlin functions should be marked with the `@Throws` annotation specifying a list of potential exception
-   classes.
-
-> You can find the state of the project after this section [on the `final` branch](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage/tree/final).
->
-{type="note"}
-
-## Create the Android application
-
-The Kotlin Multiplatform Mobile plugin for Android Studio has already handled the configuration for you, so the Kotlin
-Multiplatform shared module is already connected to your Android application.
-
-Before implementing the UI and the presentation logic, add all the required dependencies to
-the `androidApp/build.gradle.kts`:
-
-```kotlin
-// ...
-dependencies {
-    implementation(project(":shared"))
-    implementation("com.google.android.material:material:1.9.0")
-    implementation("androidx.appcompat:appcompat:1.6.1")
-    implementation("androidx.constraintlayout:constraintlayout:2.1.4")
-    implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.1.0")
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1")
-    implementation("androidx.core:core-ktx:1.10.1")
-    implementation("androidx.recyclerview:recyclerview:1.3.0")
-    implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.1.0")
-    implementation("androidx.cardview:cardview:1.0.0")
-}
-// ...
-```
-
-### Implement the UI: display the list of rocket launches
-
-1. To implement the UI, create the `layout/activity_main.xml` file in `androidApp/src/main/res`.
-
-   The screen is based on the `ConstraintLayout` with the `SwipeRefreshLayout` inside it, which contains `RecyclerView`
-   and `FrameLayout` with a background with a `ProgressBar` across its center:
-
-   ```xml
-   ```
-   {src="multiplatform-mobile-tutorial/activity_main.xml" initial-collapse-state="collapsed" collapsed-title="androidx.constraintlayout.widget.ConstraintLayout xmlns:android" lines="1-26"}
-
-2. In `androidApp/src/main/java`, replace the implementation of the `MainActivity` class, adding the properties for the
-   UI elements:
-
-   ```kotlin
-   class MainActivity : AppCompatActivity() {
-       private lateinit var launchesRecyclerView: RecyclerView
-       private lateinit var progressBarView: FrameLayout
-       private lateinit var swipeRefreshLayout: SwipeRefreshLayout
-   
-       override fun onCreate(savedInstanceState: Bundle?) {
-           super.onCreate(savedInstanceState)
-   
-           title = "SpaceX Launches"
-           setContentView(R.layout.activity_main)
-   
-           launchesRecyclerView = findViewById(R.id.launchesListRv)
-           progressBarView = findViewById(R.id.progressBar)
-           swipeRefreshLayout = findViewById(R.id.swipeContainer)
-       }
-   }
-   ```
-
-3. For the `RecyclerView` element to work, you need to create an adapter (as a subclass of `RecyclerView.Adapter`) that
-   will convert raw data into list item views. To do this, create a separate `LaunchesRvAdapter` class:
-
-   ```kotlin
-   class LaunchesRvAdapter(var launches: List<RocketLaunch>) : RecyclerView.Adapter<LaunchesRvAdapter.LaunchViewHolder>() {
-   
-       override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): LaunchViewHolder {
-           return LayoutInflater.from(parent.context)
-               .inflate(R.layout.item_launch, parent, false)
-               .run(::LaunchViewHolder)
-       }
-   
-       override fun getItemCount(): Int = launches.count()
-   
-       override fun onBindViewHolder(holder: LaunchViewHolder, position: Int) {
-           holder.bindData(launches[position])
-       }
-   
-       inner class LaunchViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
-           // ...
-           fun bindData(launch: RocketLaunch) {
-               // ...
-           }
-       }
-   }
-   ```
-
-4. Create an `item_launch.xml` resource file in `androidApp/src/main/res/layout/` with the items view layout:
-
-   ```xml
-   ```
-   {src="multiplatform-mobile-tutorial/item_launch.xml" initial-collapse-state="collapsed" collapsed-title="androidx.cardview.widget.CardView xmlns:android" lines="1-28"}
-
-5. In `androidApp/src/main/res/values/`, either create your appearance of the app or copy the following styles:
-
-   <tabs>
-   <tab title="colors.xml">
-
-   ```xml
-   <?xml version="1.0" encoding="utf-8"?>
-   <resources>
-       <color name="colorPrimary">#37474f</color>
-       <color name="colorPrimaryDark">#102027</color>
-       <color name="colorAccent">#62727b</color>
-   
-       <color name="colorSuccessful">#4BB543</color>
-       <color name="colorUnsuccessful">#FC100D</color>
-       <color name="colorNoData">#615F5F</color>
-   </resources>
-   ```
-
-   </tab>
-   <tab title="strings.xml">
-
-   ```xml
-   <?xml version="1.0" encoding="utf-8"?>
-   <resources>
-       <string name="app_name">SpaceLaunches</string>
-   
-       <string name="successful">Successful</string>
-       <string name="unsuccessful">Unsuccessful</string>
-       <string name="no_data">No data</string>
-   
-       <string name="launch_year_field">Launch year: %s</string>
-       <string name="mission_name_field">Launch name: %s</string>
-       <string name="launch_success_field">Launch success: %s</string>
-       <string name="details_field">Launch details: %s</string>
-   </resources>
-   ```
-
-   </tab>
-   <tab title="styles.xml">
-
-   ```xml
-   <resources>
-       <!-- Base application theme. -->
-       <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
-           <!-- Customize your theme here. -->
-           <item name="colorPrimary">@color/colorPrimary</item>
-           <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
-           <item name="colorAccent">@color/colorAccent</item>
-       </style>
-   </resources>
-   ```
-
-   </tab>
-   </tabs>
-
-6. Complete the implementation of the `RecyclerView.Adapter`:
-
-   ```kotlin
-   class LaunchesRvAdapter(var launches: List<RocketLaunch>) : RecyclerView.Adapter<LaunchesRvAdapter.LaunchViewHolder>() {
-       // ...
-       inner class LaunchViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
-           private val missionNameTextView = itemView.findViewById<TextView>(R.id.missionName)
-           private val launchYearTextView = itemView.findViewById<TextView>(R.id.launchYear)
-           private val launchSuccessTextView = itemView.findViewById<TextView>(R.id.launchSuccess)
-           private val missionDetailsTextView = itemView.findViewById<TextView>(R.id.details)
-
-           fun bindData(launch: RocketLaunch) {
-               val ctx = itemView.context
-               missionNameTextView.text = ctx.getString(R.string.mission_name_field, launch.missionName)
-               launchYearTextView.text = ctx.getString(R.string.launch_year_field, launch.launchYear.toString())
-               missionDetailsTextView.text = ctx.getString(R.string.details_field, launch.details ?: "")
-               val launchSuccess = launch.launchSuccess
-               if (launchSuccess != null ) {
-                   if (launchSuccess) {
-                       launchSuccessTextView.text = ctx.getString(R.string.successful)
-                       launchSuccessTextView.setTextColor((ContextCompat.getColor(itemView.context, R.color.colorSuccessful)))
-                   } else {
-                       launchSuccessTextView.text = ctx.getString(R.string.unsuccessful)
-                       launchSuccessTextView.setTextColor((ContextCompat.getColor(itemView.context, R.color.colorUnsuccessful)))
-                   }
-               } else {
-                   launchSuccessTextView.text = ctx.getString(R.string.no_data)
-                   launchSuccessTextView.setTextColor((ContextCompat.getColor(itemView.context, R.color.colorNoData)))
-               }
-           }
-       }
-   }
-   ```
-
-7. Update the `MainActivity` class as follows:
-
-   ```kotlin
-   class MainActivity : AppCompatActivity() {
-       // ...
-       private val launchesRvAdapter = LaunchesRvAdapter(listOf())
-   
-       override fun onCreate(savedInstanceState: Bundle?) {
-           // ...
-           launchesRecyclerView.adapter = launchesRvAdapter
-           launchesRecyclerView.layoutManager = LinearLayoutManager(this)
-   
-           swipeRefreshLayout.setOnRefreshListener {
-               swipeRefreshLayout.isRefreshing = false
-               displayLaunches(true)
-           }
-   
-           displayLaunches(false)
-       }
-   
-       private fun displayLaunches(needReload: Boolean) {
-           // TODO: Presentation logic
-       }
-   }
-   ```
-
-   Here you create an instance of `LaunchesRvAdapter`, configure the `RecyclerView` component, and implement all the
-   `LaunchesListView` interface functions. To catch the screen refresh gesture, you add a listener to the `SwipeRefreshLayout`.
-
-### Implement the presentation logic
-
-1. Create an instance of the `SpaceXSDK` class from the shared module and inject an instance of `DatabaseDriverFactory` in
-   it:
-
-   ```kotlin
-   class MainActivity : AppCompatActivity() {
-       // ...
-       private val sdk = SpaceXSDK(DatabaseDriverFactory(this))
-   }
-   ```
-
-2. Implement the private function `displayLaunches(needReload: Boolean)`. It runs the `getLaunches()` function inside
-   the coroutine launched in the main `CoroutineScope`, handles exceptions, and displays the error text in the toast message:
-
-   ```kotlin
-   class MainActivity : AppCompatActivity() {
-       private val mainScope = MainScope()
-       // ...
-       override fun onDestroy() {
-           super.onDestroy()
-           mainScope.cancel()
-       }
-       // ...
-       private fun displayLaunches(needReload: Boolean) {
-           progressBarView.isVisible = true
-           mainScope.launch {
-               kotlin.runCatching {
-                   sdk.getLaunches(needReload)
-               }.onSuccess {
-                   launchesRvAdapter.launches = it
-                   launchesRvAdapter.notifyDataSetChanged()
-               }.onFailure {
-                   Toast.makeText(this@MainActivity, it.localizedMessage, Toast.LENGTH_SHORT).show()
-               }
-               progressBarView.isVisible = false
-           }
-       }
-   }
-   ```
-
-3. Select **androidApp** from the run configurations menu, choose an emulator, and click the run button:
-
-![Android application](android-application.png){width=350}
-
-You've just created an Android application that has its business logic implemented in the Kotlin Multiplatform Mobile
-module.
-
-> You can find the state of the project after this section [on the `final` branch](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage/tree/final).
->
-{type="note"}
-
-# Create the iOS application
-
-For the iOS part of the project, you'll make use of [SwiftUI](https://developer.apple.com/xcode/swiftui/) to build the user
-interface and the "Model View View-Model" pattern to connect the UI to the shared module, which contains all the business logic.
-
-The shared module is already connected to the iOS project because the Android Studio plugin wizard has done all the configuration.
-You can import it the same way you would regular iOS dependencies: `import shared`.
-
-### Implement the UI
-
-First, you'll create a `RocketLaunchRow` SwiftUI view for displaying an item from the list. It will be based on the `HStack`
-and `VStack` views. There will be extensions on the `RocketLaunchRow` structure with useful helpers for displaying the
-data.
-
-1. Launch your Xcode app and select **Open a project or file**.
-2. Navigate to your project and select the `iosApp` folder. Click **Open**.
-3. In your Xcode project, create a new Swift file with the type **SwiftUI View**, name it `RocketLaunchRow`, and update
-   it with the following code:
-
-   ```swift
-   import SwiftUI
-   import shared
-   
-   struct RocketLaunchRow: View {
-       var rocketLaunch: RocketLaunch
-   
-       var body: some View {
-           HStack() {
-               VStack(alignment: .leading, spacing: 10.0) {
-                   Text("Launch name: \(rocketLaunch.missionName)")
-                   Text(launchText).foregroundColor(launchColor)
-                   Text("Launch year: \(String(rocketLaunch.launchYear))")
-                   Text("Launch details: \(rocketLaunch.details ?? "")")
-               }
-               Spacer()
-           }
-       }
-   }
-   
-   extension RocketLaunchRow {
-       private var launchText: String {
-           if let isSuccess = rocketLaunch.launchSuccess {
-               return isSuccess.boolValue ? "Successful" : "Unsuccessful"
-           } else {
-               return "No data"
-           }
-       }
-   
-       private var launchColor: Color {
-           if let isSuccess = rocketLaunch.launchSuccess {
-               return isSuccess.boolValue ? Color.green : Color.red
-           } else {
-               return Color.gray
-           }
-       }
-   }
-   ```
-
-   The list of launches will be displayed in the `ContentView`, which the project wizard has already created.
-
-4. Create a `ViewModel` class for the `ContentView`, which will prepare and manage the data. Declare it as an extension
-   to the `ContentView`, as they are closely connected, and then add the following code to `ContentView.swift`:
-
-   ```swift
-   // ...
-   extension ContentView {
-       enum LoadableLaunches {
-           case loading
-           case result([RocketLaunch])
-           case error(String)
-       }
-       
-      @MainActor
-      class ViewModel: ObservableObject {
-          @Published var launches = LoadableLaunches.loading
-      }
-   }
-   ```
-
-    * The [Combine framework](https://developer.apple.com/documentation/combine) connects the view model (`ContentView.ViewModel`)
-      with the view (`ContentView`).
-    * `ContentView.ViewModel` is declared as an `ObservableObject` and `@Published` wrapper is used for the `launches`
-      property, so the view model will emit signals whenever this property changes.
-
-5. Implement the body of the `ContentView` file and display the list of launches:
-
-   ```swift
-   struct ContentView: View {
-    @ObservedObject private(set) var viewModel: ViewModel
-   
-        var body: some View {
-            NavigationView {
-                listView()
-                .navigationBarTitle("SpaceX Launches")
-                .navigationBarItems(trailing:
-                    Button("Reload") {
-                        self.viewModel.loadLaunches(forceReload: true)
-                })
-            }
-        }
-   
-        private func listView() -> AnyView {
-            switch viewModel.launches {
-            case .loading:
-                return AnyView(Text("Loading...").multilineTextAlignment(.center))
-            case .result(let launches):
-                return AnyView(List(launches) { launch in
-                    RocketLaunchRow(rocketLaunch: launch)
-                })
-            case .error(let description):
-                return AnyView(Text(description).multilineTextAlignment(.center))
-            }
-        }
-    }
-   ```
-
-   The `@ObservedObject` property wrapper is used to subscribe to the view model.
-
-6. To make it compile, the `RocketLaunch` class needs to confirm the `Identifiable` protocol, as it is used as a
-   parameter for initializing the `List` Swift UIView. The `RocketLaunch` class already has a property named `id`, so
-   add the following to the bottom of `ContentView.swift`:
-
-   ```Swift
-   extension RocketLaunch: Identifiable { }
-   ```
-
-### Load the data
-
-To retrieve the data about the rocket launches in the view model, you'll need an instance of `SpaceXSDK` from the Multiplatform
-library.
-
-1. In `ContentView.swift`, pass it in through the constructor:
-
-   ```swift
-   extension ContentView {
-       // ...
-       @MainActor
-       class ViewModel: ObservableObject {
-           let sdk: SpaceXSDK
-           @Published var launches = LoadableLaunches.loading
-   
-           init(sdk: SpaceXSDK) {
-               self.sdk = sdk
-               self.loadLaunches(forceReload: false)
-           }
-   
-           func loadLaunches(forceReload: Bool) {
-               // TODO: retrieve data
-           }
-       }
-   }
-   ```
-
-2. Call the `getLaunches()` function from the `SpaceXSDK` class and save the result in the `launches` property:
-   
-   ```Swift
-   func loadLaunches(forceReload: Bool) {
-       Task {
-           do {
-               self.launches = .loading
-               let launches = try await sdk.getLaunches(forceReload: forceReload)
-               self.launches = .result(launches)
-           } catch {
-               self.launches = .error(error.localizedDescription)
-           }
-       }
-   }
-   ```
-
-   * When you compile a Kotlin module into an Apple framework, [suspending functions](whatsnew14.md#support-for-kotlin-s-suspending-functions-in-swift-and-objective-c)
-     are available in it as Swift's `async`/`await` mechanism.
-   * Since the `getLaunches` function is marked with the `@Throws(Exception::class)` annotation, any exceptions that are
-     instances of the `Exception` class or its subclass will be propagated as `NSError`. Therefore, all such errors can
-     be caught by the `loadLaunches()` function.
-
-3. Go to the entry point of the app, `iOSApp.swift`, and initialize the SDK, view, and view model:
-
-   ```swift
-   import SwiftUI
-   import shared
-   
-   @main
-   struct iOSApp: App {
-       let sdk = SpaceXSDK(databaseDriverFactory: DatabaseDriverFactory())
-       var body: some Scene {
-           WindowGroup {
-               ContentView(viewModel: .init(sdk: sdk))
-           }
-       }
-   }
-   ```
-
-4. In Android Studio, switch to the **iosApp** configuration, choose an emulator, and run it to see the result:
-
-![iOS Application](ios-application.png){width=350}
-
-> You can find the final version of the project [on the `final` branch](https://github.com/kotlin-hands-on/kmm-networking-and-data-storage/tree/final).
->
-{type="note"}
-
-## What's next?
-
-This tutorial features some potentially resource-heavy operations, like parsing JSON and making requests to the database in
-the main thread. To learn about how to write concurrent code and optimize your app,
-see the [Coroutines guide](coroutines-guide.md).
-
-You can also check out these additional learning materials:
-
-* [Use the Ktor HTTP client in multiplatform projects](https://ktor.io/docs/http-client-engines.html#mpp-config)
-* [Make your Android application work on iOS](multiplatform-mobile-integrate-in-existing-app.md)
-* [Introduce your team to Kotlin Multiplatform Mobile](multiplatform-mobile-introduce-your-team.md)
\ No newline at end of file
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-plugin-releases.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-plugin-releases.md
index 12bcd15e7bb..e747805f714 100644
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-plugin-releases.md
+++ b/docs/topics/multiplatform-mobile/multiplatform-mobile-plugin-releases.md
@@ -1,6 +1,6 @@
 [//]: # (title: Kotlin Multiplatform Mobile plugin releases)
 
-Since Kotlin Multiplatform Mobile is now in [Beta](kotlin-evolution.md), we are working on stabilizing the corresponding [plugin for Android Studio](https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform-mobile) 
+We are working on stabilizing the [Kotlin Multiplatform Mobile plugin for Android Studio](https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform-mobile) 
 and will be regularly releasing new versions that include new features, improvements, and bug fixes. 
 
 Ensure that you have the latest version of the Kotlin Multiplatform Mobile plugin!
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-publish-apps.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-publish-apps.md
deleted file mode 100644
index af1bbeff202..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-publish-apps.md
+++ /dev/null
@@ -1,48 +0,0 @@
-[//]: # (title: Publish your application)
-
-Once your mobile apps are ready for release, it's time to deliver them to the users by publishing them in app stores.
-Multiple stores are available for each platform. However, in this article we'll focus on the official ones:
-[Google Play Store](https://play.google.com/store) and [Apple App Store](https://www.apple.com/ios/app-store/).
-You'll learn how to prepare Kotlin Multiplatform applications for publishing, and we'll highlight
-the parts of this process that deserve special attention.
-
-## Android app
-
-Since [Kotlin is the main language for Android development](https://developer.android.com/kotlin),
-Kotlin Multiplatform has no obvious effect on compiling the project and building the Android app. Both the Android library produced from
-the shared module and the Android app itself are typical Android Gradle modules; they are no different from other Android
-libraries and apps. Thus, publishing the Android app from a Kotlin Multiplatform project is no different from the usual process described
-in the [Android developer documentation](https://developer.android.com/studio/publish).
-
-## iOS app
-
-The iOS app from a Kotlin Multiplatform project is built from a typical Xcode project, so the main stages involved in publishing it are
-the same as described in the [iOS developer documentation](https://developer.apple.com/ios/submit/).
-
-What is specific to Kotlin Multiplatform projects is compiling the shared Kotlin module into a framework and linking it to the Xcode project.
-Generally, all integration between the shared module and the Xcode project is done automatically by the [Kotlin Multiplatform Mobile plugin for Android Studio](https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform-mobile).
-However, if you don't use the plugin, bear in mind the following when building and bundling the iOS project in Xcode:
-
-* The shared Kotlin library compiles down to the native framework.
-* You need to connect the framework compiled for the specific platform to the iOS app project.
-* In the Xcode project settings, specify the path to the framework to search for the build system.
-* After building the project, you should launch and test the app to make sure that there are no issues when working with the framework in runtime.
-
-There are two ways you can connect the shared Kotlin module to the iOS project:
-* Use the [Kotlin/Native CocoaPods plugin](native-cocoapods.md), which allows you to use a multiplatform project with native targets as a CocoaPods dependency in your iOS project.
-* Manually configure your Multiplatform project to create an iOS framework and the Xcode project to obtain its latest version. The Kotlin Multiplatform Mobile plugin for Android Studio usually does this configuration. [Understand the project structure](multiplatform-mobile-understand-project-structure.md#ios-application) to implement it yourself.
-
-### Symbolicating crash reports
-
-To help developers make their apps better, iOS provides a means for analyzing app crashes. For detailed crash analysis,
-it uses special debug symbol (`.dSYM`) files that match memory addresses in crash reports with locations in the source code,
-such as functions or line numbers.
-
-By default, the release versions of iOS frameworks produced from the shared Kotlin module have an accompanying `.dSYM`
-file. This helps you analyze crashes that happen in the shared module's code.
-
-When an iOS app is rebuilt from bitcode, its `dSYM` file becomes invalid. For such cases, you can compile the shared module
-to a static framework that stores the debug information inside itself. For instructions on setting up crash report
-symbolication in binaries produced from Kotlin modules, see the [Kotlin/Native documentation](native-ios-symbolication.md).
-
-
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-samples.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-samples.md
deleted file mode 100644
index ed6f482ecbc..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-samples.md
+++ /dev/null
@@ -1,202 +0,0 @@
-[//]: # (title: Kotlin Multiplatform for mobile samples)
-
-This is a curated list of cross-platform mobile projects created with Kotlin Multiplatform.
-
-> You can find even more sample projects on GitHub, see the [`kotlin-multiplatform-mobile` topic](https://github.com/topics/kotlin-multiplatform-mobile).
->
-> If you want to add your Kotlin Multiplatform project to this topic and help the community,
-> follow the instructions in the [GitHub documentation](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/classifying-your-repository-with-topics#adding-topics-to-your-repository).
->
-{type="tip"}
-
-<table>
-  <tr>
-    <td>Sample name</td>
-    <td>What's shared?</td>
-    <td>Popular libraries used</td>
-    <td>UI Framework</td>
-    <td>iOS integration</td>
-    <td>Platform APIs</td>
-    <td>Tests</td>
-    <td>Features</td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/Kotlin/kmm-basic-sample">Kotlin Multiplatform Mobile Sample</a></strong>
-    </td>
-    <td>Algorithms</td>
-    <td>-</td>
-    <td>XML, SwiftUI</td>
-    <td>Xcode build phases</td>
-    <td>✅</td>
-    <td>-</td>
-    <td>
-      <list>
-        <li><code>expect</code>/<code>actual</code> declarations</li>
-      </list>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/Kotlin/kmm-production-sample">KMM RSS Reader</a></strong>
-    </td>
-    <td>Models, Networking, Data Storage, UI State</td>
-    <td>SQLDelight, Ktor, DateTime, multiplatform-settings, Napier, kotlinx.serialization</td>
-    <td>Jetpack Compose, SwiftUI</td>
-    <td>Xcode build phases</td>
-    <td>✅</td>
-    <td>-</td>
-    <td>
-      <list>
-        <li>Redux for sharing UI State</li>
-        <li>Published to Google Play and App Store</li>
-      </list>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/KaterinaPetrova/kmm-ktor-sample">kmm-ktor-sample</a></strong>
-    </td>
-    <td>Networking</td>
-    <td>Ktor, kotlinx.serialization, Napier</td>
-    <td>XML, SwiftUI</td>
-    <td>Xcode build phases</td>
-    <td>-</td>
-    <td>-</td>
-    <td>
-      <list>
-        <li><a href="https://www.youtube.com/watch?v=_Q62iJoNOfg%26list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C%26index=2">Video tutorial</a></li>
-      </list>
-    </td>
-  </tr>
-  <tr>
-    <td><strong><a href="https://github.com/JetBrains/compose-jb/tree/master/examples/todoapp">todoapp</a></strong></td>
-    <td>Models, Networking, Presentation, Navigation and UI </td>
-    <td>SQLDelight, Decompose, MVIKotlin, Reaktive</td>
-    <td>Jetpack Compose, SwiftUI</td>
-    <td>Xcode build phases</td>
-    <td>-</td>
-    <td>✅</td>
-    <td>
-      <list>
-        <li>99% of the code is shared</li>
-        <li>MVI architectural pattern</li>
-        <li>Shared UI across Android, Desktop and Web via <a href="https://www.jetbrains.com/lp/compose-mpp/">Compose Multiplatform</a></li>
-      </list>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/KaterinaPetrova/mpp-sample-lib">mpp-sample-lib</a></strong>
-    </td>
-    <td>Algorithms</td>
-    <td>-</td>
-    <td>-</td>
-    <td>-</td>
-    <td>✅</td>
-    <td>-</td>
-    <td>
-      <list>
-        <li>Demonstrates how to create a multiplatform library (<a href="https://dev.to/kathrinpetrova/series/11926">tutorial</a>)</li>
-      </list>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/touchlab/KaMPKit">KaMPKit</a></strong>
-    </td>
-    <td>Models, Networking, Data Storage, ViewModels</td>
-    <td>Koin, SQLDelight, Ktor, DateTime, multiplatform-settings, Kermit</td>
-    <td>Jetpack Compose, SwiftUI</td>
-    <td>CocoaPods</td>
-    <td>-</td>
-    <td>✅</td>
-    <td>-</td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/joreilly/PeopleInSpace">PeopleInSpace</a></strong>
-    </td>
-    <td>Models, Networking, Data Storage</td>
-    <td>Koin, SQLDelight, Ktor</td>
-    <td>Jetpack Compose, SwiftUI</td>
-    <td>CocoaPods, Swift Packages</td>
-    <td>-</td>
-    <td>✅</td>
-    <td>
-      <p>Target list:</p>
-      <list>
-        <li>Android Wear OS</li>
-        <li>iOS</li>
-        <li>watchOS</li>
-        <li>macOS Desktop (Compose for Desktop)</li>
-        <li>Web (Compose for Web)</li>
-        <li>Web (Kotlin/JS + React Wrapper)</li>
-        <li>JVM</li>
-      </list>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/dbaroncelli/D-KMP-sample">D-KMP-sample</a></strong>
-    </td>
-    <td>Networking, Data Storage, ViewModels, Navigation</td>
-    <td>SQLDelight, Ktor, DateTime, multiplatform-settings</td>
-    <td>Jetpack Compose, SwiftUI</td>
-    <td>Xcode build phases</td>
-    <td>-</td>
-    <td>✅</td>
-    <td>
-      <list>
-        <li>Implements the MVI pattern and the unidirectional data flow</li>
-        <li>Uses Kotlin's StateFlow to trigger UI layer recompositions</li>
-      </list>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/mitchtabian/Food2Fork-KMM">Food2Fork Recipe App</a></strong>
-    </td>
-    <td>Models, Networking, Data Storage, Interactors</td>
-    <td>SQLDelight, Ktor, DateTime</td>
-    <td>Jetpack Compose, SwiftUI</td>
-    <td>CocoaPods</td>
-    <td>-</td>
-    <td>-</td>
-    <td>-</td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/realm/realm-kotlin-samples/tree/main/Bookshelf">Bookshelf</a></strong>
-    </td>
-    <td>Models, Networking, Data Storage</td>
-    <td>Realm-Kotlin, Ktor, kotlinx.serialization</td>
-    <td>Jetpack Compose, SwiftUI</td>
-    <td>CocoaPods</td>
-    <td>-</td>
-    <td>-</td>
-    <td>
-      <list>
-        <li> Uses <a href="https://realm.io/">Realm</a> for data persistence </li>
-      </list>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <strong><a href="https://github.com/VictorKabata/Notflix">Notflix</a></strong>
-    </td>
-    <td>Models, Networking, Caching, ViewModels</td>
-    <td>Koin, Ktor, Multiplatform settings, kotlinx.coroutines, kotlinx.serialization, kotlinx.datetime, Napier</td>
-    <td>Jetpack Compose-Android, Compose Multiplatform-Desktop</td>
-    <td>-</td>
-    <td>✅</td>
-    <td>-</td>
-    <td>
-      <list>
-        <li>Modular architecture</li>
-        <li>Runs on desktop</li>
-        <li>Sharing viewmodel</li>
-      </list>
-    </td>
-  </tr>
-</table>
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-setup.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-setup.md
deleted file mode 100644
index d1e909f417e..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-setup.md
+++ /dev/null
@@ -1,145 +0,0 @@
-[//]: # (title: Set up an environment)
-
-<microformat>
-    <p>This is the first part of the <strong>Getting started with Kotlin Multiplatform for mobile</strong> tutorial:</p>
-    <p><img src="icon-1.svg" width="20" alt="First step"/> <strong>Set up an environment</strong><br/><img src="icon-2-todo.svg" width="20" alt="Second step"/> Create your first cross-platform app<br/><img src="icon-3-todo.svg" width="20" alt="Third step"/> Add dependencies<br/><img src="icon-4-todo.svg" width="20" alt="Fourth step"/> Upgrade your app<br/><img src="icon-5-todo.svg" width="20" alt="Fifth step"/> Wrap up your project</p>
-</microformat>
-
-Before you create your first application that works on both iOS and Android, you'll need to set up an environment for Kotlin Multiplatform
-Mobile development.
-
-> To write iOS-specific code and run an iOS application on a simulated or real device, you'll need a Mac with macOS.
-> This cannot be performed on other operating systems, such as Microsoft Windows. This is an Apple requirement.
->
-{type="warning"}
-
-## Install the necessary tools
-
-We recommend that you install the latest stable versions for compatibility and better performance.
-
-<table>
-   <tr>
-      <td>Tool</td>
-      <td>Comments</td>
-   </tr>
-    <tr>
-        <td><a href="https://developer.android.com/studio">Android Studio</a></td>
-        <td>You will use Android Studio to create your multiplatform applications and run them on simulated or hardware devices.</td>
-    </tr>
-    <tr>
-        <td><a href="https://apps.apple.com/us/app/xcode/id497799835">Xcode</a></td>
-        <td>
-          <p>Most of the time, Xcode will work in the background. You will use it to add Swift or Objective-C code to your iOS application.</p>
-            <note>
-              <p>
-                We generally recommend using the latest stable versions for all tools. However, Kotlin/Native sometimes doesn't support the newest Xcode right away. If that's your case, <a href="https://developer.apple.com/download/all/?q=Xcode">install an earlier version of Xcode</a>.
-              </p>
-            </note>   
-      </td>
-   </tr>
-   <tr>
-        <td><a href="https://www.oracle.com/java/technologies/javase-downloads.html">JDK</a></td>
-        <td>To check whether it's installed, run the following command in the Android Studio terminal or your command line: <code style="block"
-            lang="bash">java -version</code></td>
-   </tr>
-   <tr>
-        <td><a href="multiplatform-mobile-plugin-releases.md">Kotlin Multiplatform Mobile plugin</a></td>
-        <td>In Android Studio, select <strong>Settings/Preferences | Plugins</strong>, search <strong>Marketplace</strong> for <i>Kotlin Multiplatform Mobile</i>, and then install it.</td>
-   </tr>
-   <tr>
-        <td><a href="releases.md#update-to-a-new-release">Kotlin plugin</a></td>
-        <td>
-            <p>The Kotlin plugin is bundled with each Android Studio release. However, it still needs to be updated to the latest version to avoid compatibility issues.</p> 
-            <p>To update the plugin, on the Android Studio welcome screen, select <strong>Plugins | Installed</strong>. Click <strong>Update</strong> next to Kotlin. You can also check the Kotlin version in <strong>Tools | Kotlin | Configure Kotlin Plugin Updates</strong>.</p>
-            <p>The Kotlin plugin should be compatible with the Kotlin Multiplatform Mobile plugin. Refer to the <a href="multiplatform-mobile-plugin-releases.md#release-details">compatibility table</a>.</p></td>
-   </tr>
-</table>
-
-## Check your environment
-
-To make sure everything works as expected, install and run the KDoctor tool:
-
-> KDoctor works on macOS only.
->
-{type="note"}
-
-1. In the Android Studio terminal or your command-line tool, run the following command to install the tool using Homebrew:
-
-    ```bash
-    brew install kdoctor
-    ```
-
-   If you don't have Homebrew yet, [install it](https://brew.sh/) or see the KDoctor [README](https://github.com/Kotlin/kdoctor#installation) for other ways to install it.
-2. After the installation is completed, call KDoctor in the console: 
-
-    ```bash
-    kdoctor
-    ```
-
-3. If KDoctor diagnoses any problems while checking your environment, review the output for issues and possible solutions:
-
-   * Fix any failed checks (`[x]`). You can find problem descriptions and potential solutions after the `*` symbol.
-   * Check the warnings (`[!]`) and successful messages (`[v]`). They may contain useful notes and tips, as well.
-   
-   > You may ignore KDoctor's warnings regarding the CocoaPods installation. In your first project, you will use a
-   > different iOS framework distribution option.
-   >
-   {type="tip"}
-
-## Possible issues and solutions
-
-<deflist collapsible="true">
-   <def title="Android Studio">
-      Make sure that you have Android Studio installed. You can get it from its <a href="https://developer.android.com/studio">official website.</a>
-   </def>
-   <def title="Java and JDK">
-         <list>
-           <li>Make sure that you have JDK installed. You can get it from its <a href="https://www.oracle.com/java/technologies/javase-downloads.html">official website</a>.</li>
-           <li>Android Studio uses a bundled JDK to execute Gradle tasks. To configure the Gradle JDK in Android Studio, select <strong>Settings/Preferences | Build, Execution, Deployment | Build Tools | Gradle</strong>.</li>
-           <li>You might encounter issues related to <code>JAVA_HOME</code>. This environment variable specifies the location of the Java binary required for Xcode and Gradle. If so, follow KDoctor's tips to fix the issues.</li>
-         </list>
-   </def>
-   <def title="Xcode">
-      <list>
-         <li>Make sure that you have Xcode installed. You can get it from its <a href="https://developer.apple.com/xcode/">official website</a>.</li>
-         <li>Launch Xcode in a separate window to accept its license terms and allow it to perform some necessary initial tasks.</li>
-         <li>
-            <p><code>Error: can't grab Xcode schemes</code>. If you encounter an error like this, in Xcode, select <strong>Settings/Preferences | Locations</strong>. In the <strong>Command Line Tools</strong> field, select your Xcode.</p>
-            <img src="xcode-schemes.png" alt="Xcode schemes" width="500"/>
-         </li>
-      </list>
-   </def>
-   <def title="Kotlin plugins">
-         <chunk>
-            <p><strong>Kotlin Multiplatform Mobile plugin</strong></p>
-               <list>
-                  <li>Make sure that the Kotlin Mobile Multiplatform plugin is installed and enabled. On the Android Studio welcome screen, select <strong>Plugins | Installed</strong>. Verify that you have the plugin enabled. If it's not in the <strong>Installed</strong> list, search <strong>Marketplace</strong> for it and install the plugin.</li>
-                  <li>If the plugin is outdated, click <strong>Update</strong> next to the plugin name. You can do the same in the <strong>Settings/Preferences | Tools | Plugins</strong> section.</li>
-                  <li>Check the compatibility of the Kotlin Multiplatform Mobile plugin with your version of Kotlin in the <a href="https://kotlinlang.org/docs/multiplatform-mobile-plugin-releases.html#release-details">Release details</a> table.</li>
-               </list>
-         </chunk>
-         <chunk>
-            <p><strong>Kotlin plugin</strong></p>
-            <p>Make sure that the Kotlin plugin is updated to the latest version. To do that, on the Android Studio welcome screen, select <strong>Plugins | Installed</strong>. Click <strong>Update</strong> next to Kotlin.</p>
-            <p>You can also check the Kotlin version in <strong>Tools | Kotlin | Configure Kotlin Plugin Updates</strong>.</p>
-         </chunk>
-   </def>
-   <def title="Command line">
-            <p>Make sure you have all the necessary tools installed:</p>
-            <list>
-              <li><code>command not found: brew</code> — <a href="https://brew.sh/">install Homebrew</a>.</li>
-              <li><code>command not found: java</code> — <a href="https://www.oracle.com/java/technologies/javase-downloads.html">install Java</a>.</li>
-           </list>
-    </def>
-</deflist>
-
-## Next step
-
-In the next part of the tutorial, you'll create your first cross-platform mobile application.
-
-**[Proceed to the next part](multiplatform-mobile-create-first-app.md)**
-
-## Get help
-
-* **Kotlin Slack**. Get an [invite](https://surveys.jetbrains.com/s3/kotlin-slack-sign-up) and join the [#multiplatform](https://kotlinlang.slack.com/archives/C3PQML5NU) channel.
-* **Kotlin issue tracker**. [Report a new issue](https://youtrack.jetbrains.com/newIssue?project=KT).
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-understand-project-structure.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-understand-project-structure.md
deleted file mode 100644
index 07a12ee3526..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-understand-project-structure.md
+++ /dev/null
@@ -1,522 +0,0 @@
-[//]: # (title: Understand mobile project structure)
-
-The purpose of the Kotlin Multiplatform technology is unifying the development of applications with common 
-logic for Android and iOS platforms. To make this possible, it uses a mobile-specific structure of
-[Kotlin Multiplatform](multiplatform.md) projects.
-
-This page describes the structure and components of a basic cross-platform mobile project: shared module, Android app,
-and an iOS app.
-
-> This structure isn't the only possible way to organize your project; however, we recommend it as a starting point.
->
-{type="note"}
-
-To view the complete structure of your mobile multiplatform project, switch the view from **Android** to **Project**.
-
-![Select the Project view](select-project-view.png){width=200}
-
-## Root project
-
-The root project is a Gradle project that holds the shared module and the Android application as its subprojects.
-They are linked together via the [Gradle multi-project mechanism](https://docs.gradle.org/current/userguide/multi_project_builds.html). 
-
-![Basic Multiplatform Mobile project structure](basic-project-structure.png){width=700}
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-// settings.gradle.kts
-include(":shared")
-include(":androidApp")
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-// settings.gradle
-include ':shared'
-include ':androidApp'
-```
-
-</tab>
-</tabs>
-
-The iOS application is produced from an Xcode project. It's stored in a separate directory within the root project.
-Xcode uses its own build system; thus, the iOS application project isn't connected with other parts of the Multiplatform Mobile project
-via Gradle. Instead, it uses the shared module as an external artifact – framework. For details on integration between
-the shared module and the iOS application, see [iOS application](#ios-application).
-
-This is a basic structure of a cross-platform mobile project:
-
-![Basic Multiplatform Mobile project directories](basic-project-dirs.png){width=400}
-
-The root project does not hold source code. You can use it to store global configuration in its `build.gradle(.kts)` or 
-`gradle.properties`, for example, add repositories or define global configuration variables.
-
-For more complex projects, you can add more modules into the root project by creating them in the IDE and linking via
-`include` declarations in the Gradle settings.
-
-## Shared module
-
-Shared module contains the core application logic used in both Android and iOS target platforms: classes, functions, and so on.
-This is a [Kotlin Multiplatform](multiplatform-get-started.md) module that compiles
-into an Android library and an iOS framework. It uses the Gradle build system with the Kotlin Multiplatform plugin applied and 
-has targets for Android and iOS.
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-plugins {
-    kotlin("multiplatform") version "%kotlinVersion%"
-    // ..
-}
-
-kotlin {
-    android()
-    ios()
-}
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-plugins {
-    id 'org.jetbrains.kotlin.multiplatform' version '%kotlinVersion%'
-    //..
-}
-
-kotlin {
-    android()
-    ios()
-}
-```
-
-</tab>
-</tabs>
-
-### Source sets
-
-The shared module contains the code that is common for Android and iOS applications. However, to implement the same logic
-on Android and iOS, you sometimes need to write two platform-specific versions of it.
-To handle such cases, Kotlin offers the [expect/actual](multiplatform-expect-actual.md) mechanism.
-The source code of the shared module is organized in three source sets accordingly:
-
-* `commonMain` stores the code that works on both platforms, including the `expect` declarations
-* `androidMain` stores Android-specific parts, including `actual` implementations
-* `iosMain` stores iOS-specific parts, including `actual` implementations
-
-Each source set has its own dependencies. Kotlin standard library is added automatically to all source sets, you don't need to declare it in the build script.
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-kotlin {
-    sourceSets {
-        val commonMain by getting
-        val androidMain by getting {
-            dependencies {
-                implementation("androidx.core:core-ktx:1.2.0")
-            }
-        }
-        val iosMain by getting 
-        // ...
-    }
-}
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-kotlin {
-    sourceSets {
-        commonMain {
-        }
-        androidMain {
-            dependencies {
-                implementation 'androidx.core:core-ktx:1.2.0'
-            }
-        }
-        iosMain {
-        }
-
-        // ...
-    }
-}
-```
-
-</tab>
-</tabs>
-
-When you write your code, add the dependencies you need to the corresponding source sets.
-Read [Multiplatform documentation on adding dependencies](multiplatform-add-dependencies.md) for more information.
-
-Along with `*Main` source sets, there are three matching test source sets:
-
-* `commonTest`
-* `androidTest`
-* `iosTest`
-
-Use them to store unit tests for common and platform-specific source sets accordingly.
-By default, they have dependencies on Kotlin test library, providing you with means for Kotlin unit testing:
-annotations, assertion functions and other. You can add dependencies on other test libraries you need.
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-kotlin {
-    sourceSets {
-        // ...
-        val commonTest by getting {
-            dependencies {
-                implementation(kotlin("test"))
-            }
-        }
-        val androidTest by getting
-        val iosTest by getting
-    }
-
-}
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-kotlin {
-    sourceSets {
-        //...
-
-        commonTest {
-            dependencies {
-                implementation kotlin('test')
-            }
-        }
-        androidTest {
-
-        }
-        iosTest {
-
-        }
-    }
-}
-```
-
-</tab>
-</tabs>
-
-The main and test source sets described above are default. The Kotlin Multiplatform plugin generates them
-automatically upon target creation. In your project, you can add more source sets for specific purposes.
-For more information, see [Multiplatform DSL reference](multiplatform-dsl-reference.md#custom-source-sets).
-
-### Android library
-
-The configuration of the Android library produced from the shared module is typical for Android projects.
-To learn about Android libraries creation, see [Create an Android library](https://developer.android.com/studio/projects/android-library)
-in the Android developer documentation.
-
-To produce the Android library, a separate Gradle plugin is used in addition to Kotlin Multiplatform:
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-plugins {
-    // ...
-    id("com.android.library")
-}
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-plugins {
-    // ...
-    id 'com.android.library'
-}
-```
-
-</tab>
-</tabs>
-
-The configuration of Android library is stored in the `android {}` top-level block of the shared module's build script:
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-android {
-    // A typical Android configuration, see https://developer.android.com/build for details.
-    //  For example:
-    namespace = "com.example.kotlinmultiplatformsandbox"
-    compileSdk = 33
-    defaultConfig {
-        minSdk = 24
-    }
-}
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-android {
-    // A typical Android configuration, see https://developer.android.com/build for details.
-    // For example:
-    namespace "com.example.kotlinmultiplatformsandbox"
-    compileSdk 33
-    defaultConfig {
-        minSdk 24
-    }
-}
-```
-
-</tab>
-</tabs>
-
-It's typical for any Android project. You can edit it to suit your needs.
-To learn more, see the [Android developer documentation](https://developer.android.com/studio/build#module-level).
-
-### iOS framework
-
-For using in iOS applications, the shared module compiles into a framework – a kind of hierarchical directory
-with shared resources used on the Apple platforms.
-This framework connects to the Xcode project that builds into an iOS application.
-
-The framework is produced via the [Kotlin/Native](native-overview.md) compiler.
-The framework configuration is stored in the `ios {}` block of the build script within `kotlin {}`.
-It defines the output type `framework` and the string identifier `baseName` that is used to form the name
-of the output artifact. Its default value matches the Gradle module name. 
-For a real project, it's likely that you'll need a more complex configuration of the framework production.
-For details, see [Multiplatform documentation](multiplatform-build-native-binaries.md).
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-kotlin {
-    // ...
-    ios {
-        binaries {
-            framework {
-                baseName = "shared"
-            }
-        }
-    }
-}
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-kotlin {
-    // ...
-    ios {
-        binaries {
-            framework {
-                baseName = 'shared'
-            }
-        }
-    }
-}
-```
-
-</tab>
-</tabs>
-
-Additionally, there is a Gradle task `embedAndSignAppleFrameworkForXcode`, that exposes the framework to the Xcode project
-the iOS application is built from. It uses the iOS application's project configuration to define the build
-mode (`debug` or `release`) and provide the appropriate framework version to the specified location.
-
-The task is built into the multiplatform plugin. It executes upon each build of the Xcode project to provide the latest
-version of the framework for the iOS application. For details, see [iOS application](#ios-application).
-
-> Use the `embedAndSignAppleFrameworkForXcode` Gradle task with Xcode project builds only; otherwise, you'll get an error.
->
-{type="note"}
-
-## Android application
-
-The Android application part of a Multiplatform Mobile project is a typical Android application written in Kotlin.
-In a basic cross-platform mobile project, it uses two Gradle plugins: 
-
-* Kotlin Android
-* Android Application
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-plugins {
-    id("com.android.application")
-    kotlin("android")
-} 
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-plugins {
-    id 'com.android.application'
-    id 'org.jetbrains.kotlin.android'
-}
-```
-
-</tab>
-</tabs>
-
-To access the shared module code, the Android application uses it as a project dependency.
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-dependencies {
-    implementation(project(":shared"))
-    //..
-} 
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-dependencies {
-    implementation project(':shared')
-    //..
-}
-```
-
-</tab>
-</tabs>
-
-Besides this dependency, the Android application uses the Kotlin standard library (which is added automatically) and some common Android dependencies:
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-dependencies {
-    //..
-    implementation("androidx.core:core-ktx:1.2.0")
-    implementation("androidx.appcompat:appcompat:1.1.0")
-    implementation("androidx.constraintlayout:constraintlayout:1.1.3")
-} 
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-dependencies {
-    //..
-    implementation 'androidx.core:core-ktx:1.2.0'
-    implementation 'androidx.appcompat:appcompat:1.1.0'
-    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
-}
-```
-
-</tab>
-</tabs>
-
-Add your project's Android-specific dependencies to this block.
-The build configuration of the Android application is located in the `android {}` top-level block of the build script:
-
-<tabs group="build-script">
-<tab title="Kotlin" group-key="kotlin">
-
-```kotlin
-android {
-    compileSdk = 29
-    defaultConfig {
-        applicationId = "org.example.androidApp"
-        minSdk = 24
-        versionCode = 1
-        versionName = "1.0"
-    }
-    buildTypes {
-        getByName("release") {
-            isMinifyEnabled = false
-        }
-    }
-}
-```
-
-</tab>
-<tab title="Groovy" group-key="groovy">
-
-```groovy
-android {
-    compileSdk 29
-    defaultConfig {
-        applicationId 'org.example.androidApp'
-        minSdk 24
-        versionCode 1
-        versionName '1.0'
-    }
-    buildTypes {
-        'release' {
-            minifyEnabled false
-        }
-    }
-}
-```
-
-</tab>
-</tabs>
-
-It's typical for any Android project. You can edit it to suit your needs.
-To learn more, see the [Android developer documentation](https://developer.android.com/studio/build#module-level).
-
-## iOS application
-
-The iOS application is produced from an Xcode project generated automatically by the New Project wizard.
-It resides in a separate directory within the root project.
-
-![Basic Kotlin Multiplatform Xcode project](basic-xcode-project.png){width=400}
-
-For each build of the iOS application, the project obtains the latest version of the framework. To do this, it uses a
-**Run Script** build phase that executes the `embedAndSignAppleFrameworkForXcode` Gradle task from the shared module.
-This task generates the `.framework` with the required configuration, depending on the Xcode environment settings, and puts
-the artifact into the `DerivedData` Xcode directory.
-
-* If you have a custom name for the Apple framework, use `embedAndSign<Custom-name>AppleFrameworkForXcode` as the name for
-this Gradle task.
-* If you have a custom build configuration that is different from the default `Debug` or `Release`, on the **Build Settings**
-tab, add the `KOTLIN_FRAMEWORK_BUILD_TYPE` setting under **User-Defined** and set it to `Debug` or `Release`.
-
-> Use the `embedAndSignAppleFrameworkForXcode` Gradle task with Xcode project builds only; otherwise, you'll get an error.
->
-{type="note"}
-
-![Execution of `embedAndSignAppleFrameworkForXcode` in the Xcode project settings](packforxcode-in-project-settings.png){width=700}
-
-To embed framework into the application and make the declarations from the shared module available in the source code of the iOS application, the following build settings should be configured properly:
-
-1. **Other Linker flags** under the **Linking** section:
-
-   ```text
-   $(inherited) -framework shared
-   ```
-
-   ![Configuring **Other linker flags** in the Xcode project settings](other-linker-flags-in-xcode-project-settings.png){width=700}
-
-2. **Framework Search Paths** under the **Search Paths** section:
-
-   ```text
-   $(SRCROOT)/../shared/build/xcode-frameworks/$(CONFIGURATION)/$(SDK_NAME)
-   ```
-
-   ![Configuring **Framework Search Paths** in the Xcode project settings](framework-search-path-in-xcode-project-settings.png){width=700}
-
-In other aspects, the Xcode part of a cross-platform mobile project is a typical iOS application project.
-To learn more about creating iOS application, see the [Xcode documentation](https://developer.apple.com/documentation/xcode#topics).
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-upgrade-app.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-upgrade-app.md
deleted file mode 100644
index 29e03d508c2..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-upgrade-app.md
+++ /dev/null
@@ -1,371 +0,0 @@
-[//]: # (title: Upgrade your app)
-
-<microformat>
-    <p>This is the fourth part of the <strong>Getting started with Kotlin Multiplatform for mobile</strong> tutorial. Before proceeding, make sure you've completed previous steps.</p>
-    <p><img src="icon-1-done.svg" width="20" alt="First step"/> <a href="multiplatform-mobile-setup.md">Set up an environment</a><br/><img src="icon-2-done.svg" width="20" alt="Second step"/> <a href="multiplatform-mobile-create-first-app.md">Create your first cross-platform app</a><br/><img src="icon-3-done.svg" width="20" alt="Third step"/> <a href="multiplatform-mobile-dependencies.md">Add dependencies</a><br/><img src="icon-4.svg" width="20" alt="Fourth step"/> <strong>Upgrade your app</strong><br/><img src="icon-5-todo.svg" width="20" alt="Fifth step"/> Wrap up your project</p>
-</microformat>
-
-You've already implemented common logic using external dependencies. Now you can add more complex logic. Network
-requests and data serialization are the [most popular cases](https://kotlinlang.org/lp/multiplatform/) to share with Kotlin
-Multiplatform. Learn how to implement these in your first application, so that after completing this onboarding journey
-you can use them in future projects.
-
-The updated app will retrieve data over the internet from a [SpaceX API](https://github.com/r-spacex/SpaceX-API/tree/master/docs#rspacex-api-docs)
-and display the date of the last successful launch of a SpaceX rocket.
-
-## Add more dependencies
-
-You'll need the following multiplatform libraries in your project:
-
-* [`kotlinx.coroutines`](https://github.com/Kotlin/kotlinx.coroutines), for using coroutines to write asynchronous code,
-  which allows simultaneous operations.
-* [`kotlinx.serialization`](https://github.com/Kotlin/kotlinx.serialization), for deserializing JSON responses into objects of entity classes used to process
-  network operations.
-* [Ktor](https://ktor.io/), a framework as an HTTP client for retrieving data over the internet.
-
-### kotlinx.coroutines
-
-To add `kotlinx.coroutines` to your project, specify a dependency in the common source set. To do so, add the following
-line to the `build.gradle.kts` file of the shared module:
-
-```kotlin
-sourceSets {
-    val commonMain by getting {
-        dependencies {
-            // ...
-            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:%coroutinesVersion%")
-        }
-    }
-}
-```
-
-The Multiplatform Gradle plugin automatically adds a dependency to the platform-specific (iOS and Android) parts
-of `kotlinx.coroutines`.
-
-#### If you use Kotlin prior to version 1.7.20
-
-If you use Kotlin 1.7.20 and later, you already have the new Kotlin/Native memory manager enabled by default.
-If it's not the case, add the following to the end of the `build.gradle.kts` file:
-
-```kotlin
-kotlin.targets.withType(org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget::class.java) {
-    binaries.all {
-        binaryOptions["memoryModel"] = "experimental"
-    }
-}
-```
-
-### kotlinx.serialization
-
-For `kotlinx.serialization`, you need the plugin required by the build system. The Kotlin serialization plugin is shipped
-with the Kotlin compiler distribution, and the IntelliJ IDEA plugin is bundled into the Kotlin plugin.
-
-You can set up the serialization plugin with the Kotlin plugin using the Gradle plugins DSL by adding this line to
-the existing `plugins` block at the very beginning of the `build.gradle.kts` file in the shared module:
-
-```kotlin
-plugins {
-    // ...
-    kotlin("plugin.serialization") version "%kotlinVersion%"
-}
-```
-
-### Ktor
-
-You can add Ktor in the same way you've added the `kotlinx.coroutines` library. In addition to specifying the core
-dependency (`ktor-client-core`) in the common source set, you also need to:
-
-* Add the ContentNegotiation functionality (`ktor-client-content-negotiation`), responsible for serializing/deserializing
-  the content in a specific format.
-* Add the `ktor-serialization-kotlinx-json` dependency to instruct Ktor to use the JSON format and `kotlinx.serialization`
-  as a serialization library. Ktor will expect JSON data and deserialize it into a data class when receiving responses.
-* Provide the platform engines by adding dependencies on the corresponding artifacts in the platform source sets
-  (`ktor-client-android`, `ktor-client-darwin`).
-
-```kotlin
-val ktorVersion = "%ktorVersion%"
-
-sourceSets {
-    val commonMain by getting {
-        dependencies {
-            // ...
-            implementation("io.ktor:ktor-client-core:$ktorVersion")
-            implementation("io.ktor:ktor-client-content-negotiation:$ktorVersion")
-            implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
-        }
-    }
-    val androidMain by getting {
-        dependencies {
-            implementation("io.ktor:ktor-client-android:$ktorVersion")
-        }
-    }
-    val iosMain by getting {
-        // ...
-        dependencies {
-            implementation("io.ktor:ktor-client-darwin:$ktorVersion") 
-        }
-    }
-}
-```
-
-Synchronize the Gradle files by clicking **Sync Now** in the notification.
-
-## Create API requests
-
-You'll need the [SpaceX API](https://github.com/r-spacex/SpaceX-API/tree/master/docs#rspacex-api-docs) to retrieve data and a single method to
-get the list of all launches from the **v4/launches** endpoint.
-
-### Add data model
-
-In `shared/src/commonMain/kotlin`, create a new `RocketLaunch.kt` file in the project folder
-and add a data class which stores data from the SpaceX API:
-
-```kotlin
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class RocketLaunch (
-    @SerialName("flight_number")
-    val flightNumber: Int,
-    @SerialName("name")
-    val missionName: String,
-    @SerialName("date_utc")
-    val launchDateUTC: String,
-    @SerialName("success")
-    val launchSuccess: Boolean?,
-)
-```
-
-* The `RocketLaunch` class is marked with the `@Serializable` annotation, so that the `kotlinx.serialization` plugin can
-  automatically generate a default serializer for it.
-* The `@SerialName` annotation allows you to redefine field names, making it possible to declare properties in data classes
-  with more readable names.
-
-### Connect HTTP client
-
-1. In `Greeting.kt`, create a Ktor `HTTPClient` instance to execute network requests and parse the resulting JSON:
-
-    ```kotlin
-    import io.ktor.client.*
-    import io.ktor.client.plugins.contentnegotiation.*
-    import io.ktor.serialization.kotlinx.json.*
-    import kotlinx.serialization.json.Json
-    
-    class Greeting {
-        private val platform: Platform = getPlatform()
-        
-        private val httpClient = HttpClient {
-            install(ContentNegotiation) {
-                json(Json {
-                    prettyPrint = true
-                    isLenient = true
-                    ignoreUnknownKeys = true
-                })
-            }
-        }
-    }
-    ```
-
-   To deserialize the result of the GET request,
-   the [ContentNegotiation Ktor plugin](https://ktor.io/docs/serialization-client.html#register_json) and the JSON
-   serializer are used.
-
-2. In the `greet()` function, retrieve the information about rocket launches by calling the `httpClient.get()`
-   method and find the latest launch:
-
-    ```kotlin
-    import io.ktor.client.call.*
-    import io.ktor.client.request.*
-
-    class Greeting {
-        // ...
-        @Throws(Exception::class)
-        suspend fun greet(): String {
-            val rockets: List<RocketLaunch> =
-                httpClient.get("https://api.spacexdata.com/v4/launches").body()
-            val lastSuccessLaunch = rockets.last { it.launchSuccess == true }
-            return "Guess what it is! > ${platform.name.reversed()}!" +
-                    "\nThere are only ${daysUntilNewYear()} left until New Year! 🎆" +
-                    "\nThe last successful launch was ${lastSuccessLaunch.launchDateUTC} 🚀"
-        }
-    }
-    ```
-
-   The `suspend` modifier in the `greet()` function is necessary because it now contains a call to `get()`. It's a
-   suspend function that has an asynchronous operation to retrieve data over the internet and can only be called from
-   within a coroutine or another suspend function. The network request will be executed in the HTTP client's thread pool.
-
-### Add internet access permission
-
-To access the internet, the Android application needs appropriate permission. Since all network requests are made from the
-shared module, it makes sense to add the internet access permission to its manifest.
-
-Update your `androidApp/src/main/AndroidManifest.xml` file with the access permission:
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.jetbrains.simplelogin.kotlinmultiplatformsandbox" >
-    <uses-permission android:name="android.permission.INTERNET"/>
-</manifest>
-```
-
-## Update Android and iOS apps
-
-You've already updated the API of the shared module by adding the `suspend` modifier to the `greet()` function. Now you
-need to update native (iOS, Android) parts of the project, so they can properly handle the result of calling the
-`greet()` function.
-
-### Android app
-
-As both the shared module and the Android application are written in Kotlin, using shared code from Android is
-straightforward:
-
-In `androidApp/src/main/java`, locate the `MainActivity.kt` file and update the following class replacing previous implementation:
-
-```kotlin
-import androidx.compose.runtime.*
-
-class MainActivity : ComponentActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContent {
-            MyApplicationTheme {
-                Surface(
-                    modifier = Modifier.fillMaxSize(),
-                    color = MaterialTheme.colors.background
-                ) {
-                    var text by remember { mutableStateOf("Loading") }
-                    LaunchedEffect(true) {
-                        text = try {
-                            Greeting().greet()
-                        } catch (e: Exception) {
-                            e.localizedMessage ?: "error"
-                        }
-                    }
-                    GreetingView(text)
-                }
-            }
-        }
-    }
-}
-```
-
-The `greet()` function is now called inside `LaunchedEffect` to avoid recalling it on each recomposition.
-
-### iOS app
-
-For the iOS part of the project, you'll make use of [SwiftUI](https://developer.apple.com/xcode/swiftui/) to build the user
-interface and the [Model–view–viewmodel](https://en.wikipedia.org/wiki/Model–view–viewmodel) pattern to connect the UI to
-the shared module, which contains all the business logic.
-
-The module is already connected to the iOS project — the Android Studio plugin wizard did all the configuration. The module
-is already imported and used in `ContentView.swift` with `import shared`.
-
-> If you see errors in Xcode regarding the shared module or when updating your code, run the **iosApp** from Android Studio.
->
-{type="tip"}
-
-1. Launch your Xcode app and select **Open a project or file**.
-2. Navigate to your project, for example **KotlinMultiplatformSandbox**, and select the `iosApp` folder. Click **Open**.
-3. In `iosApp/iOSApp.swift`, update the entry point for your app:
-   
-   ```swift
-   @main
-   struct iOSApp: App {
-       var body: some Scene {
-           WindowGroup {
-               ContentView(viewModel: ContentView.ViewModel())
-           }
-       }
-   }
-   ```
-
-4. In `iosApp/ContentView.swift`, create a `ViewModel` class for `ContentView`, which will prepare and manage data
-   for it:
-
-    ```swift
-    import SwiftUI
-    import shared
-    
-    struct ContentView: View {
-        @ObservedObject private(set) var viewModel: ViewModel
-    
-        var body: some View {
-            Text(viewModel.text)
-        }
-    }
-    
-    extension ContentView {
-        class ViewModel: ObservableObject {
-            @Published var text = "Loading..."
-            init() {
-                // Data will be loaded here
-            }
-        }
-    }
-    ```
-
-   * `ViewModel` is declared as an extension to `ContentView`, as they are closely connected.
-   * The [Combine framework](https://developer.apple.com/documentation/combine) connects the view model (`ContentView.ViewModel`)
-   with the view (`ContentView`).
-   * `ContentView.ViewModel` is declared as an `ObservableObject`.
-   * The `@Published` wrapper is used for the `text` property.
-   * The `@ObservedObject` property wrapper is used to subscribe to the view model.
-
-   Now the view model will emit signals whenever this property changes.
-
-5. Call the `greet()` function, which now also loads data from the SpaceX API, and save the result in the `text` property:
-
-    ```swift
-    class ViewModel: ObservableObject {
-        @Published var text = "Loading..."
-        init() {
-            Greeting().greet { greeting, error in
-                DispatchQueue.main.async {
-                    if let greeting = greeting {
-                        self.text = greeting
-                    } else {
-                        self.text = error?.localizedDescription ?? "error"
-                    }
-                }
-            }
-        }
-    }
-    ```
-
-   * Kotlin/Native [provides bidirectional interoperability with Objective-C](https://kotlinlang.org/docs/native-objc-interop.html#mappings), thus
-   Kotlin concepts, including `suspend` functions, are mapped to the corresponding Swift/Objective-C concepts and vice versa. When you
-   compile a Kotlin module into an Apple framework, suspending functions are available in it as functions with
-   callbacks (`completionHandler`).
-   * The `greet()` function was marked with the `@Throws(Exception::class)` annotation. So any exceptions that are
-   instances of the `Exception` class or its subclass will be propagated as `NSError`, so you can handle them in the `completionHandler`.
-   * When calling Kotlin `suspend` functions from Swift, completion handlers might be called on threads other than main,
-   see the [iOS integration](native-ios-integration.md#completion-handlers) in the Kotlin/Native memory manager.
-   That's why `DispatchQueue.main.async` is used to update `text` property.
-
-6. Re-run both **androidApp** and **iosApp** configurations from Android Studio to make sure your app's logic is synced:
-
-   ![Final results](multiplatform-mobile-upgrade.png){width="500"}
-
-> You can find this state of the project in our [GitHub repository](https://github.com/kotlin-hands-on/get-started-with-kmp).
-> 
-{type="note"}
-
-## Next step
-
-In the final part of the tutorial, you'll wrap up your project and see what steps to take next.
-
-**[Proceed to the next part](multiplatform-mobile-wrap-up.md)**
-
-### See also
-
-* Explore various approaches to [composition of suspending functions](composing-suspending-functions.md).
-* Learn more about the [interoperability with Objective-C frameworks and libraries](native-objc-interop.md).
-* Complete this tutorial on [networking and data storage](multiplatform-mobile-ktor-sqldelight.md).
-
-## Get help
-
-* **Kotlin Slack**. Get an [invite](https://surveys.jetbrains.com/s3/kotlin-slack-sign-up) and join the [#multiplatform](https://kotlinlang.slack.com/archives/C3PQML5NU) channel.
-* **Kotlin issue tracker**. [Report a new issue](https://youtrack.jetbrains.com/newIssue?project=KT).
diff --git a/docs/topics/multiplatform-mobile/multiplatform-mobile-wrap-up.md b/docs/topics/multiplatform-mobile/multiplatform-mobile-wrap-up.md
deleted file mode 100644
index 06db1a1d65c..00000000000
--- a/docs/topics/multiplatform-mobile/multiplatform-mobile-wrap-up.md
+++ /dev/null
@@ -1,64 +0,0 @@
-[//]: # (title: Wrap up your project)
-
-<microformat>
-    <p>This is final part of the <strong>Getting started with Kotlin Multiplatform for mobile</strong> tutorial. Before proceeding, make sure you've completed previous steps.</p>
-    <p><img src="icon-1-done.svg" width="20" alt="First step"/> <a href="multiplatform-mobile-setup.md">Set up an environment</a><br/><img src="icon-2-done.svg" width="20" alt="Second step"/> <a href="multiplatform-mobile-create-first-app.md">Create your first cross-platform app</a><br/><img src="icon-3-done.svg" width="20" alt="Third step"/> <a href="multiplatform-mobile-dependencies.md">Add dependencies</a><br/><img src="icon-4-done.svg" width="20" alt="Fourth step"/> <a href="multiplatform-mobile-upgrade-app.md">Upgrade your app</a><br/><img src="icon-5.svg" width="20" alt="Fifth step"/> <strong>Wrap up your project</strong></p>
-</microformat>
-
-You've created your first Multiplatform Mobile app that works both on iOS and Android! Now you know how
-to set up an environment for cross-platform mobile development, create a project in Android Studio, run your app on devices,
-and expand its functionality.
-
-Now that you've gained some experience with Kotlin Multiplatform, you can take a look at some advanced topics and take on
-additional cross-platform mobile development tasks:
-
-<table>
-   <tr>
-      <th>Next steps</th>
-      <th>Deep dive</th>
-   </tr>
-   <tr>
-   <td>
-     <list>
-        <li><a href="multiplatform-run-tests.md">Add tests to your Kotlin Multiplatform project</a></li>
-        <li><a href="multiplatform-mobile-publish-apps.md">Publish your mobile application to app stores</a></li>
-        <li><a href="multiplatform-mobile-introduce-your-team.md">Introduce cross-platform mobile development to your team</a></li>
-        <li><a href="https://github.com/terrakok/kmm-awesome">Check out the list of useful tools and libraries</a></li>
-     </list>
-   </td>
-    <td>
-     <list>
-        <li><a href="multiplatform-mobile-understand-project-structure.md">Kotlin Multiplatform for mobile project structure</a></li>
-        <li><a href="native-objc-interop.md">Interoperability with Objective-C frameworks and libraries</a></li>
-        <li><a href="multiplatform-add-dependencies.md">Adding dependencies on multiplatform libraries</a></li>        
-        <li><a href="multiplatform-mobile-android-dependencies.md">Adding Android dependencies</a></li>
-        <li><a href="multiplatform-mobile-ios-dependencies.md">Adding iOS dependencies</a></li>
-     </list>
-   </td>
-   </tr>
-</table>
-
-<table>
-   <tr>
-      <th>Tutorials and samples</th>
-      <th>Community and feedback</th>
-   </tr>
-   <tr>
-   <td>
-     <list>
-        <li><a href="multiplatform-mobile-integrate-in-existing-app.md">Make your Android app cross-platform</a></li>
-        <li><a href="multiplatform-mobile-ktor-sqldelight.md">Create a multiplatform app using Ktor and SQLDelight</a></li>
-        <li><a href="https://github.com/JetBrains/compose-multiplatform-ios-android-template/#readme">Share UIs between iOS and Android using Compose Multiplatform</a></li>
-        <li><a href="multiplatform-mobile-samples.md">See the curated list of sample projects</a></li>
-     </list>
-   </td>
-    <td>
-     <list>
-        <li><a href="https://kotlinlang.slack.com/archives/C3PQML5NU">Join the #multiplatform channel in Kotlin Slack</a></li>
-        <li><a href="https://stackoverflow.com/questions/tagged/kotlin-multiplatform">Subscribe to the "kotlin-multiplatform" tag on Stack Overflow</a></li>        
-        <li><a href="https://www.youtube.com/playlist?list=PLlFc5cFwUnmy_oVc9YQzjasSNoAk4hk_C">Subscribe to the Kotlin YouTube channel</a></li>
-        <li><a href="https://youtrack.jetbrains.com/newIssue?project=KT">Report a problem to our issue tracker</a></li>
-     </list>
-   </td>
-   </tr>
-</table>
diff --git a/docs/topics/multiplatform/multiplatform-add-dependencies.md b/docs/topics/multiplatform/multiplatform-add-dependencies.md
index 5ef2d17d2b8..2c56aba4e4e 100644
--- a/docs/topics/multiplatform/multiplatform-add-dependencies.md
+++ b/docs/topics/multiplatform/multiplatform-add-dependencies.md
@@ -58,10 +58,10 @@ Learn how to [change the default behavior](gradle-configure-project.md#dependenc
 ### Test libraries
 
 The [`kotlin.test` API](https://kotlinlang.org/api/latest/kotlin.test/) is available for multiplatform tests. When
-you [create a multiplatform project](multiplatform-library.md), the Project Wizard automatically adds test
+you create a multiplatform project, the [project wizard](https://kmp.jetbrains.com/) automatically adds test
 dependencies to common and platform-specific source sets.
 
-If you didn't use the Project Wizard to create your project, you
+If you didn't use the project wizard to create your project, you
 can [add the dependencies manually](gradle-configure-project.md#set-dependencies-on-test-libraries).
 
 ### kotlinx libraries
diff --git a/docs/topics/multiplatform/multiplatform-configure-compilations.md b/docs/topics/multiplatform/multiplatform-configure-compilations.md
index 8c1120fb24c..51af2d44550 100644
--- a/docs/topics/multiplatform/multiplatform-configure-compilations.md
+++ b/docs/topics/multiplatform/multiplatform-configure-compilations.md
@@ -188,7 +188,7 @@ JVM versions in your final artifact, or you have already set up source sets in G
 
 ## Use Java sources in JVM compilations
 
-When [creating a project with the Project Wizard](multiplatform-library.md), Java sources are included in the compilations of
+When creating a project with the [project wizard](https://kmp.jetbrains.com/), Java sources are included in the compilations of
 the JVM target.
 
 In the build script, the following section applies the Gradle `java` plugin and configures the target to cooperate with it:
diff --git a/docs/topics/multiplatform/multiplatform-discover-project.md b/docs/topics/multiplatform/multiplatform-discover-project.md
index 513d5a2ae1e..9d65de27269 100644
--- a/docs/topics/multiplatform/multiplatform-discover-project.md
+++ b/docs/topics/multiplatform/multiplatform-discover-project.md
@@ -9,7 +9,7 @@ Discover main parts of your multiplatform project:
 
 ## Multiplatform plugin
 
-When you [create a multiplatform project](multiplatform-library.md), the Project Wizard automatically applies the `kotlin-multiplatform` Gradle 
+When you create a multiplatform project, the [project wizard](https://kmp.jetbrains.com/) automatically applies the `kotlin-multiplatform` Gradle 
 plugin in the file `build.gradle(.kts`).
 
 You can also apply it manually.
@@ -70,7 +70,7 @@ The project includes the directory `src` with Kotlin source sets, which are coll
 their resources, dependencies, and language settings. A source set can be used in Kotlin compilations for one or more 
 target platforms. 
 
-Each source set directory includes Kotlin code files (the `kotlin` directory) and `resources`. The Project Wizard creates 
+Each source set directory includes Kotlin code files (the `kotlin` directory) and `resources`. The project wizard creates 
 default source sets for the `main` and `test` compilations of the common code and all added targets. 
 
 ![Source sets](source-sets.png){width=300}
diff --git a/docs/topics/multiplatform/multiplatform-full-stack-app.md b/docs/topics/multiplatform/multiplatform-full-stack-app.md
deleted file mode 100644
index 3453dba66fd..00000000000
--- a/docs/topics/multiplatform/multiplatform-full-stack-app.md
+++ /dev/null
@@ -1,984 +0,0 @@
-[//]: # (title: Build a full-stack web app with Kotlin Multiplatform)
-
-This tutorial demonstrates how to build a connected full-stack application with IntelliJ IDEA. You will create a simple
-JSON API and learn how to use the API from a web app using Kotlin and React.
-
-The application consists of a server part using Kotlin/JVM and a web client using Kotlin/JS. Both parts will be one
-Kotlin Multiplatform project. Since the whole app will be in Kotlin, you can share libraries and programming paradigms
-(such as using Coroutines for concurrency) on both the frontend and backend.
-
-Using Kotlin throughout the whole stack also makes it possible to write classes and functions that can be used from both
-the JVM and JS targets of your application. In this tutorial, you'll primarily utilize this functionality to share a
-type-safe representation of the data between client and server.
-
-You will also use popular Kotlin multiplatform libraries and frameworks:
-
-* [`kotlinx.serialization`](https://github.com/Kotlin/kotlinx.serialization)
-* [`kotlinx.coroutines`](https://github.com/Kotlin/kotlinx.coroutines)
-* The [Ktor](https://ktor.io/) framework
-
-Serialization and deserialization to and from type-safe objects is delegated to the `kotlinx.serialization`
-multiplatform library. This helps you make data communication safe and easy to implement.
-
-The output will be a simple shopping list application that allows you to plan your grocery shopping.
-
-* The user interface will be simple: a list of planned purchases and a field to enter new shopping items.
-* If a user clicks on an item in the shopping list, it will be removed.
-* The user can also specify a priority level for list entries by adding an exclamation point `!`. This information will
-  help order the shopping list.
-
-> For this tutorial, you are expected to have an understanding of Kotlin. Some knowledge about basic concepts in React
-> and Kotlin coroutines may help understand some sample code, but it is not strictly required.
->
-{type="tip"}
-
-## Create the project
-
-Clone the [project repository](https://github.com/kotlin-hands-on/jvm-js-fullstack) from GitHub and open it in IntelliJ
-IDEA. This template already includes all of the configuration and required dependencies for all of the project parts: JVM, JS, and
-the common code.
-
-You don't need to change the Gradle configuration throughout this tutorial. If you want to get right to programming,
-feel free to move on directly to the [next section](#build-the-backend).
-
-Alternatively, you can get an understanding of the configuration and project setup in the `build.gradle.kts` file to
-prepare for other projects. Check out the sections about the Gradle structure below.
-
-#### Plugins {initial-collapse-state="collapsed"}
-
-Like all Kotlin projects targeting more than one platform, your project uses the Kotlin Multiplatform Gradle plugin. It
-provides a single point of configuration for the application targets (in this case, Kotlin/JVM and Kotlin/JS) and
-exposes several lifecycle tasks for them.
-
-Additionally, you'll need two more plugins:
-
-* The [`application`](https://docs.gradle.org/current/userguide/application_plugin.html) plugin runs the server part of
-  the application that uses JVM.
-* The [`serialization`](https://github.com/Kotlin/kotlinx.serialization#gradle) plugin provides multiplatform
-  conversions between Kotlin objects and their JSON text representation.
-
-```kotlin
-plugins {
-    kotlin("multiplatform") version "%kotlinVersion%"
-    application // to run the JVM part
-    kotlin("plugin.serialization") version "%kotlinVersion%"
-}
-```
-
-#### Targets {initial-collapse-state="collapsed"}
-
-The target configuration inside the `kotlin` block is responsible for setting up the platforms you want to support with
-your project. Configure two targets: `jvm` (server) and `js` (client). Here you'll make further adjustments to target
-configurations.
-
-```kotlin
-jvm {
-    withJava()
-}
-js {
-    browser {
-        binaries.executable()
-    }
-}
-```
-
-For more detailed information on targets, see [Understand Multiplatform project structure](multiplatform-discover-project.md#targets).
-
-#### Source sets {initial-collapse-state="collapsed"}
-
-Kotlin source sets are a collection of Kotlin sources and their resources, dependencies, and language settings that
-belong to one or more targets. You use them to set up platform-specific and common dependency blocks.
-
-```kotlin
-sourceSets {
-    val commonMain by getting {
-        dependencies {
-            // ...
-        }
-    }
-    val jvmMain by getting {
-        dependencies {
-            // ...
-        }
-    }
-    val jsMain by getting {
-        dependencies {
-            // ...
-        }
-    }
-}
-```
-
-Each source set also corresponds to a folder in the `src` directory. In your project, there are three
-folders, `commonMain`, `jsMain`, and `jvmMain`, which contain their own `resources` and `kotlin` folders.
-
-For detailed information on source sets, see [Understand Multiplatform project structure](multiplatform-discover-project.md#source-sets).
-
-## Build the backend
-
-Let's begin by writing the server side of the application. The typical API server implements
-the [CRUD operations](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) – create, read, update, and delete.
-For the simple shopping list, you can focus solely on:
-
-* Creating new entries in the list
-* Reading entries using the API
-* Deleting entries
-
-To create the backend, you can use the Ktor framework, designed to build asynchronous servers and clients in connected
-systems. It can be set up quickly and grow as systems become more complex.
-
-You can find more information about Ktor in its [documentation](https://ktor.io/docs/welcome.html).
-
-### Run the embedded server
-
-Instantiate a server with Ktor. You need to tell
-the [embedded server](https://ktor.io/docs/create-server.html#embedded-server) that ships with Ktor to use the `Netty`
-engine on a port, in this case, `9090`.
-
-1. To define the entry point for the app, add the following code to `src/jvmMain/kotlin/Server.kt`:
-
-    ```kotlin
-    import io.ktor.http.*
-    import io.ktor.serialization.kotlinx.json.*
-    import io.ktor.server.engine.*
-    import io.ktor.server.netty.*
-    import io.ktor.server.application.*
-    import io.ktor.server.plugins.compression.*
-    import io.ktor.server.plugins.contentnegotiation.*
-    import io.ktor.server.plugins.cors.routing.*
-    import io.ktor.server.request.*
-    import io.ktor.server.response.*
-    import io.ktor.server.http.content.*
-    import io.ktor.server.routing.*
-    
-    fun main() {
-        embeddedServer(Netty, 9090) {
-            routing {
-                get("/hello") {
-                    call.respondText("Hello, API!")
-                }
-            }
-        }.start(wait = true)
-    }
-    ```
-
-    * The first API endpoint is an HTTP method, `get`, and the route under which it should be reachable, `/hello`.
-    * All imports that are needed for the rest of the tutorial have already been added.
-
-2. To start the application and see that everything works, execute the Gradle `run` task. You can use
-   the `./gradlew run` command in the terminal or run from the Gradle tool window:
-
-    ![Execute the Gradle run task](gradle-run-task.png){width=700}
-
-3. Once the application has finished compiling and the server has started up, use a web browser to navigate
-   to [`http://localhost:9090/hello`](http://localhost:9090/hello) to see the first route in action:
-
-    ![Hello, API output](hello-api-output.png){width=500}
-
-Later, like with the endpoint for GET requests to `/hello`, you'll be able to configure all of the endpoints for the API inside
-the [`routing`](https://ktor.io/docs/routing-in-ktor.html) block.
-
-### Install Ktor plugins
-
-Before continuing with the application development, install the required [plugins](https://ktor.io/docs/plugins.html) for the
-embedded servers. Ktor uses plugins to enable support for more features in the application like encoding, compression,
-logging, and authentication.
-
-Add the following lines to the top of the `embeddedServer` block in `src/jvmMain/kotlin/Server.kt`:
-
-```kotlin
-install(ContentNegotiation) {
-    json()
-}
-install(CORS) {
-    allowMethod(HttpMethod.Get)
-    allowMethod(HttpMethod.Post)
-    allowMethod(HttpMethod.Delete)
-    anyHost()
-}
-install(Compression) {
-    gzip()
-}
-routing {
-    // ...
-}
-```
-
-Each call to `install` adds one feature to the Ktor application:
-
-* [`ContentNegotiation`](https://ktor.io/docs/serialization.html) provides automatic content conversion of requests
-  based on their `Content-Type` and `Accept` headers. Together with the `json()` setting, this enables automatic
-  serialization and deserialization to and from JSON, allowing you to delegate this task to the framework.
-* [`CORS`](https://ktor.io/docs/cors.html)
-  configures [Cross-Origin Resource Sharing](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). CORS is needed to
-  make calls from arbitrary JavaScript clients and helps prevent issues later.
-* [`Compression`](https://ktor.io/docs/compression.html) greatly reduces the amount of data to be sent to the client
-  by gzipping outgoing content when applicable.
-
-#### Related Gradle configuration for Ktor {initial-collapse-state="collapsed"}
-
-The artifacts required to use Ktor are a part of the `jvmMain` `dependencies` block in the `build.gradle.kts` file. This
-includes the server, logging, and supporting libraries for providing type-safe serialization support
-through `kotlinx.serialization`.
-
-```kotlin
-val jvmMain by getting {
-    dependencies {
-        implementation("io.ktor:ktor-serialization:$ktorVersion")
-        implementation("io.ktor:ktor-server-content-negotiation:$ktorVersion")
-        implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
-        implementation("io.ktor:ktor-server-cors:$ktorVersion")
-        implementation("io.ktor:ktor-server-compression:$ktorVersion")
-        implementation("io.ktor:ktor-server-core-jvm:$ktorVersion")
-        implementation("io.ktor:ktor-server-netty:$ktorVersion")
-        implementation("ch.qos.logback:logback-classic:$logbackVersion")
-        implementation("org.litote.kmongo:kmongo-coroutine-serialization:$kmongoVersion")
-    }
-}
-```
-
-`kotlinx.serialization` and its integration with Ktor also requires a few common artifacts to be present, which you can
-find in the `commonMain` source set:
-
-```kotlin
-val commonMain by getting {
-    dependencies {
-        implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$serializationVersion")
-        implementation("io.ktor:ktor-client-core:$ktorVersion")
-    }
-}
-```
-
-### Create a data model
-
-Thanks to Kotlin Multiplatform, you can define the data model once as a common abstraction and refer to it from both the
-backend and frontend.
-
-The data model for `ShoppingListItem` should have:
-
-* A textual description of an item
-* A numeric priority for an item
-* An identifier
-
-In `src/commonMain/`, create a `kotlin/ShoppingListItem.kt` file with the following content:
-
-```kotlin
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class ShoppingListItem(val desc: String, val priority: Int) {
-    val id: Int = desc.hashCode()
-
-    companion object {
-        const val path = "/shoppingList"
-    }
-}
-```
-
-* The `@Serializable` annotation comes from the multiplatform `kotlinx.serialization` library, which allows you to define
-  models directly in common code.
-* Once you use this serializable `ShoppingListItem` class from the JVM and JS platforms, code for each platform will be
-  generated. This code takes care of serialization and deserialization.
-* The `companion object` stores additional information about the model − in this case, the `path` under which you will
-  be able to access it in the API. By referring to this variable instead of defining routes and requests as strings, you
-  can change the `path` to model operations. Any changes to the endpoint name only need to be made here - the client and
-  server are adjusted automatically.
-
-> This sample computes a simple `id` from the `hashCode()` of its description. In this case, that's enough, but when working
-> with real data, it would be preferable to include tried and tested mechanisms to generate identifiers for your objects –
-> from [UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier) to auto-incrementing IDs backed by the database of your choice.
->
-{type="tip"}
-
-### Add items to store
-
-You can now use the `ShoppingListItem` model to instantiate some sample items and keep track of any additions or
-deletions made through the API.
-
-Because there's currently no database, create a `MutableList` to temporarily store the `ShoppingListItem`s. For that,
-add the following file-level declaration to `src/jvmMain/kotlin/Server.kt`:
-
-```kotlin
-val shoppingList = mutableListOf(
-    ShoppingListItem("Cucumbers 🥒", 1),
-    ShoppingListItem("Tomatoes 🍅", 2),
-    ShoppingListItem("Orange Juice 🍊", 3)
-)
-```
-
-The `common` classes are referred to as any other class in Kotlin – they are shared between all of the targets.
-
-### Create routes for the JSON API
-
-Add the routes that support the creation, retrieval, and deletion of `ShoppingListItem`s.
-
-1. Inside `src/jvmMain/kotlin/Server.kt`, change your `routing` block to look as follows:
-
-    ```kotlin
-    routing {
-        route(ShoppingListItem.path) {
-            get {
-                call.respond(shoppingList)
-            }
-            post {
-                shoppingList += call.receive<ShoppingListItem>()
-                call.respond(HttpStatusCode.OK)
-            }
-            delete("/{id}") {
-                val id = call.parameters["id"]?.toInt() ?: error("Invalid delete request")
-                shoppingList.removeIf { it.id == id }
-                call.respond(HttpStatusCode.OK)
-            }
-        }
-    }
-    ```
-
-    Routes are grouped based on a common path. You don't have to specify the `route` path as a `String`. Instead,
-    the `path` from the `ShoppingListItem` model is used. The code behaves as follows:
-    * A `get` request to the model's path (`/shoppingList`) responds with the whole shopping list.
-    * A `post` request to the model's path (`/shoppingList`) adds an entry to the shopping list.
-    * A `delete` request to the model's path and a provided `id` (`shoppingList/47`) removes an entry from the
-      shopping list.
-
-    > You can receive objects directly from requests and respond to requests with objects (and even lists of
-    > objects) directly. Because you've set up `ContentNegotiation` with `json()` support earlier, the objects marked
-    > as `@Serializable` are automatically turned into JSON before being sent (in case of a GET request) or received
-    > (in case of a POST request).
-    >
-    {type="note"}
-
-2. Check to ensure that everything is working as planned. Restart the application, head
-   to [`http://localhost:9090/shoppingList`](http://localhost:9090/shoppingList), and validate that the data is properly
-   served. You should see the example items in JSON formatting:
-
-    ![Shopping list in JSON formatting](shopping-list-json.png){width=500}
-
-To test the `post` and `delete` requests, use an HTTP client that supports `.http` files. If you're
-using IntelliJ IDEA Ultimate Edition, you can do this right from the IDE.
-
-1. In the project root, create a file called `AddShoppingListElement.http` and add a declaration of the HTTP POST request as follows:
-
-    ```http
-    POST http://localhost:9090/shoppingList
-    Content-Type: application/json
-    
-    {
-      "desc": "Peppers 🌶",
-      "priority": 5
-    }
-    ```
-
-2. With the server running, execute the request using the run button in the gutter.
-
-   If everything goes well, the "run" tool window should show `HTTP/1.1 200 OK`, and you can
-   visit [`http://localhost:9090/shoppingList`](http://localhost:9090/shoppingList) again to validate that the entry has been
-   added properly:
-
-    ![Successful connection to localhost](connection-to-localhost.png){width=700}
-
-3. Repeat this process for a file called `DeleteShoppingListElement.http`, which contains the following:
-
-    ```http
-    DELETE http://localhost:9090/shoppingList/AN_ID_GOES_HERE
-    ```
-
-   To try this request, replace `AN_ID_GOES_HERE` with an existing ID.
-
-Now you have a backend that can support all of the necessary operations for a functional shopping list. Move on to building a
-JavaScript frontend for the application, which will allow users to easily inspect, add, and check off elements from
-their shopping list.
-
-## Set up the frontend
-
-To make your version of the server usable, build a small Kotlin/JS web app that can query the server's API, display them
-in the form of a list, and allow the user to add and remove elements.
-
-### Serve the frontend
-
-Unless explicitly configured otherwise, a Kotlin Multiplatform project just means that you can build the application for
-each platform, in this case JVM and JavaScript. However, for the application to function properly, you need to have
-both the backend and the frontend compiled. In fact, you want the backend to also serve all of the assets belonging to the
-frontend – an HTML page and the corresponding `.js` file.
-
-In the template project, the adjustments to the Gradle file have already been made.
-Whenever you run the server with the `run` Gradle task, the frontend is also built and included in the resulting
-artifacts. To learn more about how this works, see the [Relevant Gradle configuration](#relevant-gradle-configuration-for-the-frontend)
-section.
-
-The template already comes with a boilerplate `index.html` file in the `src/commonMain/resources` folder. It has
-a `root` node for rendering components and a `script` tag that includes the application:
-
-```xml
-<!DOCTYPE html>
-<html lang="en">
-    <head>
-        <meta charset="UTF-8">
-        <title>Full Stack Shopping List</title>
-    </head>
-    <body>
-        <div id="root"></div>
-        <script src="shoppinglist.js"></script>
-    </body>
-</html>
-```
-{validate="false"}
-
-This file is placed in the `common` resources instead of a `jvm` source set to make tasks for running the JS application
-in the browser (`jsBrowserDevelopmentRun` and `jsBrowserProductionRun`) accessible to the file as well. It's helpful if
-you need to run only the browser application without the backend.
-
-While you don't need to make sure that the file is properly available on the server, you still need to instruct Ktor to
-provide the `.html` and `.js` files to the browser when requested.
-
-#### Relevant Gradle configuration for the frontend {initial-collapse-state="collapsed"}
-
-The Gradle configuration for the application contains a snippet that makes the execution and packaging of the
-server-side JVM application dependent on the build of your frontend application while respecting the settings
-regarding `development` and `production` from the environment variable. It makes sure that whenever a `jar` file is
-built from the application, it includes the Kotlin/JS code:
-
-```kotlin
-// include JS artifacts in any generated JAR
-tasks.getByName<Jar>("jvmJar") {
-    val taskName = if (project.hasProperty("isProduction")
-        || project.gradle.startParameter.taskNames.contains("installDist")
-    ) {
-        "jsBrowserProductionWebpack"
-    } else {
-        "jsBrowserDevelopmentWebpack"
-    }
-    val webpackTask = tasks.getByName<KotlinWebpack>(taskName)
-    dependsOn(webpackTask) // make sure JS gets compiled first
-    from(File(webpackTask.destinationDirectory, webpackTask.outputFileName)) // bring output file along into the JAR
-}
-```
-
-The `jvmJar` task modified here is called by the `application` plugin, which is responsible for the `run` task, and
-the `distributions` plugin, which is responsible for the `installDist` task, amongst others. This means that the
-combined build will work when you `run` your application, and also when you prepare it for deployment to another target
-system or cloud platform.
-
-To ensure that the `run` task properly recognizes the JS artifacts, the classpath is adjusted as follows:
-
-```kotlin
-tasks.getByName<JavaExec>("run") {
-    classpath(tasks.getByName<Jar>("jvmJar")) // so that the JS artifacts generated by `jvmJar` can be found and served
-}
-```
-
-### Serve HTML and JavaScript files from Ktor
-
-For simplicity, the `index.html` file will be served on the root route `/` and expose the JavaScript artifact in the
-root directory.
-
-1. In `src/jvmMain/kotlin/Server.kt`, add the corresponding routes to the `routing` block:
-
-    ```kotlin
-    get("/") {
-        call.respondText(
-            this::class.java.classLoader.getResource("index.html")!!.readText(),
-            ContentType.Text.Html
-        )
-    }
-    staticResources("/", "static")
-    route(ShoppingListItem.path) {
-        // ...
-    }
-    ```
-
-2. To confirm that everything went as planned, run the application again with the Gradle `run` task.
-3. Navigate to [`http://localhost:9090/`](http://localhost:9090/). You should see a page saying "Hello, Kotlin/JS":
-
-    ![Hello, Kotlin/JS output](hello-kotlin-js-output.png){width=500}
-
-### Edit configuration
-
-While you are developing, the build system generates _development_ artifacts. This means that no optimizations are
-applied when the Kotlin code is turned into JavaScript. That makes compile times faster but also results in larger JS
-files. When you deploy your application to the web, this is something you want to avoid.
-
-To instruct Gradle to generate optimized production assets, set the necessary environment
-variable. If you are running your application on a deployment system, you can
-configure it to set this environment variable during the build. If you want to try out production mode locally, you can
-do it in the terminal or by adding the variable to the run configuration:
-
-1. In IntelliJ IDEA, select the **Edit Configurations** action:
-
-    ![Edit run configuration in IntelliJ IDEA](edit-run-configurations.png){width=700}
-
-2. In the **Run/Debug Configurations** menu, set the environment variable:
-
-    ```none
-    ORG_GRADLE_PROJECT_isProduction=true
-    ```
-
-    ![Set the environment variable](set-environment-variable.png){width=700}
-
-Subsequent builds with this run configuration will perform all available optimizations for the frontend part of the
-application, including eliminating dead code. They will still be slower than development builds, so it would be good to
-remove this flag again while you are developing.
-
-## Build the frontend
-
-To render and manage user interface elements, use the popular framework [React](https://reactjs.org/) together with the
-available [wrappers](https://github.com/JetBrains/kotlin-wrappers/) for Kotlin. Setting up a full project with React
-will allow you to re-use it and its configuration as a starting point for more complex multiplatform
-applications.
-
-For a more in-depth view of typical workflows and how apps are developed with React and Kotlin/JS, see
-the [Build a web application with React and Kotlin/JS](js-react.md) tutorial.
-
-### Write the API client
-
-To display data, you need to obtain it from the server. For this, build a small API client.
-
-This API client will use the [`ktor-clients`](https://ktor.io/clients/index.html) library to send requests to HTTP
-endpoints. Ktor clients use Kotlin's coroutines to provide non-blocking networking and support plugins like the Ktor
-server.
-
-In this configuration, the `JsonFeature` uses `kotlinx.serialization` to provide a way to create typesafe HTTP requests.
-It takes care of automatically converting between Kotlin objects and their JSON representation and vice versa.
-
-By leveraging these properties, you can create an API wrapper as a set of suspending functions that either accept or
-return `ShoppingItems`. Create a file called `Api.kt` and implement them in `src/jsMain/kotlin`:
-
-```kotlin
-import io.ktor.http.*
-import io.ktor.client.*
-import io.ktor.client.call.*
-import io.ktor.client.plugins.contentnegotiation.*
-import io.ktor.client.request.*
-import io.ktor.serialization.kotlinx.json.*
-
-val jsonClient = HttpClient {
-    install(ContentNegotiation) {
-        json()
-    }
-}
-
-suspend fun getShoppingList(): List<ShoppingListItem> {
-    return jsonClient.get(ShoppingListItem.path).body()
-}
-
-suspend fun addShoppingListItem(shoppingListItem: ShoppingListItem) {
-    jsonClient.post(ShoppingListItem.path) {
-        contentType(ContentType.Application.Json)
-        setBody(shoppingListItem)
-    }
-}
-
-suspend fun deleteShoppingListItem(shoppingListItem: ShoppingListItem) {
-    jsonClient.delete(ShoppingListItem.path + "/${shoppingListItem.id}")
-}
-```
-
-### Build the user interface
-
-You've laid the groundwork on the client and have a clean API to access the data provided by the server. Now you can
-work on displaying the shopping list on the screen in a React application.
-
-#### Configure an entry point for the application
-
-Instead of rendering a simple "Hello, Kotlin/JS" string, make the application render a functional `App` component. For
-that, replace the content inside `src/jsMain/kotlin/Main.kt` with the following:
-
-```kotlin
-import web.dom.document
-import react.create
-import react.dom.client.createRoot
-
-fun main() {
-    val container = document.getElementById("root") ?: error("Couldn't find container!")
-    createRoot(container).render(App.create())
-}
-```
-
-#### Build and render the shopping list
-
-Next, implement the `App` component. For the shopping list application, it needs to:
-
-* Keep the "local state" of the shopping list to understand which elements to display.
-* Load the shopping list elements from the server and set the state accordingly.
-* Provide React with instructions on how to render the list.
-
-Based on these requirements, you can implement the `App` component as follows:
-
-1. Create and fill the `src/jsMain/kotlin/App.kt` file:
-
-    ```kotlin
-    import react.*
-    import kotlinx.coroutines.*
-    import react.dom.html.ReactHTML.h1
-    import react.dom.html.ReactHTML.li
-    import react.dom.html.ReactHTML.ul
-    
-    private val scope = MainScope()
-    
-    val App = FC<Props> {
-        var shoppingList by useState(emptyList<ShoppingListItem>())
-    
-        useEffectOnce {
-            scope.launch {
-                shoppingList = getShoppingList()
-            }
-        }
-    
-        h1 {
-            +"Full-Stack Shopping List"
-        }
-        ul {
-            shoppingList.sortedByDescending(ShoppingListItem::priority).forEach { item ->
-                li {
-                    key = item.toString()
-                    +"[${item.priority}] ${item.desc} "
-                }
-            }
-        }
-    }
-    ```
-
-    * Here, the Kotlin DSL is used to define the HTML representation of the application.
-    * `launch` is used to obtain the list of `ShoppingListItem`s from the API when the component is first initialized.
-    * The React hooks `useEffectOnce` and `useState` help you use React's functionality concisely. For more information on how
-      React hooks work, check out the [official React documentation](https://reactjs.org/docs/hooks-overview.html). To learn
-      more about React with Kotlin/JS, see the [Build a web application with React and Kotlin/JS](js-react.md) tutorial.
-2. Start the application using the Gradle `run` task.
-3. Navigate to [`http://localhost:9090/`](http://localhost:9090/) to see the list:
-
-    ![New shopping list rendering](new-shopping-list-rendering.png){width=500}
-
-#### Add an input field component
-
-Next, allow users to add new entries to the shopping list using a text input field. You'll need an input component that
-provides a callback when users submit their entry to the shopping list to receive input.
-
-1. Create the `src/jsMain/kotlin/InputComponent.kt` file and fill it with the following definition:
-
-    ```kotlin
-    import web.html.HTMLFormElement
-    import react.*
-    import web.html.HTMLInputElement
-    import react.dom.events.ChangeEventHandler
-    import react.dom.events.FormEventHandler
-    import web.html.InputType
-    import react.dom.html.ReactHTML.form
-    import react.dom.html.ReactHTML.input
-    
-    external interface InputProps : Props {
-        var onSubmit: (String) -> Unit
-    }
-    
-    val inputComponent = FC<InputProps> { props ->
-        val (text, setText) = useState("")
-    
-        val submitHandler: FormEventHandler<HTMLFormElement> = {
-            it.preventDefault()
-            setText("")
-            props.onSubmit(text)
-        }
-    
-        val changeHandler: ChangeEventHandler<HTMLInputElement> = {
-            setText(it.target.value)
-        }
-    
-        form {
-            onSubmit = submitHandler
-            input {
-                type = InputType.text
-                onChange = changeHandler
-                value = text
-            }
-        }
-    }
-    ```
-
-   The `inputComponent` keeps track of its internal state (what the user has typed so far) and exposes an `onSubmit`
-   handler that gets called when the user submits the form (usually by pressing the `Enter` key).
-
-2. To use this `inputComponent` from the application, add the following snippet to `src/jsMain/kotlin/App.kt` at the
-   bottom of the `FC` block (after the closing brace for the `ul` element):
-
-    ```kotlin
-    inputComponent {
-        onSubmit = { input ->
-            val cartItem = ShoppingListItem(input.replace("!", ""), input.count { it == '!' })
-            scope.launch {
-                addShoppingListItem(cartItem)
-                shoppingList = getShoppingList()
-            }
-        }
-    }
-    ```
-
-    * When users submit text, a new `ShoppingListItem` is created. Its priority is set to be the number of exclamation
-      points in the input, and its description is the input with all exclamation points removed. This turns `Peaches!! 🍑`
-      into a `ShoppingListItem(desc="Peaches 🍑", priority=2)`.
-    * The generated `ShoppingListItem` gets sent to the server with the client you've built before.
-    * Then, the UI is updated by obtaining the new list of `ShoppingListItem`s from the server, updating the application
-      state, and letting React re-render the contents.
-
-#### Implement item removal
-
-Add the ability to remove the finished items from the list so that it doesn't get too long.
-Instead of adding another UI element (like a "delete" button), you can allow users to delete an item by clicking it.
-
-To achieve this, pass a corresponding handler to `onClick` of the list elements:
-
-1. In `src/jsMain/kotlin/App.kt`, update the `li` block (inside the `ul` block):
-
-    ```kotlin
-    li {
-        key = item.toString()
-        onClick = {
-            scope.launch {
-                deleteShoppingListItem(item)
-                shoppingList = getShoppingList()
-            }
-        }
-        +"[${item.priority}] ${item.desc} "
-    }
-    ```
-
-    The API client is invoked along with the element that should be removed. The server updates the shopping list, which
-    re-renders the user interface.
-
-2. Start the application using the Gradle `run` task.
-3. Navigate to [`http://localhost:9090/`](http://localhost:9090/), and try adding and removing elements from the list:
-
-    ![Final shopping list](finished-shopping-list.gif){width=500}
-
-## Include a database to store data
-
-Currently, the application doesn't save data, meaning that the shopping list vanishes when you terminate
-the server process. To fix that, use the MongoDB database to store and retrieve shopping list items even when
-the server shuts down.
-
-MongoDB is simple, fast to set up, has library support for Kotlin, and provides simple, [NoSQL](https://en.wikipedia.org/wiki/NoSQL)
-document storage, which is more than enough for a basic application. You are free to equip your application with a different
-mechanism for data storage.
-
-To provide all of the functionality used in this section, you'll need to include several libraries from the Kotlin and
-JavaScript (npm) ecosystems. See the `jsMain` dependency block in the `build.gradle.kts` file with the full setup.
-
-### Set up MongoDB
-
-Install MongoDB Community Edition on your local machine from the [official MongoDB website](https://docs.mongodb.com/manual/installation/#mongodb-community-edition-installation-tutorials).
-Alternatively, you can use a containerization tool like [podman](https://podman.io/) to run a containerized instance of MongoDB.
-
-After installation, ensure that you are running the `mongodb-community` service for the rest of the tutorial. You'll use
-it to store and retrieve list entries.
-
-### Include KMongo in the process
-
-[KMongo](https://litote.org/kmongo/) is a community-created Kotlin framework that makes it easy to work with MongoDB
-from Kotlin/JVM code. It also works nicely with `kotlinx.serialization`, which is used to facilitate communication
-between client and server.
-
-By making the code use an external database, you no longer need to keep a collection of `shoppingListItems` on the
-server. Instead, set up a database client and obtain a database and a collection from it.
-
-1. Inside `src/jvmMain/kotlin/Server.kt`, remove the declaration for `shoppingList` and add the following three
-   top-level variables:
-
-    ```kotlin
-    val client = KMongo.createClient().coroutine
-    val database = client.getDatabase("shoppingList")
-    val collection = database.getCollection<ShoppingListItem>()
-    ```
-
-2. In `src/jvmMain/kotlin/Server.kt`, replace definitions for the GET, POST, and DELETE routes to a `ShoppingListItem`
-   to make use of the available collection operations:
-
-    ```kotlin
-    get {
-        call.respond(collection.find().toList())
-    }
-    post {
-        collection.insertOne(call.receive<ShoppingListItem>())
-        call.respond(HttpStatusCode.OK)
-    }
-    delete("/{id}") {
-        val id = call.parameters["id"]?.toInt() ?: error("Invalid delete request")
-        collection.deleteOne(ShoppingListItem::id eq id)
-        call.respond(HttpStatusCode.OK)
-    }
-    ```
-
-    In the DELETE request, KMongo's [type-safe queries](https://litote.org/kmongo/typed-queries/) are used to
-    obtain and remove the correct `ShoppingListItem` from the database.
-
-3. Start the server using the `run` task, and navigate to [`http://localhost:9090/`](http://localhost:9090/). On the first
-   start, you'll be greeted by an empty shopping list as is expected when querying an empty database.
-4. Add some items to your shopping list. The server will save them to the database.
-5. To check this, restart the server and reload the page.
-
-### Inspect MongoDB
-
-To see what kind of information is actually saved in the database, you can inspect the database using external tools.
-
-If you have IntelliJ IDEA Ultimate Edition or DataGrip, you can inspect the database contents with these tools.
-Alternatively, you can use the [`mongosh`](https://www.mongodb.com/docs/mongodb-shell/) command-line client.
-
-1. To connect to the local MongoDB instance, in IntelliJ IDEA Ultimate or
-   DataGrip, go to the **Database** tab and select **+** | **Data Source** | **MongoDB**:
-
-    ![Create a MongoDB data source](mongodb-data-source.png){width=700}
-
-2. If it's your first time connecting to a MongoDB database this way, you might be prompted to download missing drivers:
-
-    ![Download missing drivers for MongoDB](download-missing-drivers.png){width=700}
-
-3. When working with a local MongoDB installation that uses the default settings, no adjustments to the
-   configuration are necessary.
-   You can test the connection with the **Test Connection** button, which should output the MongoDB version and some
-   additional information.
-
-4. Click **OK**. Now you can use the **Database** window to navigate to your collection and look at everything stored in it:
-
-    ![Use the Database tool for collection analysis](database-tool.png){width=700}
-
-#### Relevant Gradle configuration for Kmongo {initial-collapse-state="collapsed"}
-
-Kmongo is added with a single dependency to the project, a specific version that includes coroutine and serialization
-support out of the box:
-
-```kotlin
-val jvmMain by getting {
-    dependencies {
-        // ...
-        implementation("org.litote.kmongo:kmongo-coroutine-serialization:$kmongoVersion")
-    }
-}
-```
-
-## Deploy to the cloud
-
-Instead of opening your app on `localhost`, you can bring it onto the web by deploying it to the cloud.
-
-To get the application running on managed infrastructure (such as cloud providers), you need to integrate it with the
-environment variables provided by the selected platform and add any required configurations to the project. Specifically,
-pass the application port and MongoDB connection string.
-
-> During application deployment, you might need to change the firewall rules to allow the application to access the
-> database. For more details, see the [MongoDB documentation](https://docs.atlas.mongodb.com/security/ip-access-list/).
->
-{type="note"}
-
-### Specify the PORT variable
-
-On managed platforms, the port on which the application should run is often determined externally and exposed through
-the `PORT` environment variable. If present, you can respect this setting by configuring `embeddedServer`
-in `src/jvmMain/kotlin/Server.kt`:
-
-```kotlin
-fun main() {
-    val port = System.getenv("PORT")?.toInt() ?: 9090
-    embeddedServer(Netty, port) {
-        // ...
-    }
-}
-```
-
-Ktor also supports configuration files that can respect environment variables. To learn more about how to use them,
-check out the [official documentation](https://ktor.io/docs/configurations.html#hocon-overview).
-
-### Specify the MONGODB_URI variable
-
-Managed platforms often expose connection strings through environment variables – for MongoDB, this might be
-the `MONGODB_URI` string, which needs to be used by the client to connect to the database. Depending on the specific
-MongoDB instance you're trying to connect to, you might need to append the `retryWrites=false` parameter to the connection
-string.
-
-To properly satisfy these requirements, instantiate the `client` and `database` variables
-in `src/jvmMain/kotlin/Server.kt`:
-
-```kotlin
-val connectionString: ConnectionString? = System.getenv("MONGODB_URI")?.let {
-    ConnectionString("$it?retryWrites=false")
-}
-
-val client =
-    if (connectionString != null) KMongo.createClient(connectionString).coroutine else KMongo.createClient().coroutine
-val database = client.getDatabase(connectionString?.database ?: "shoppingList")
-```
-
-This ensures that the `client` is created based on this information whenever the environment variables are set.
-Otherwise (for instance, on `localhost`), the database connection is instantiated as before.
-
-### Create the Procfile
-
-Managed cloud platforms like Heroku or PaaS implementations like [Dokku](https://github.com/dokku/dokku) also handle
-the lifecycle of your application. To do so, they require an "entry point" definition. These two platforms use
-a file called `Procfile` that you have in the project root directory. It points to the output generated by the `stage` task
-(which is included in the Gradle template already):
-
-```shell
-web: ./build/install/shoppingList/bin/shoppingList
-```
-
-### Turn on production mode
-
-To turn on a compilation with optimizations for the JavaScript assets, pass another flag to the build
-process. In the **Run/Debug Configurations** menu, set the environment variable `ORG_GRADLE_PROJECT_isProduction` to `true`.
-You can set this environment variable when you deploy the application to the target environment.
-
-> You can find the finished application on GitHub on the [`final` branch](https://github.com/kotlin-hands-on/jvm-js-fullstack/tree/final).
->
-{type="note"}
-
-#### Relevant Gradle configuration {initial-collapse-state="collapsed"}
-
-The `stage` task is an alias for `installDist`:
-
-```kotlin
-// Alias "installDist" as "stage" (for cloud providers)
-tasks.create("stage") {
-    dependsOn(tasks.getByName("installDist"))
-}
-
-// only necessary until https://youtrack.jetbrains.com/issue/KT-37964 is resolved
-distributions {
-    main {
-        contents {
-            from("$buildDir/libs") {
-                rename("${rootProject.name}-jvm", rootProject.name)
-                into("lib")
-            }
-        }
-    }
-}
-```
-
-## What's next
-
-#### Add more features {initial-collapse-state="collapsed"}
-
-See how your application can be expanded and improved:
-
-* **Improve the design**. You could make use of `styled-components`, one of the libraries that have Kotlin wrappers
-  provided. If you want to see `styled-components` in action, look at
-  the [Build a web application with React and Kotlin/JS](js-react.md) tutorial.
-* **Add crossing out list items**. For now, list items just vanish with no record of them existing. Instead of deleting
-  an element, use ~~crossing out~~.
-* **Implement editing**. So far, an entry in the shopping list can't be edited. Consider adding an edit button.
-
-#### Join the community and get help {initial-collapse-state="collapsed"}
-
-You can join the official Kotlin Slack channels, [#ktor](https://slack-chats.kotlinlang.org/c/ktor), [#javascript](https://slack-chats.kotlinlang.org/c/javascript),
-and others to get help with Kotlin related problems from the community.
-
-#### Learn more about Kotlin/JS {initial-collapse-state="collapsed"}
-
-You can find additional learning materials targeting
-Kotlin/JS: [Set up a Kotlin/JS project](js-project-setup.md) and [Run Kotlin/JS](running-kotlin-js.md).
-
-#### Learn more about Ktor {initial-collapse-state="collapsed"}
-
-For in-depth information about the Ktor framework, including demo projects, check out [ktor.io](https://ktor.io/).
-
-If you run into trouble, check out the [Ktor issue tracker](https://youtrack.jetbrains.com/issues/KTOR) on YouTrack –
-and if you can't find your problem, don't hesitate to file a new issue.
-
-#### Learn more about Kotlin Multiplatform {initial-collapse-state="collapsed"}
-
-Learn more about how [multiplatform code works in Kotlin](multiplatform.md).
diff --git a/docs/topics/multiplatform/multiplatform-get-started.md b/docs/topics/multiplatform/multiplatform-get-started.md
index 2d93a80d454..a01e533cd6f 100644
--- a/docs/topics/multiplatform/multiplatform-get-started.md
+++ b/docs/topics/multiplatform/multiplatform-get-started.md
@@ -1,11 +1,6 @@
 [//]: # (title: Get started with Kotlin Multiplatform)
 [//]: # (description: Learn how to create your first Kotlin cross-platform app or library benefiting from Kotlin Multiplatform.)
 
-> Kotlin Multiplatform is in [Beta](components-stability.md). It is almost stable, but migration steps may be required
-> in the future. We'll do our best to minimize any changes you have to make.
->
-{type="note"}
-
 Support for multiplatform programming is one of Kotlin's key benefits. It reduces time spent writing and maintaining the 
 same code for [different platforms](multiplatform-dsl-reference.md#targets) while retaining the flexibility and benefits of native programming.   
 
@@ -13,13 +8,10 @@ Learn more about [Kotlin Multiplatform benefits](multiplatform.md).
 
 ## Start from scratch
 
-* [Create and publish a multiplatform library](multiplatform-library.md). Complete a project for JVM, web,
-  and native platforms, which can be used from any other common code (for example, shared with Android and iOS).
-  Learn how to write tests that can be executed on all platforms and use an efficient implementation provided by a specific platform.
-* [Get started with Kotlin Multiplatform for mobile](multiplatform-mobile-getting-started.md). Create your first cross-platform 
+* [Get started with Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html). Create your first cross-platform 
   application that works on Android and iOS with the help of the [Kotlin Multiplatform Mobile plugin for Android Studio](https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform-mobile).
   Learn how to create, run, and add dependencies to multiplatform mobile applications.
-* [Share UIs between iOS and Android](https://github.com/JetBrains/compose-multiplatform-ios-android-template/#readme).
+* [Share UIs between iOS and Android](https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-multiplatform-getting-started.html).
   Create a Kotlin Multiplatform application that uses the [Compose Multiplatform UI framework](https://www.jetbrains.com/lp/compose-multiplatform/)
   for sharing UIs between iOS and Android.
 
@@ -32,7 +24,6 @@ Once you have gained some experience with Kotlin Multiplatform and want to know
 * [Set up targets manually](multiplatform-set-up-targets.md) for your Kotlin Multiplatform project.
 * [Add dependencies](multiplatform-add-dependencies.md) on the standard, test, or another kotlinx library.
 * [Configure compilations](multiplatform-configure-compilations.md) for production and test purposes in your project.
-* [Run tests](multiplatform-run-tests.md) for JVM, JavaScript, Android, Linux, Windows, macOS, iOS, watchOS, and tvOS simulators.
 * [Publish a multiplatform library](multiplatform-publish-lib.md) to the Maven repository.
 * [Build native binaries](multiplatform-build-native-binaries.md) as executables or shared libraries, like universal frameworks or XCFrameworks.
 
diff --git a/docs/topics/multiplatform/multiplatform-library.md b/docs/topics/multiplatform/multiplatform-library.md
deleted file mode 100644
index 91d6085bfcb..00000000000
--- a/docs/topics/multiplatform/multiplatform-library.md
+++ /dev/null
@@ -1,607 +0,0 @@
-[//]: # (title: Create and publish a multiplatform library – tutorial)
-
-In this tutorial, you will learn how to create a multiplatform library for JVM, JS, and Native platforms, write common
-tests for all platforms, and publish the library to a local Maven repository.
-
-This library converts raw data – strings and byte arrays – to the [Base64](https://en.wikipedia.org/wiki/Base64) format.
-It can be used on Kotlin/JVM, Kotlin/JS, and any available Kotlin/Native platform.
-
-You will use different ways to implement the conversion to the Base64 format on different platforms:
-
-* For JVM – the [`java.util.Base64` class](https://docs.oracle.com/javase/8/docs/api/java/util/Base64.html).
-* For JS – the [`base-64` npm package](https://www.npmjs.com/package/base-64).
-* For Kotlin/Native – your own implementation.
-
-You will also test your code using common tests, and then publish the library to your local Maven repository.
-
-> You can find a similar project in this [GitHub repository](https://github.com/KaterinaPetrova/mpp-sample-lib).
->
-{type="note"}
-
-## Set up the environment
-
-You can complete this tutorial on any operating system.
-Download and install the [latest version of IntelliJ IDEA](https://www.jetbrains.com/idea/download/index.html) with the [latest Kotlin plugin](releases.md).
-
-## Create a project
-
-1. In IntelliJ IDEA, select **File | New | Project**.
-2. In the left-hand panel, select **Kotlin Multiplatform**.
-3. Enter a project name, then in the **Multiplatform** section select **Library** as the project template.
-
-   ![Select a project template](multiplatform-project-1.png)
-
-   By default, your project will use Gradle with Kotlin DSL as the build system.
-4. Specify the [JDK](https://www.jetbrains.com/help/idea/sdk.html#jdk), which is required for developing Kotlin projects.
-5. Click **Next** and then **Finish**.
-
-The wizard will create a sample multiplatform library with the following structure:
-
-![Multiplatform library structure](multiplatform-lib-structure.png){width=250}
-
-## Write cross-platform code
-
-Define the classes and interfaces you are going to implement in the common code.
-
-1. In `commonMain/kotlin`, create a new `org.jetbrains.base64` directory.
-2. Create the `Base64.kt` file in the new directory.
-3. Define the `Base64Encoder` interface that converts bytes to the `Base64` format:
-
-    ```kotlin
-    package org.jetbrains.base64
-    
-    interface Base64Encoder {
-        fun encode(src: ByteArray): ByteArray
-    }
-    ```
-
-4. Define the `Base64Factory` object to provide an instance of the `Base64Encoder` interface to the common code:
-
-    ```kotlin
-    expect object Base64Factory {
-        fun createEncoder(): Base64Encoder
-    }
-    ```
-
-The factory object is marked with the `expect` keyword in the cross-platform code.
-For each platform, you should provide an `actual` implementation of the `Base64Factory` object with the platform-specific encoder.
-Learn more about [platform-specific implementations](multiplatform-expect-actual.md).
-
-## Provide platform-specific implementations
-
-Now you will create the `actual` implementations of the `Base64Factory` object for each platform:
-
-* [JVM](#jvm)
-* [JS](#js)
-* [Native](#native)
-
-### JVM
-
-1. In `jvmMain/kotlin`, create a new `org.jetbrains.base64` package.
-2. Create the `Base64.kt` file in the new package.
-3. Provide a simple implementation of the `Base64Factory` object that delegates to the `java.util.Base64` class:
-
-   > IDEA inspections help create `actual` implementations for an `expect` declaration.
-   >
-   {type="note"}
-
-    ```kotlin
-    package org.jetbrains.base64
-    import java.util.*
-    
-    actual object Base64Factory {
-        actual fun createEncoder(): Base64Encoder = JvmBase64Encoder
-    }
-    
-    object JvmBase64Encoder : Base64Encoder {
-        override fun encode(src: ByteArray): ByteArray = Base64.getEncoder().encode(src)
-    }
-    ```
-
-Pretty simple, right? You've provided a platform-specific implementation by using a straightforward delegation to a third-party implementation.
-
-### JS
-
-For the JS part of your project, you'll make use of the `base-64` npm package. It can be added as dependency to implement
-JS-specific functionality:
-
-1. Update your `build.gradle.kts` file by adding a dependency to the `jsMain` source set:
-
-   ```kotlin
-   kotlin {
-       // ...
-       
-       sourceSets {
-           val jsMain by getting {
-               dependencies {
-                   implementation(npm("base-64", "1.0.0"))
-               }
-           }
-       }
-   }
-   ```
-
-2. In `jsMain/kotlin`, create a new `org.jetbrains.base64` directory.
-3. Create the `Base64.kt` file in the new directory.
-4. Provide a simple implementation of the `Base64Factory` object that delegates to the `Base64` object:
-
-    ```kotlin
-    package org.jetbrains.base64
-
-    actual object Base64Factory {
-        actual fun createEncoder(): Base64Encoder = JsBase64Encoder
-    }
-
-    object JsBase64Encoder : Base64Encoder {
-        override fun encode(src: ByteArray): ByteArray {
-            val binString = src.decodeToString()
-            return Base64.encode(binString).encodeToByteArray()
-        }
-    }
-    ```
-   
-5. Create a separate file `Base64Npm.kt` in the same directory.
-6. Implement the `Base64` object using the `base-64` npm package:
-
-   ```kotlin
-   package org.jetbrains.base64
-
-   @JsModule("base-64")
-   @JsNonModule
-   external object Base64 {
-       fun encode(s: String): String
-   }
-   ```
-
-### Native
-
-Unfortunately, there is no third-party implementation available for all Kotlin/Native targets, so you need to write it yourself:
-
-1. In `nativeMain/kotlin`, create a new `org.jetbrains.base64` directory.
-2. Create the `Base64.kt` file in the new directory.
-3. Provide your own implementation for the `Base64Factory` object:
-
-    ```kotlin
-    package org.jetbrains.base64
-    
-    private val BASE64_ALPHABET: String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-    private val BASE64_MASK: Byte = 0x3f
-    private val BASE64_PAD: Char = '='
-    private val BASE64_INVERSE_ALPHABET = IntArray(256) {
-        BASE64_ALPHABET.indexOf(it.toChar())
-    }
-    
-    private fun Int.toBase64(): Char = BASE64_ALPHABET[this]
-    
-    actual object Base64Factory {
-        actual fun createEncoder(): Base64Encoder = NativeBase64Encoder
-    }
-    
-    object NativeBase64Encoder : Base64Encoder {
-        override fun encode(src: ByteArray): ByteArray {
-            fun ByteArray.getOrZero(index: Int): Int = if (index >= size) 0 else get(index).toInt()
-            // 4n / 3 is expected Base64 payload
-            val result = ArrayList<Byte>(4 * src.size / 3)
-            var index = 0
-            while (index < src.size) {
-                val symbolsLeft = src.size - index
-                val padSize = if (symbolsLeft >= 3) 0 else (3 - symbolsLeft) * 8 / 6
-                val chunk = (src.getOrZero(index) shl 16) or (src.getOrZero(index + 1) shl 8) or src.getOrZero(index + 2)
-                index += 3
-    
-                for (i in 3 downTo padSize) {
-                    val char = (chunk shr (6 * i)) and BASE64_MASK.toInt()
-                    result.add(char.toBase64().code.toByte())
-                }
-                // Fill the pad with '='
-                repeat(padSize) { result.add(BASE64_PAD.code.toByte()) }
-            }
-    
-            return result.toByteArray()
-        }
-    }
-    ```
-
-## Test your library
-
-Now when you have `actual` implementations of the `Base64Factory` object for all platforms, it's time to test your multiplatform library.
-
-To save time on testing, you can write common tests that will be executed on all platforms instead of testing each platform separately.
-
-### Prerequisites
-
-Before writing tests, add the `encodeToString` method with the default implementation to the `Base64Encoder` interface, which is defined in `commonMain/kotlin/org/jetbrains/base64/Base64.kt`.
-This implementation converts byte arrays to strings, which are much easier to test.
-
-```kotlin
-interface Base64Encoder {
-    fun encode(src: ByteArray): ByteArray
-
-    fun encodeToString(src: ByteArray): String {
-        val encoded = encode(src)
-        return buildString(encoded.size) {
-            encoded.forEach { append(it.toInt().toChar()) }
-        }
-    }
-}
-```
-
-You can also provide a more efficient implementation of this method for a specific platform, for example, for JVM in `jvmMain/kotlin/org/jetbrains/base64/Base64.kt`:
-
-```kotlin
-object JvmBase64Encoder : Base64Encoder {
-    override fun encode(src: ByteArray): ByteArray = Base64.getEncoder().encode(src)
-    override fun encodeToString(src: ByteArray): String = Base64.getEncoder().encodeToString(src)
-}
-```
-
-One of the benefits of a multiplatform library is having a default implementation with optional platform-specific overrides.
-
-### Write common tests
-
-Now you have a string-based API that you can cover with basic tests.
-
-1. In `commonTest/kotlin`, create a new `org.jetbrains.base64` directory.
-2. Create the `Base64Test.kt` file in the new directory.
-3. Add tests to this file:
-
-    ```kotlin
-    package org.jetbrains.base64
-
-    import kotlin.test.Test
-    import kotlin.test.assertEquals
-   
-    class Base64Test {
-        @Test
-        fun testEncodeToString() {
-            checkEncodeToString("Kotlin is awesome", "S290bGluIGlzIGF3ZXNvbWU=")
-        }
-    
-        @Test
-        fun testPaddedStrings() {
-            checkEncodeToString("", "")
-            checkEncodeToString("1", "MQ==")
-            checkEncodeToString("22", "MjI=")
-            checkEncodeToString("333", "MzMz")
-            checkEncodeToString("4444", "NDQ0NA==")
-        }
-    
-        private fun checkEncodeToString(input: String, expectedOutput: String) {
-            assertEquals(expectedOutput, Base64Factory.createEncoder().encodeToString(input.asciiToByteArray()))
-        }
-    
-        private fun String.asciiToByteArray() = ByteArray(length) {
-            get(it).code.toByte()
-        }
-    }
-    ```
-
-4. In the Terminal, execute the `check` Gradle task:
-
-    ```bash
-    ./gradlew check
-    ```
-
-   > You can also run the `check` Gradle task by double-clicking it in the list of Gradle tasks.
-   >
-   {type="note"}
-
-The tests will run on all platforms (JVM, JS, and Native).
-
-### Add platform-specific tests
-
-You can also add tests that will be run only for a specific platform. For example, you can add UTF-16 tests on JVM:
-
-1. In `jvmTest/kotlin`, create the `org.jetbrains.base64` package.
-2. Create the `Base64Test.kt` file in the new package.
-3. Add tests to this file:
-
-   ```kotlin
-   package org.jetbrains.base64
-   
-   import kotlin.test.Test
-   import kotlin.test.assertEquals
-   
-   class Base64JvmTest {
-       @Test
-       fun testNonAsciiString() {
-           val utf8String = "Gödel"
-           val actual = Base64Factory.createEncoder().encodeToString(utf8String.toByteArray())
-           assertEquals("R8O2ZGVs", actual)
-       }
-   }
-   ```
-
-This test will automatically run on the JVM platform in addition to the common tests.
-
-## Publish your library to the local Maven repository
-
-Your multiplatform library is ready for publishing so that you can use it in other projects.
-
-To publish your library, use the [`maven-publish` Gradle plugin](https://docs.gradle.org/current/userguide/publishing_maven.html).
-
-1. In the `build.gradle.kts` file, apply the `maven-publish` plugin and specify the group and version of your library:
-
-   ```kotlin
-   plugins {
-       kotlin("multiplatform") version "%kotlinVersion%"
-       id("maven-publish")
-   }
-   
-   group = "org.jetbrains.base64"
-   version = "1.0.0"
-   ```
-
-2. In the Terminal, run the `publishToMavenLocal` Gradle task to publish your library to your local Maven repository:
-
-    ```bash
-    ./gradlew publishToMavenLocal
-    ```
-
-   > You can also run the `publishToMavenLocal` Gradle task by double-clicking it in the list of Gradle tasks.
-   >
-   {type="note"}
-
-Your library will be published to the local Maven repository.
-
-## Publish your library to the external Maven Central repository
-
-You can go public and release your multiplatform library to [Maven Central](https://search.maven.org/), a remote repository
-where maven artifacts are stored and managed. This way, other developers will be able to find it and add as a dependency
-to their projects.
-
-### Register a Sonatype account and generate GPG keys
-
-If this is your first library, or you used the sunset Bintray to do this before, you need first to register a
-Sonatype account.
-
-You can use the GetStream article to create and set up your account. The [Registering a Sonatype account](https://getstream.io/blog/publishing-libraries-to-mavencentral-2021/#registering-a-sonatype-account)
-section describes how to:
-
-1. Register a [Sonatype Jira account](https://issues.sonatype.org/secure/Signup!default.jspa).
-2. Create a new issue. You can use [our issue](https://issues.sonatype.org/browse/OSSRH-65092) as an example.
-3. Verify your domain ownership corresponding to the group ID you want to use to publish your artifacts.
-
-Then, since artifacts published on Maven Central have to be signed, follow the [Generating a GPG key pair](https://getstream.io/blog/publishing-libraries-to-mavencentral-2021/#generating-a-gpg-key-pair)
-section to:
-
-1. Generate a GPG key pair for signing your artifacts.
-2. Publish your public key.
-3. Export your private key.
-
-When the Maven repository and signing keys for your library are ready, you can move on and set up your build to upload
-the library artifacts to a staging repository and then release them.
-
-### Set up publication
-
-Now you need to instruct Gradle how to publish the library. Most of the work is already done by the `maven-publish` and Kotlin
-Gradle plugins, all the required publications are created automatically. You already know the result when the library is
-published to a local Maven repository. To publish it to Maven Central, you need to take additional steps:
-
-1. Configure the public Maven repository URL and credentials.
-2. Provide a description and `javadocs` for all library components.
-3. Sign publications.
-
-You can handle all these tasks with Gradle scripts. Let's extract all the publication-related logic from the library
-module `build.script`, so you can easily reuse it for other modules in the future.
-
-The most idiomatic and flexible way to do that is to use Gradle's [precompiled script plugins](https://docs.gradle.org/current/userguide/custom_plugins.html#sec:precompiled_plugins).
-All the build logic will be provided as a precompiled script plugin and could be applied by plugin ID to every module of our library.
-
-To implement this, move the publication logic to a separate Gradle project:
-
-1. Add a new Gradle project inside your library root project. For that, create a new folder named `convention-plugins` and create a new file  `build.gradle.kts` inside of it.
-2. Place the following code into the new `build.gradle.kts` file:
-
-   ```kotlin
-   plugins {
-       `kotlin-dsl` // Is needed to turn our build logic written in Kotlin into the Gradle Plugin
-   }
-   
-   repositories {
-       gradlePluginPortal() // To use 'maven-publish' and 'signing' plugins in our own plugin
-   }
-   ```
-
-3. In the `convention-plugins` directory, create a `src/main/kotlin/convention.publication.gradle.kts` file
-   to store all the publication logic.
-4. Add all the required logic in the new file. Be sure to make changes to match your project configuration and where explicitly noted by angle brackets (i.e. `<replace-me>`):
-
-   ```kotlin
-   import org.gradle.api.publish.maven.MavenPublication
-   import org.gradle.api.tasks.bundling.Jar
-   import org.gradle.kotlin.dsl.`maven-publish`
-   import org.gradle.kotlin.dsl.signing
-   import java.util.*
-   
-   plugins {
-       `maven-publish`
-       signing
-   }
-   
-   // Stub secrets to let the project sync and build without the publication values set up
-   ext["signing.keyId"] = null
-   ext["signing.password"] = null
-   ext["signing.secretKeyRingFile"] = null
-   ext["ossrhUsername"] = null
-   ext["ossrhPassword"] = null
-   
-   // Grabbing secrets from local.properties file or from environment variables, which could be used on CI
-   val secretPropsFile = project.rootProject.file("local.properties")
-   if (secretPropsFile.exists()) {
-       secretPropsFile.reader().use {
-           Properties().apply {
-               load(it)
-           }
-       }.onEach { (name, value) ->
-           ext[name.toString()] = value
-       }
-   } else {
-       ext["signing.keyId"] = System.getenv("SIGNING_KEY_ID")
-       ext["signing.password"] = System.getenv("SIGNING_PASSWORD")
-       ext["signing.secretKeyRingFile"] = System.getenv("SIGNING_SECRET_KEY_RING_FILE")
-       ext["ossrhUsername"] = System.getenv("OSSRH_USERNAME")
-       ext["ossrhPassword"] = System.getenv("OSSRH_PASSWORD")
-   }
-   
-   val javadocJar by tasks.registering(Jar::class) {
-       archiveClassifier.set("javadoc")
-   }
-   
-   fun getExtraString(name: String) = ext[name]?.toString()
-   
-   publishing {
-       // Configure maven central repository
-       repositories {
-           maven {
-               name = "sonatype"
-               setUrl("https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/")
-               credentials {
-                   username = getExtraString("ossrhUsername")
-                   password = getExtraString("ossrhPassword")
-               }
-           }
-       }
-   
-       // Configure all publications
-       publications.withType<MavenPublication> {
-           // Stub javadoc.jar artifact
-           artifact(javadocJar.get())
-   
-           // Provide artifacts information requited by Maven Central
-           pom {
-               name.set("MPP Sample library")
-               description.set("Sample Kotlin Multiplatform library (jvm + ios + js) test")
-               url.set("https://github.com/<your-github-repo>/mpp-sample-lib")
-   
-               licenses {
-                   license {
-                       name.set("MIT")
-                       url.set("https://opensource.org/licenses/MIT")
-                   }
-               }
-               developers {
-                   developer {
-                   id.set("<your-github-profile>")
-                   name.set("<your-name>")
-                   email.set("<your-email>") 
-               }
-           }
-               scm {
-                   url.set("https://github.com/<your-github-repo>/mpp-sample-lib")
-               }
-           }
-       }
-   }
-   
-   // Signing artifacts. Signing.* extra properties values will be used
-   signing {
-       sign(publishing.publications)
-   }
-   ```
-   {initial-collapse-state="collapsed"}
-
-   Applying just `maven-publish` is enough for publishing to the local Maven repository, but not to Maven Central.
-   In the provided script, you get the credentials from `local.properties` or environment variables,
-   do all the required configuration in the `publishing` section, and sign your publications with the signing plugin.
-
-5. Go back to your library project. To ask Gradle to prebuild your plugins, update the root `settings.gradle.kts`
-   with the following:
-
-   ```kotlin
-   rootProject.name = "multiplatform-lib" // your project name
-   includeBuild("convention-plugins")
-   ```
-
-6. Now, you can apply this logic in the library's `build.script`. In the `plugins` section, replace `maven-publish` with
-   `conventional.publication`:
-
-   ```kotlin
-   plugins {
-       kotlin("multiplatform") version "%kotlinVersion%"
-       id("convention.publication")
-   }
-   ```
-
-7. Create a `local.properties` file within your library's root directory with all the necessary credentials and make sure to add it to your `.gitignore`:
-
-   ```none
-   # The GPG key pair ID (last 8 digits of its fingerprint)
-   signing.keyId=...
-   # The passphrase of the key pair
-   signing.password=...
-   # Private key you exported earlier
-   signing.secretKeyRingFile=...
-   # Your credentials for the Jira account
-   ossrhUsername=...
-   ossrhPassword=...
-   ```
-
-8. Run `./gradlew clean` and sync the project.
-
-New Gradle tasks related to the Sonatype repository should appear in the publishing group – that means that everything
-is ready for you to publish your library.
-
-### Publish your library to Maven Central
-
-To upload your library to the Sonatype repository, run the following program:
-
-```bash
-./gradlew publishAllPublicationsToSonatypeRepository
-```
-
-The staging repository will be created, and all the artifacts for all publications will be uploaded to that
-repository. All it's left to do is to check that all the artifacts you wanted to upload have made it there and to
-press the release button.
-
-These steps are described in the [Your first release](https://getstream.io/blog/publishing-libraries-to-mavencentral-2021/#your-first-release)
-section. In short, you need to:
-
-1. Go to [https://s01.oss.sonatype.org](https://s01.oss.sonatype.org) and log in using your credentials in Sonatype Jira.
-2. Find your repository in the **Staging repositories** section.
-3. Close it.
-4. Release the library.
-5. To activate the sync to Maven Central, go back to the Jira issue you created and leave a comment saying that you've
-   released your first component.
-   This step is only needed if it's your first release.
-
-Soon your library will be available at [https://repo1.maven.org/maven2](https://repo1.maven.org/maven2), and other
-developers will be able to add it as a dependency. In a couple of hours, other developers will be able to find it using
-[Maven Central Repository Search](https://search.maven.org/).
-
-## Add a dependency on the published library
-
-You can add your library to other multiplatform projects as a dependency.
-
-In the `build.gradle.kts` file, add `mavenLocal()` or `MavenCentral()` (if the library was published
-to the external repository) and add a dependency on your library:
-
-```kotlin
-repositories {
-    mavenCentral()
-    mavenLocal()
-}
-
-kotlin {
-    sourceSets {
-        val commonMain by getting {
-            dependencies {
-                implementation("org.jetbrains.base64:multiplatform-lib:1.0.0")
-            }
-        }
-    }
-}
-```
-
-The `implementation` dependency consists of:
-
-* The group ID and version — specified earlier in the `build.gradle.kts` file
-* The artifact ID — by default, it's your project's name specified in the `settings.gradle.kts` file
-
-For more details, see the [Gradle documentation](https://docs.gradle.org/current/userguide/publishing_maven.html) on the `maven-publish` plugin.
-
-## What's next?
-
-* Learn more about [publishing multiplatform libraries](multiplatform-publish-lib.md).
-* Learn more about [Kotlin Multiplatform](multiplatform-get-started.md).
-* [Create your first cross-platform mobile application – tutorial](multiplatform-mobile-create-first-app.md).
diff --git a/docs/topics/multiplatform/multiplatform-publish-lib.md b/docs/topics/multiplatform/multiplatform-publish-lib.md
index d371ffc0358..78d49ce1355 100644
--- a/docs/topics/multiplatform/multiplatform-publish-lib.md
+++ b/docs/topics/multiplatform/multiplatform-publish-lib.md
@@ -22,9 +22,6 @@ publishing {
 }
 ```
 
-To get hands-on experience, as well as learn how to publish a multiplatform library to the external Maven Central repository,
-see the [Create and publish a multiplatform library](multiplatform-library.md) tutorial.
-
 > You can also publish a multiplatform library to a GitHub repository. For more information, see GitHub's documentation on [GitHub packages](https://docs.github.com/en/packages).
 >
 {type="tip"}
diff --git a/docs/topics/multiplatform/multiplatform-run-tests.md b/docs/topics/multiplatform/multiplatform-run-tests.md
deleted file mode 100644
index 52dff8ccb7e..00000000000
--- a/docs/topics/multiplatform/multiplatform-run-tests.md
+++ /dev/null
@@ -1,67 +0,0 @@
-[//]: # (title: Run tests with Kotlin Multiplatform)
-
-By default, Kotlin supports running tests for JVM, JS, Android, Linux, Windows, macOS as well as iOS, watchOS, and tvOS simulators. 
-To run tests for other Kotlin/Native targets, you need to configure them manually in an appropriate environment, emulator, 
-or test framework.
-
-## Required dependencies
-
-The [`kotlin.test` API](https://kotlinlang.org/api/latest/kotlin.test/) is available for multiplatform tests. When you
-[create a multiplatform project](multiplatform-library.md), the Project Wizard automatically adds test dependencies to
-common and platform-specific source sets. 
-
-If you didn't use the Project Wizard to create your project, you can [add the dependencies manually](gradle-configure-project.md#set-dependencies-on-test-libraries).
-
-## Run tests for one or more targets
-
-To run tests for all targets, run the `check` task.
-
-To run tests for a particular target suitable for testing, run a test task `<targetName>Test`.
-
-## Test shared code
-
-For testing shared code, you can use [actual declarations](multiplatform-expect-actual.md) in your tests.
-
-For example, to test the shared code in `commonMain`:
-
-```kotlin
-expect object Platform {
-    val name: String
-}
-
-fun hello(): String = "Hello from ${Platform.name}"
-
-class Proxy {
-    fun proxyHello() = hello()
-}
-```
-
-You can use the following test in `commonTest`:
-
-```kotlin
-import kotlin.test.Test
-import kotlin.test.assertTrue
-
-class SampleTests {
-    @Test
-    fun testProxy() {
-        assertTrue(Proxy().proxyHello().isNotEmpty())
-    }
-}
-```
-
-And the following test in `iosTest`:
-
-```kotlin
-import kotlin.test.Test
-import kotlin.test.assertTrue
-
-class SampleTestsIOS {
-    @Test
-    fun testHello() {
-        assertTrue("iOS" in hello())
-    }
-}
-```
-
-You can also learn how to create and run multiplatform tests in the [Create and publish a multiplatform library – tutorial](multiplatform-library.md#test-your-library).
\ No newline at end of file
diff --git a/docs/topics/multiplatform/multiplatform-set-up-targets.md b/docs/topics/multiplatform/multiplatform-set-up-targets.md
index ce97ed17b28..2d744defd11 100644
--- a/docs/topics/multiplatform/multiplatform-set-up-targets.md
+++ b/docs/topics/multiplatform/multiplatform-set-up-targets.md
@@ -1,6 +1,6 @@
 [//]: # (title: Set up targets for Kotlin Multiplatform)
 
-You can add targets when [creating a project with the Project Wizard](multiplatform-library.md). If you need to add a target 
+You can add targets when creating a project with the [project wizard](https://kmp.jetbrains.com/). If you need to add a target 
 later, you can do this manually using target presets for [supported platforms](multiplatform-dsl-reference.md#targets).
 
 Learn more about [additional settings for targets](multiplatform-dsl-reference.md#common-target-configuration).
diff --git a/docs/topics/multiplatform/multiplatform.md b/docs/topics/multiplatform/multiplatform.md
index af850a1dc92..ae5d80b7529 100644
--- a/docs/topics/multiplatform/multiplatform.md
+++ b/docs/topics/multiplatform/multiplatform.md
@@ -2,11 +2,6 @@
 [//]: # (description: Kotlin Multiplatform allows creating cross-platform apps for desktop, web, and mobile devices.
 Share application logic while keeping native user experience.)
 
-> Kotlin Multiplatform is in [Beta](components-stability.md). It is almost stable, but migration steps may be required
-> in the future. We'll do our best to minimize any changes you have to make.
->
-{type="note"}
-
 The Kotlin Multiplatform technology is designed to simplify the development of cross-platform projects. It reduces time
 spent writing and maintaining the same code for [different platforms](#kotlin-multiplatform-use-cases)
 while retaining the flexibility and benefits of native programming.
@@ -17,12 +12,12 @@ while retaining the flexibility and benefits of native programming.
 
 ### Android and iOS applications
 
-Sharing code between mobile platforms is a major Kotlin Multiplatform use cases. With Kotlin Multiplatform for mobile,
+Sharing code between mobile platforms is a major Kotlin Multiplatform use cases. With Kotlin Multiplatform,
 you can build cross-platform mobile applications that share code between Android and iOS to implement networking,
 data storage and data validation, analytics, computations, and other application logic.
 
-Check out the [Get started with Kotlin Multiplatform for mobile](multiplatform-mobile-getting-started.md) and
-[Create a multiplatform app using Ktor and SQLDelight](multiplatform-mobile-ktor-sqldelight.md) tutorials,
+Check out the [Get started with Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html) and
+[Create a multiplatform app using Ktor and SQLDelight](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-ktor-sqldelight.html) tutorials,
 where you will create applications for Android and iOS that include a module with shared code for both platforms.
 
 Thanks to [Compose Multiplatform](https://www.jetbrains.com/lp/compose-multiplatform/),
@@ -31,8 +26,8 @@ you can also share UIs across Android and iOS to create fully cross-platform app
 
 ![Sharing different levels and UI](multiplatform-compose.svg){width=600}
 
-Try this [Compose Multiplatform mobile application](https://github.com/JetBrains/compose-multiplatform-ios-android-template/#readme)
-template to create your own mobile application with UIs shared between both platforms.
+Check out the [Get started with Compose Multiplatform](https://github.com/JetBrains/compose-multiplatform-ios-android-template/#readme)
+tutorial to create your own mobile application with UIs shared between both platforms.
 
 ### Multiplatform libraries
 
@@ -40,8 +35,7 @@ Kotlin Multiplatform is also helpful for library authors. You can create a multi
 platform-specific implementations for JVM, web, and native platforms. Once published, a multiplatform library can be used
 as a dependency in other cross-platform projects.
 
-See the [Create and publish a multiplatform library](multiplatform-library.md) tutorial, where you will create
-a multiplatform library, test it, and publish it to Maven.
+See the [Publish a multiplatform library](multiplatform-publish-lib.md) for more details.
 
 ### Desktop applications
 
@@ -69,7 +63,7 @@ declarations](multiplatform-expect-actual.md).
 
 ## Get started
 
-* Begin with the [Get started with Kotlin Multiplatform for mobile](multiplatform-mobile-getting-started.md) if you want to create iOS and Android applications with shared code
+* Begin with the [Get started with Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html) if you want to create iOS and Android applications with shared code
 * Explore [sharing code principles and examples](multiplatform-share-on-platforms.md) if you want to create applications or libraries targeting other platforms
 
 > New to Kotlin? Take a look at [Getting started with Kotlin](getting-started.md).
@@ -78,8 +72,4 @@ declarations](multiplatform-expect-actual.md).
 
 ### Sample projects
 
-Look through cross-platform application samples to understand how Kotlin Multiplatform works:
-
-* [Kotlin Multiplatform for mobile samples](multiplatform-mobile-samples.md)
-* [Compose Multiplatform samples](https://github.com/JetBrains/compose-multiplatform/blob/master/examples/README.md)
-
+Look through [cross-platform application samples](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-samples.html) to understand how Kotlin Multiplatform works.
diff --git a/docs/topics/native-and-cross-platform.md b/docs/topics/native-and-cross-platform.md
index 3339e258769..317799bf6ef 100644
--- a/docs/topics/native-and-cross-platform.md
+++ b/docs/topics/native-and-cross-platform.md
@@ -108,7 +108,7 @@ In a nutshell, you should to opt for cross-platform solutions if:
 * You want to have a single codebase for the app logic while keeping full control over UI elements. Not all cross-platform frameworks allow you to do this, but some, like Kotlin Multiplatform Mobile, provide this capability.
 * You're eager to embrace a modern technology that continues to evolve.
 
-> Share the logic of your iOS and Android apps. See [Kotlin Multiplatform Mobile](multiplatform-mobile-getting-started.md) in action.
+> Share the logic of your iOS and Android apps. See [Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html) in action.
 >
 {type="note"}
 
diff --git a/docs/topics/native/native-cocoapods.md b/docs/topics/native/native-cocoapods.md
index bc676c67732..25c70a82893 100644
--- a/docs/topics/native/native-cocoapods.md
+++ b/docs/topics/native/native-cocoapods.md
@@ -110,7 +110,7 @@ If you encounter problems during the installation, check the [Possible issues an
 
 ## Add and configure Kotlin CocoaPods Gradle plugin
 
-If your environment is set up correctly, you can [create a new Kotlin Multiplatform project](multiplatform-mobile-create-first-app.md)
+If your environment is set up correctly, you can [create a new Kotlin Multiplatform project](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-create-first-app.html)
 and choose **CocoaPods Dependency Manager** as the iOS framework distribution option. The plugin will automatically generate the project for you.
 
 If you want to configure your project manually:
diff --git a/docs/topics/native/native-improving-compilation-time.md b/docs/topics/native/native-improving-compilation-time.md
index ca2904f8193..a149540b6d7 100644
--- a/docs/topics/native/native-improving-compilation-time.md
+++ b/docs/topics/native/native-improving-compilation-time.md
@@ -45,7 +45,7 @@ Here are some recommendations for configuring Gradle for better compilation perf
       the `.framework` for only the platform you're using.
       
       To build a platform-specific framework, call the `packForXcode` task generated
-      by the [Kotlin Multiplatform project wizard](multiplatform-mobile-create-first-app.md). 
+      by the [Kotlin Multiplatform project wizard](https://kmp.jetbrains.com/). 
       
       > Remember that in this case, you will need to clean the build using `./gradlew clean` after switching between the
       > device and the simulator. See [this issue](https://youtrack.jetbrains.com/issue/KT-40907) for details.
diff --git a/docs/topics/native/native-objc-interop.md b/docs/topics/native/native-objc-interop.md
index 44e01bb4cb8..dd071213366 100644
--- a/docs/topics/native/native-objc-interop.md
+++ b/docs/topics/native/native-objc-interop.md
@@ -188,7 +188,7 @@ Note that the opposite reversed translation is not implemented yet:
 Swift/Objective-C error-throwing methods aren't imported to Kotlin as
 exception-throwing.
 
-> See how exceptions are handled in the Swift part of a [multiplatform project](multiplatform-mobile-upgrade-app.md#ios-app).
+> See how exceptions are handled in the Swift part of a [multiplatform project](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-upgrade-app.html#ios-app).
 >
 {type="tip"}
 
@@ -240,7 +240,7 @@ Starting from Swift 5.5, Kotlin's `suspend` functions are also available for cal
 `async` functions without using the completion handlers. Currently, this functionality is highly experimental and has certain limitations. See [this YouTrack issue](https://youtrack.jetbrains.com/issue/KT-47610)
 for details.
 
-> * See how Kotlin's suspending functions are used in the Swift part of a [multiplatform project](multiplatform-mobile-upgrade-app.md#ios-app). 
+> * See how Kotlin's suspending functions are used in the Swift part of a [multiplatform project](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-upgrade-app.html#ios-app). 
 > * Learn more about the [`async`/`await` mechanism in the Swift documentation](https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html).
 >
 {type="tip"}
diff --git a/docs/topics/native/native-overview.md b/docs/topics/native/native-overview.md
index 6dfa1b24ed3..d583b3002d6 100644
--- a/docs/topics/native/native-overview.md
+++ b/docs/topics/native/native-overview.md
@@ -58,7 +58,7 @@ are pre-imported and included as Kotlin/Native libraries in the compiler package
 web, and native. Multiplatform libraries provide the necessary APIs for common Kotlin code and allow writing shared parts
 of projects in Kotlin all in one place.
 
-You can use the [Get started with Kotlin Multiplatform for mobile](multiplatform-mobile-getting-started.md) tutorial
+You can use the [Get started with Kotlin Multiplatform](multiplatform-get-started.md) tutorial
 to create applications and share business logic between iOS and Android. To share UIs among iOS, Android, desktop, and web,
 try [Compose Multiplatform](https://www.jetbrains.com/lp/compose-multiplatform/),
 JetBrains' declarative UI framework based on Kotlin and [Jetpack Compose](https://developer.android.com/jetpack/compose).
@@ -76,7 +76,7 @@ Recommended documentation:
 Recommended tutorials:
 
 * [Get started with Kotlin/Native](native-get-started.md)
-* [Get started with Kotlin Multiplatform for mobile](multiplatform-mobile-getting-started.md)
+* [Get started with Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html)
 * [Mapping primitive data types from C](mapping-primitive-data-types-from-c.md)
 * [Kotlin/Native as a dynamic Library](native-dynamic-libraries.md)
 * [Kotlin/Native as an Apple framework](apple-framework.md)
diff --git a/docs/topics/native/native-target-support.md b/docs/topics/native/native-target-support.md
index 2fc6efb38bc..fdffb476d22 100644
--- a/docs/topics/native/native-target-support.md
+++ b/docs/topics/native/native-target-support.md
@@ -51,7 +51,7 @@ Mind the following terms used in tier tables:
 | `tvosArm64`             | `aarch64-apple-tvos`              |               | Apple tvOS on ARM64 platforms                      |
 | `iosArm64`              | `aarch64-apple-ios`               |               | Apple iOS and iPadOS on ARM64 platforms            |
 
-> We're doing our best to move `iosArm64` to Tier 1, as it's a crucial target for [Kotlin Multiplatform for mobile](multiplatform-mobile-getting-started.md).
+> We're doing our best to move `iosArm64` to Tier 1, as it's a crucial target for [Kotlin Multiplatform](multiplatform-get-started.md).
 > To do that, we need first to create a dedicated testing infrastructure because platform limitations make it difficult
 > to run compiler tests on Apple devices.
 > 
diff --git a/docs/topics/tour/kotlin-tour-null-safety.md b/docs/topics/tour/kotlin-tour-null-safety.md
index a2d1fc2c586..ff6de5694fc 100644
--- a/docs/topics/tour/kotlin-tour-null-safety.md
+++ b/docs/topics/tour/kotlin-tour-null-safety.md
@@ -199,4 +199,4 @@ fun main() {
 
 Congratulations! Now that you have completed the Kotlin tour, check out our tutorials for popular Kotlin applications:
 * [Create a backend application](jvm-create-project-with-spring-boot.md)
-* [Create a cross-platform application for Android and iOS](multiplatform-mobile-getting-started.md)
\ No newline at end of file
+* [Create a cross-platform application for Android and iOS](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html)
\ No newline at end of file
diff --git a/docs/topics/whatsnew1720.md b/docs/topics/whatsnew1720.md
index 9184e2484e8..71ce34bb58a 100644
--- a/docs/topics/whatsnew1720.md
+++ b/docs/topics/whatsnew1720.md
@@ -745,8 +745,7 @@ Since the previous release, the Kotlin documentation has received some notable c
 
 ### New and updated tutorials
 
-* [Get started with Kotlin Multiplatform Mobile](multiplatform-mobile-getting-started.md) – learn about cross-platform mobile development with Kotlin and create an app that works on both Android and iOS.
-* [Build a full-stack web app with Kotlin Multiplatform](multiplatform-full-stack-app.md) – create an app using Kotlin throughout the whole stack, with a Kotlin/JVM server part and a Kotlin/JS web client.
+* [Get started with Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html) – learn about cross-platform mobile development with Kotlin and create an app that works on both Android and iOS.
 * [Build a web application with React and Kotlin/JS](js-react.md) – create a browser app exploring Kotlin's DSLs and features of a typical React program.
 
 ### Changes in release documentation
diff --git a/docs/topics/whatsnew18.md b/docs/topics/whatsnew18.md
index ac16bf21c85..bf83fbd8446 100644
--- a/docs/topics/whatsnew18.md
+++ b/docs/topics/whatsnew18.md
@@ -797,9 +797,9 @@ The Kotlin documentation has received some notable changes:
 
 * [Get started with Gradle and Kotlin/JVM](get-started-with-jvm-gradle-project.md) – create a console application using
   IntelliJ IDEA and Gradle.
-* [Create a multiplatform app using Ktor and SQLDelight](multiplatform-mobile-ktor-sqldelight.md) – create a mobile
+* [Create a multiplatform app using Ktor and SQLDelight](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-ktor-sqldelight.html) – create a mobile
   application for iOS and Android using Kotlin Multiplatform Mobile.
-* [Get started with Kotlin Multiplatform Mobile](multiplatform-mobile-getting-started.md) – learn about cross-platform
+* [Get started with Kotlin Multiplatform](https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html) – learn about cross-platform
   mobile development with Kotlin and create an app that works on both Android and iOS.
 
 ## Install Kotlin 1.8.0
diff --git a/docs/topics/whatsnew1820.md b/docs/topics/whatsnew1820.md
index 58389a44369..fdc2b0281e1 100644
--- a/docs/topics/whatsnew1820.md
+++ b/docs/topics/whatsnew1820.md
@@ -609,7 +609,7 @@ The following targets have been deprecated with Kotlin 1.8.20 and will be remove
 As for the remaining targets, there are now three tiers of support depending on how well a target is supported and
 tested in the Kotlin/Native compiler. A target can be moved to a different tier. For example, we'll do our best to
 provide full support for `iosArm64` in the future, as it is important
-for [Kotlin Multiplatform Mobile](multiplatform-mobile-getting-started.md).
+for [Kotlin Multiplatform](multiplatform-get-started.md).
 
 If you're a library author, these target tiers can help you decide which targets to test on CI tools and which ones to
 skip. The Kotlin team will use the same approach when developing official Kotlin libraries,
diff --git a/redirects/pages.yml b/redirects/pages.yml
index 59617372f8d..92ff9ac1f7e 100644
--- a/redirects/pages.yml
+++ b/redirects/pages.yml
@@ -77,9 +77,6 @@
 - from: /docs/tutorials/native/mapping-strings-from-c.html
   to: /docs/mapping-strings-from-c.html
 
-- from: /docs/tutorials/native/mpp-ios-android.html
-  to: /docs/multiplatform-mobile-create-first-app.html
-
 - from: /docs/tutorials/native/apple-framework.html
   to: /docs/apple-framework.html
 
@@ -95,9 +92,6 @@
 - from: /docs/tutorials/native/intro-to-kotlin-native.html
   to: /docs/native-app-with-c-and-libcurl.html
 
-- from: /docs/tutorials/native/working-with-klib.html
-  to: /docs/multiplatform-library.html
-
 - from: /docs/tutorials/native/basic-kotlin-native-app.html
   to: /docs/tutorials/native/using-command-line-compiler.html
 
@@ -142,9 +136,6 @@
 - from: /docs/tutorials/edu-tools-learner.html
   to: /docs/edu-tools-learner.html
 
-- from: /docs/tutorials/mpp/multiplatform-library.html
-  to: /docs/multiplatform-library.html
-
 - from: /docs/tutorials/mpp/intro-to-kotlin-mpp.html
   to: /docs/multiplatform.html
 
@@ -415,9 +406,6 @@
 - from: /docs/reference/type-safe-builders.html
   to: /docs/type-safe-builders.html
 
-- from: /docs/reference/mpp-run-tests.html
-  to: /docs/multiplatform-run-tests.html
-
 - from: /docs/reference/javascript-dce.html
   to: /docs/javascript-dce.html
 
@@ -662,11 +650,6 @@
     - /docs/kmm-use-ktor-for-networking.html
   to: https://ktor.io/docs/getting-started-ktor-client-multiplatform-mobile.html
 
-- from:
-    - /docs/kmm-configure-sqldelight-for-data-storage.html
-    - /docs/multiplatform-mobile-configure-sqldelight-for-data-storage.html
-  to: /docs/multiplatform-mobile-ktor-sqldelight.html
-
 - from: /docs/kotlin-mascot.html
   to: https://blog.jetbrains.com/kotlin/2021/10/introducing-the-kotlin-mascot/
 
@@ -695,3 +678,71 @@
     - /docs/reference/platform-specific-declarations.html
     - /docs/reference/mpp-connect-to-apis.html
   to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-connect-to-apis.html
+
+- from:
+    - /docs/multiplatform-mobile-getting-started.html
+    - /docs/kmm-getting-started.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-getting-started.html
+
+- from:
+    - /docs/multiplatform-mobile-setup.html
+    - /docs/kmm-setup.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-setup.html
+
+- from:
+    - /docs/multiplatform-mobile-create-first-app.html
+    - /docs/kmm-create-first-app.html
+    - /docs/tutorials/native/mpp-ios-android.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-create-first-app.html
+
+- from: /docs/multiplatform-mobile-dependencies.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-dependencies.html
+
+- from: /docs/multiplatform-mobile-upgrade-app.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-upgrade-app.html
+
+- from: /docs/multiplatform-mobile-wrap-up.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-wrap-up.html
+
+- from:
+  - /docs/multiplatform-mobile-integrate-in-existing-app.html
+  - /docs/kmm-integrate-in-existing-app.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-integrate-in-existing-app.html
+
+- from:
+  - /docs/multiplatform-mobile-publish-apps.html
+  - /docs/kmm-publish-apps.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-publish-apps.html
+
+- from:
+  - /docs/multiplatform-mobile-ktor-sqldelight.html
+  - /docs/kmm-configure-sqldelight-for-data-storage.html
+  - /docs/multiplatform-mobile-configure-sqldelight-for-data-storage.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-ktor-sqldelight.html
+
+- from:
+    - /docs/tutorials/native/working-with-klib.html
+    - /docs/tutorials/mpp/multiplatform-library.html
+    - /docs/multiplatform-full-stack-app.html
+    - /docs/multiplatform-library.html
+    - /docs/working-with-klib.html
+    - /docs/multiplatform-create-lib.html
+    - /docs/mpp-create-lib.html
+    - /docs/mpp-publish-lib.html
+  to: /docs/multiplatform-publish-lib.html
+
+- from:
+  - /docs/reference/mpp-run-tests.html
+  - /docs/multiplatform-run-tests.html
+  - /docs/mpp-run-tests.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-run-tests.html
+
+- from:
+    - /docs/multiplatform-mobile-samples.html
+    - /docs/kmm-samples.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-samples.html
+
+- from:
+    - /docs/multiplatform-mobile-faq.html
+    - /docs/kmm-faq.html
+  to: https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-faq.html