diff --git a/coroutines-guide.md b/coroutines-guide.md
index cf91ab9..3b4707c 100644
--- a/coroutines-guide.md
+++ b/coroutines-guide.md
@@ -2,7 +2,7 @@
 
 ## Table of contents
 
-<!--- TOC_REF docs/topics/basics.md -->
+<!--- TOC_REF docs/topics/coroutines-basics.md -->
 <!--- TOC_REF docs/topics/cancellation-and-timeouts.md -->
 <!--- TOC_REF docs/topics/composing-suspending-functions.md -->
 <!--- TOC_REF docs/topics/coroutine-context-and-dispatchers.md -->
diff --git a/docs/basics.md b/docs/basics.md
index 5de1de2..a18bf3d 100644
--- a/docs/basics.md
+++ b/docs/basics.md
@@ -1,3 +1,3 @@
-The documentation has been moved to the [https://kotlinlang.org/docs/basics.html](https://kotlinlang.org/docs/basics.html) page.
+The documentation has been moved to the [https://kotlinlang.org/docs/coroutines-basics.html](https://kotlinlang.org/docs/coroutines-basics.html) page.
 
-To edit the documentation, open the [topics/basics.md](topics/basics.md) page.
\ No newline at end of file
+To edit the documentation, open the [topics/coroutines-basics.md](topics/coroutines-basics.md) page.
diff --git a/docs/cfg/buildprofiles.xml b/docs/cfg/buildprofiles.xml
index cd546de..ac4d04a 100644
--- a/docs/cfg/buildprofiles.xml
+++ b/docs/cfg/buildprofiles.xml
@@ -4,6 +4,7 @@
     <variables>
         <enable-browser-edits>true</enable-browser-edits>
         <browser-edits-url>https://github.com/Kotlin/kotlinx.coroutines/edit/master/</browser-edits-url>
+        <allow-indexable-eaps>true</allow-indexable-eaps>
     </variables>
     <build-profile product="kc"/>
 </buildprofiles>
diff --git a/docs/kc.tree b/docs/kc.tree
index a72aa0c..9cc0a28 100644
--- a/docs/kc.tree
+++ b/docs/kc.tree
@@ -9,7 +9,7 @@
 
     <toc-element id="coroutines-guide.md"/>
     <toc-element id="async-programming.md"/>
-    <toc-element id="basics.md"/>
+    <toc-element id="coroutines-basics.md"/>
     <toc-element id="coroutines-basic-jvm.md"/>
     <toc-element toc-title="Intro to coroutines and channels – hands-on tutorial" href="https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/"/>
     <toc-element id="cancellation-and-timeouts.md"/>
@@ -23,4 +23,4 @@
     <toc-element id="debug-coroutines-with-idea.md"/>
     <toc-element id="debug-flow-with-idea.md"/>
 
-</product-profile>
\ No newline at end of file
+</product-profile>
diff --git a/docs/topics/coroutines-basic-jvm.md b/docs/topics/coroutines-basic-jvm.md
index 42aa95a..3b067ea 100644
--- a/docs/topics/coroutines-basic-jvm.md
+++ b/docs/topics/coroutines-basic-jvm.md
@@ -32,7 +32,7 @@
 ```
 </tabs>
 
-This library is published to Maven Central repository, so add the following:
+This library is published to the [Maven Central repository](https://search.maven.org/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core), so add the following:
 
 ```groovy
 repositories {
@@ -77,6 +77,8 @@
 </dependencies>
 ```
 
+This library is published to the [Maven Central repository](https://search.maven.org/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core), which Maven will download from by default.
+
 That's it, we are good to go and write code under `src/main/kotlin`.
 
 ## My first coroutine
diff --git a/docs/topics/coroutines-basics.md b/docs/topics/coroutines-basics.md
new file mode 100644
index 0000000..c1c1758
--- /dev/null
+++ b/docs/topics/coroutines-basics.md
@@ -0,0 +1,379 @@
+<!--- TEST_NAME BasicsGuideTest -->
+
+[//]: # (title: Coroutines basics)
+
+This section covers basic coroutine concepts.
+
+## Your first coroutine
+
+Run the following code:
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() {
+    GlobalScope.launch { // launch a new coroutine in background and continue
+        delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
+        println("World!") // print after delay
+    }
+    println("Hello,") // main thread continues while coroutine is delayed
+    Thread.sleep(2000L) // block main thread for 2 seconds to keep JVM alive
+}
+```
+{kotlin-runnable="true" kotlin-min-compiler-version="1.3"}
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-01.kt).
+>
+{type="note"}
+
+You will see the following result:
+
+```text
+Hello,
+World!
+```
+
+<!--- TEST -->
+
+Essentially, coroutines are light-weight threads.
+They are launched with [launch] _coroutine builder_ in a context of some [CoroutineScope].
+Here we are launching a new coroutine in the [GlobalScope], meaning that the lifetime of the new
+coroutine is limited only by the lifetime of the whole application.  
+
+You can achieve the same result by replacing
+`GlobalScope.launch { ... }` with `thread { ... }`, and `delay(...)` with `Thread.sleep(...)`. 
+Try it (don't forget to import `kotlin.concurrent.thread`).
+
+If you start by replacing `GlobalScope.launch` with `thread`, the compiler produces the following error:
+
+```Plain Text
+Error: Kotlin: Suspend functions are only allowed to be called from a coroutine or another suspend function
+```
+
+That is because [delay] is a special _suspending function_ that does not block a thread, but _suspends_ the
+coroutine, and it can be only used from a coroutine.
+
+## Bridging blocking and non-blocking worlds
+
+The first example mixes _non-blocking_ `delay(...)` and _blocking_ `Thread.sleep(...)` in the same code. 
+It is easy to lose track of which one is blocking and which one is not. 
+Let's be explicit about blocking using the [runBlocking] coroutine builder:
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() { 
+    GlobalScope.launch { // launch a new coroutine in background and continue
+        delay(1000L)
+        println("World!")
+    }
+    println("Hello,") // main thread continues here immediately
+    runBlocking {     // but this expression blocks the main thread
+        delay(2000L)  // ... while we delay for 2 seconds to keep JVM alive
+    } 
+}
+```
+{kotlin-runnable="true" kotlin-min-compiler-version="1.3"}
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-02.kt).
+>
+{type="note"}
+
+<!--- TEST
+Hello,
+World!
+-->
+
+The result is the same, but this code uses only non-blocking [delay]. 
+The main thread invoking `runBlocking` _blocks_ until the coroutine inside `runBlocking` completes. 
+
+This example can be also rewritten in a more idiomatic way, using `runBlocking` to wrap 
+the execution of the main function:
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking<Unit> { // start main coroutine
+    GlobalScope.launch { // launch a new coroutine in background and continue
+        delay(1000L)
+        println("World!")
+    }
+    println("Hello,") // main coroutine continues here immediately
+    delay(2000L)      // delaying for 2 seconds to keep JVM alive
+}
+```
+{kotlin-runnable="true" kotlin-min-compiler-version="1.3"}
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-03.kt).
+>
+{type="note"}
+
+<!--- TEST
+Hello,
+World!
+-->
+
+Here `runBlocking<Unit> { ... }` works as an adaptor that is used to start the top-level main coroutine. 
+We explicitly specify its `Unit` return type, because a well-formed `main` function in Kotlin has to return `Unit`.
+
+This is also a way to write unit tests for suspending functions:
+
+<!--- INCLUDE
+import kotlinx.coroutines.*
+-->
+
+```kotlin
+class MyTest {
+    @Test
+    fun testMySuspendingFunction() = runBlocking<Unit> {
+        // here we can use suspending functions using any assertion style that we like
+    }
+}
+```
+
+<!--- CLEAR -->
+
+## Waiting for a job
+
+Delaying for a time while another coroutine is working is not a good approach. Let's explicitly 
+wait (in a non-blocking way) until the background [Job] that we have launched is complete:
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {
+//sampleStart
+    val job = GlobalScope.launch { // launch a new coroutine and keep a reference to its Job
+        delay(1000L)
+        println("World!")
+    }
+    println("Hello,")
+    job.join() // wait until child coroutine completes
+//sampleEnd    
+}
+```
+{kotlin-runnable="true" kotlin-min-compiler-version="1.3"}
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-04.kt).
+>
+{type="note"}
+
+<!--- TEST
+Hello,
+World!
+-->
+
+Now the result is still the same, but the code of the main coroutine is not tied to the duration of
+the background job in any way. Much better.
+
+## Structured concurrency
+
+There is still something to be desired for practical usage of coroutines. 
+When we use `GlobalScope.launch`, we create a top-level coroutine. Even though it is light-weight, it still 
+consumes some memory resources while it runs. If we forget to keep a reference to the newly launched 
+coroutine, it still runs. What if the code in the coroutine hangs (for example, we erroneously
+delay for too long), what if we launched too many coroutines and ran out of memory? 
+Having to manually keep references to all the launched coroutines and [join][Job.join] them is error-prone. 
+
+There is a better solution. We can use structured concurrency in our code. 
+Instead of launching coroutines in the [GlobalScope], just like we usually do with threads (threads are always global), 
+we can launch coroutines in the specific scope of the operation we are performing. 
+
+In our example, we have a `main` function that is turned into a coroutine using the [runBlocking] coroutine builder.
+Every coroutine builder, including `runBlocking`, adds an instance of [CoroutineScope] to the scope of its code block. 
+We can launch coroutines in this scope without having to `join` them explicitly, because
+an outer coroutine (`runBlocking` in our example) does not complete until all the coroutines launched
+in its scope complete. Thus, we can make our example simpler:
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking { // this: CoroutineScope
+    launch { // launch a new coroutine in the scope of runBlocking
+        delay(1000L)
+        println("World!")
+    }
+    println("Hello,")
+}
+```
+{kotlin-runnable="true" kotlin-min-compiler-version="1.3"}
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-05.kt).
+>
+{type="note"}
+
+<!--- TEST
+Hello,
+World!
+-->
+
+## Scope builder
+
+In addition to the coroutine scope provided by different builders, it is possible to declare your own scope using the
+[coroutineScope][_coroutineScope] builder. It creates a coroutine scope and does not complete until all launched children complete. 
+
+[runBlocking] and [coroutineScope][_coroutineScope] may look similar because they both wait for their body and all its children to complete.
+The main difference is that the [runBlocking] method _blocks_ the current thread for waiting,
+while [coroutineScope][_coroutineScope] just suspends, releasing the underlying thread for other usages.
+Because of that difference, [runBlocking] is a regular function and [coroutineScope][_coroutineScope] is a suspending function.
+
+It can be demonstrated by the following example:
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking { // this: CoroutineScope
+    launch { 
+        delay(200L)
+        println("Task from runBlocking")
+    }
+    
+    coroutineScope { // Creates a coroutine scope
+        launch {
+            delay(500L) 
+            println("Task from nested launch")
+        }
+    
+        delay(100L)
+        println("Task from coroutine scope") // This line will be printed before the nested launch
+    }
+    
+    println("Coroutine scope is over") // This line is not printed until the nested launch completes
+}
+```
+{kotlin-runnable="true" kotlin-min-compiler-version="1.3"}
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-06.kt).
+>
+{type="note"}
+
+<!--- TEST
+Task from coroutine scope
+Task from runBlocking
+Task from nested launch
+Coroutine scope is over
+-->
+
+Note that right after the "Task from coroutine scope" message (while waiting for nested launch)
+ "Task from runBlocking" is executed and printed — even though the [coroutineScope][_coroutineScope] is not completed yet. 
+
+## Extract function refactoring
+
+Let's extract the block of code inside `launch { ... }` into a separate function. When you 
+perform "Extract function" refactoring on this code, you get a new function with the `suspend` modifier.
+This is your first _suspending function_. Suspending functions can be used inside coroutines
+just like regular functions, but their additional feature is that they can, in turn, 
+use other suspending functions (like `delay` in this example) to _suspend_ execution of a coroutine.
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {
+    launch { doWorld() }
+    println("Hello,")
+}
+
+// this is your first suspending function
+suspend fun doWorld() {
+    delay(1000L)
+    println("World!")
+}
+```
+{kotlin-runnable="true" kotlin-min-compiler-version="1.3"}
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-07.kt).
+>
+{type="note"}
+
+<!--- TEST
+Hello,
+World!
+-->
+
+But what if the extracted function contains a coroutine builder which is invoked on the current scope?
+In this case, the `suspend` modifier on the extracted function is not enough. Making `doWorld` an extension
+method on `CoroutineScope` is one of the solutions, but it may not always be applicable as it does not make the API clearer.
+The idiomatic solution is to have either an explicit `CoroutineScope` as a field in a class containing the target function
+or an implicit one when the outer class implements `CoroutineScope`.
+As a last resort, [CoroutineScope(coroutineContext)][CoroutineScope()] can be used, but such an approach is structurally unsafe 
+because you no longer have control on the scope of execution of this method. Only private APIs can use this builder.
+
+## Coroutines ARE light-weight
+
+Run the following code:
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {
+    repeat(100_000) { // launch a lot of coroutines
+        launch {
+            delay(5000L)
+            print(".")
+        }
+    }
+}
+```
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-08.kt).
+>
+{type="note"}
+
+<!--- TEST lines.size == 1 && lines[0] == ".".repeat(100_000) -->
+
+It launches 100K coroutines and, after 5 seconds, each coroutine prints a dot. 
+
+Now, try that with threads. What would happen? (Most likely your code will produce some sort of out-of-memory error)
+
+## Global coroutines are like daemon threads
+
+The following code launches a long-running coroutine in [GlobalScope] that prints "I'm sleeping" twice a second and then 
+returns from the main function after some delay:
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {
+//sampleStart
+    GlobalScope.launch {
+        repeat(1000) { i ->
+            println("I'm sleeping $i ...")
+            delay(500L)
+        }
+    }
+    delay(1300L) // just quit after delay
+//sampleEnd    
+}
+```
+{kotlin-runnable="true" kotlin-min-compiler-version="1.3"}
+
+> You can get the full code [here](../../kotlinx-coroutines-core/jvm/test/guide/example-basic-09.kt).
+>
+{type="note"}
+
+You can run and see that it prints three lines and terminates:
+
+```text
+I'm sleeping 0 ...
+I'm sleeping 1 ...
+I'm sleeping 2 ...
+```
+
+<!--- TEST -->
+
+Active coroutines that were launched in [GlobalScope] do not keep the process alive. They are like daemon threads.
+
+<!--- MODULE kotlinx-coroutines-core -->
+<!--- INDEX kotlinx.coroutines -->
+
+[launch]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html
+[CoroutineScope]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html
+[GlobalScope]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-global-scope/index.html
+[delay]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/delay.html
+[runBlocking]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html
+[Job]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html
+[Job.join]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/join.html
+[_coroutineScope]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/coroutine-scope.html
+[CoroutineScope()]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope.html
+
+<!--- END -->
diff --git a/docs/topics/coroutines-guide.md b/docs/topics/coroutines-guide.md
index 21a64cc..239b2a4 100644
--- a/docs/topics/coroutines-guide.md
+++ b/docs/topics/coroutines-guide.md
@@ -16,7 +16,7 @@
 
 ## Table of contents
 
-* [Coroutines basics](basics.md)
+* [Coroutines basics](coroutines-basics.md)
 * [Tutorial: Create a basic coroutine](coroutines-basic-jvm.md)
 * [Hands-on: Intro to coroutines and channels](https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels)
 * [Cancellation and timeouts](cancellation-and-timeouts.md)
diff --git a/docs/topics/knit.properties b/docs/topics/knit.properties
index cab9402..562b412 100644
--- a/docs/topics/knit.properties
+++ b/docs/topics/knit.properties
@@ -7,4 +7,3 @@
 
 test.package=kotlinx.coroutines.guide.test
 test.dir=../../kotlinx-coroutines-core/jvm/test/guide/test/
-
diff --git a/kotlinx-coroutines-core/common/src/flow/Flow.kt b/kotlinx-coroutines-core/common/src/flow/Flow.kt
index a511903..0ccd343 100644
--- a/kotlinx-coroutines-core/common/src/flow/Flow.kt
+++ b/kotlinx-coroutines-core/common/src/flow/Flow.kt
@@ -101,7 +101,7 @@
  * From the implementation point of view, it means that all flow implementations should
  * only emit from the same coroutine.
  * This constraint is efficiently enforced by the default [flow] builder.
- * The [flow] builder should be used if flow implementation does not start any coroutines.
+ * The [flow] builder should be used if the flow implementation does not start any coroutines.
  * Its implementation prevents most of the development mistakes:
  *
  * ```
diff --git a/kotlinx-coroutines-core/common/src/flow/internal/Combine.kt b/kotlinx-coroutines-core/common/src/flow/internal/Combine.kt
index 4c76e14..7fde063 100644
--- a/kotlinx-coroutines-core/common/src/flow/internal/Combine.kt
+++ b/kotlinx-coroutines-core/common/src/flow/internal/Combine.kt
@@ -23,7 +23,7 @@
     val size = flows.size
     if (size == 0) return@flowScope // bail-out for empty input
     val latestValues = arrayOfNulls<Any?>(size)
-    latestValues.fill(UNINITIALIZED) // Smaller bytecode & faster that Array(size) { UNINITIALIZED }
+    latestValues.fill(UNINITIALIZED) // Smaller bytecode & faster than Array(size) { UNINITIALIZED }
     val resultChannel = Channel<Update>(size)
     val nonClosed = LocalAtomicInt(size)
     var remainingAbsentValues = size
diff --git a/kotlinx-coroutines-core/common/src/flow/terminal/Collect.kt b/kotlinx-coroutines-core/common/src/flow/terminal/Collect.kt
index d47da4a..42c6629 100644
--- a/kotlinx-coroutines-core/common/src/flow/terminal/Collect.kt
+++ b/kotlinx-coroutines-core/common/src/flow/terminal/Collect.kt
@@ -87,8 +87,8 @@
 
 /**
  * Terminal flow operator that collects the given flow with a provided [action].
- * The crucial difference from [collect] is that when the original flow emits a new value, [action] block for previous
- * value is cancelled.
+ * The crucial difference from [collect] is that when the original flow emits a new value
+ * then the [action] block for the previous value is cancelled.
  *
  * It can be demonstrated by the following example:
  *
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-01.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-01.kt
index 15e1261..f04b100 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-01.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-01.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic01
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-02.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-02.kt
index 4f178ca..bfece26 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-02.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-02.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic02
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-03.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-03.kt
index f80113c..8541f60 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-03.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-03.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic03
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-04.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-04.kt
index 33c928a..69f8277 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-04.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-04.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic04
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-05.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-05.kt
index 52b490d..9d530b5 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-05.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-05.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic05
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-06.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-06.kt
index a1b5bc5..b53d3b8 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-06.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-06.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic06
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-07.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-07.kt
index 32c02b8..cd854ce 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-07.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-07.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic07
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-08.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-08.kt
index bb7786f..0a346e0 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-08.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-08.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic08
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/example-basic-09.kt b/kotlinx-coroutines-core/jvm/test/guide/example-basic-09.kt
index 9f998b5..c9783ee 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/example-basic-09.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/example-basic-09.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.exampleBasic09
 
 import kotlinx.coroutines.*
diff --git a/kotlinx-coroutines-core/jvm/test/guide/test/BasicsGuideTest.kt b/kotlinx-coroutines-core/jvm/test/guide/test/BasicsGuideTest.kt
index ea5003b..765cd0b 100644
--- a/kotlinx-coroutines-core/jvm/test/guide/test/BasicsGuideTest.kt
+++ b/kotlinx-coroutines-core/jvm/test/guide/test/BasicsGuideTest.kt
@@ -2,7 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// This file was automatically generated from basics.md by Knit tool. Do not edit.
+// This file was automatically generated from coroutines-basics.md by Knit tool. Do not edit.
 package kotlinx.coroutines.guide.test
 
 import kotlinx.coroutines.knit.*
diff --git a/site/docs/index.md b/site/docs/index.md
index 3e6bb93..92eb094 100644
--- a/site/docs/index.md
+++ b/site/docs/index.md
@@ -18,6 +18,7 @@
 | [kotlinx-coroutines-reactive](kotlinx-coroutines-reactive)           | Utilities for [Reactive Streams](https://www.reactive-streams.org) |
 | [kotlinx-coroutines-reactor](kotlinx-coroutines-reactor)             | Utilities for [Reactor](https://projectreactor.io) |
 | [kotlinx-coroutines-rx2](kotlinx-coroutines-rx2)                     | Utilities for [RxJava 2.x](https://github.com/ReactiveX/RxJava) |
+| [kotlinx-coroutines-rx3](kotlinx-coroutines-rx3)                     | Utilities for [RxJava 3.x](https://github.com/ReactiveX/RxJava) |
 | [kotlinx-coroutines-android](kotlinx-coroutines-android)             | `Main` dispatcher for Android applications |
 | [kotlinx-coroutines-javafx](kotlinx-coroutines-javafx)               | `JavaFx` dispatcher for JavaFX UI applications |
 | [kotlinx-coroutines-swing](kotlinx-coroutines-swing)                 | `Swing` dispatcher for Swing UI applications |