diff --git a/kotlinx-coroutines-core/common/src/Delay.kt b/kotlinx-coroutines-core/common/src/Delay.kt
index d95dc52f9f..301ed2d322 100644
--- a/kotlinx-coroutines-core/common/src/Delay.kt
+++ b/kotlinx-coroutines-core/common/src/Delay.kt
@@ -133,7 +133,6 @@ public suspend fun delay(timeMillis: Long) {
  *
  * Implementation note: how exactly time is tracked is an implementation detail of [CoroutineDispatcher] in the context.
  */
-@ExperimentalTime
 public suspend fun delay(duration: Duration): Unit = delay(duration.toDelayMillis())
 
 /** Returns [Delay] implementation of the given context */
@@ -143,6 +142,5 @@ internal val CoroutineContext.delay: Delay get() = get(ContinuationInterceptor)
  * Convert this duration to its millisecond value.
  * Positive durations are coerced at least `1`.
  */
-@ExperimentalTime
 internal fun Duration.toDelayMillis(): Long =
     if (this > Duration.ZERO) inWholeMilliseconds.coerceAtLeast(1) else 0
diff --git a/kotlinx-coroutines-core/common/src/Timeout.kt b/kotlinx-coroutines-core/common/src/Timeout.kt
index 264a2b9d1b..46ab4ae8c8 100644
--- a/kotlinx-coroutines-core/common/src/Timeout.kt
+++ b/kotlinx-coroutines-core/common/src/Timeout.kt
@@ -64,7 +64,6 @@ public suspend fun <T> withTimeout(timeMillis: Long, block: suspend CoroutineSco
  *
  * > Implementation note: how the time is tracked exactly is an implementation detail of the context's [CoroutineDispatcher].
  */
-@ExperimentalTime
 public suspend fun <T> withTimeout(timeout: Duration, block: suspend CoroutineScope.() -> T): T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
@@ -131,7 +130,6 @@ public suspend fun <T> withTimeoutOrNull(timeMillis: Long, block: suspend Corout
  *
  * > Implementation note: how the time is tracked exactly is an implementation detail of the context's [CoroutineDispatcher].
  */
-@ExperimentalTime
 public suspend fun <T> withTimeoutOrNull(timeout: Duration, block: suspend CoroutineScope.() -> T): T? =
         withTimeoutOrNull(timeout.toDelayMillis(), block)
 
diff --git a/kotlinx-coroutines-core/common/src/flow/SharingStarted.kt b/kotlinx-coroutines-core/common/src/flow/SharingStarted.kt
index a5ae63667f..0554142408 100644
--- a/kotlinx-coroutines-core/common/src/flow/SharingStarted.kt
+++ b/kotlinx-coroutines-core/common/src/flow/SharingStarted.kt
@@ -135,7 +135,6 @@ public fun interface SharingStarted {
  * are negative.
  */
 @Suppress("FunctionName")
-@ExperimentalTime
 public fun SharingStarted.Companion.WhileSubscribed(
     stopTimeout: Duration = Duration.ZERO,
     replayExpiration: Duration = Duration.INFINITE
diff --git a/kotlinx-coroutines-core/common/src/flow/operators/Delay.kt b/kotlinx-coroutines-core/common/src/flow/operators/Delay.kt
index e893f44ea5..258dc3eeb1 100644
--- a/kotlinx-coroutines-core/common/src/flow/operators/Delay.kt
+++ b/kotlinx-coroutines-core/common/src/flow/operators/Delay.kt
@@ -17,7 +17,6 @@ import kotlin.time.*
 /* Scaffolding for Knit code examples
 <!--- TEST_NAME FlowDelayTest -->
 <!--- PREFIX .*-duration-.*
-@file:OptIn(ExperimentalTime::class)
 ----- INCLUDE .*-duration-.*
 import kotlin.time.*
 ----- INCLUDE .*
@@ -150,7 +149,6 @@ public fun <T> Flow<T>.debounce(timeoutMillis: (T) -> Long): Flow<T> =
  * Note that the resulting flow does not emit anything as long as the original flow emits
  * items faster than every [timeout] milliseconds.
  */
-@ExperimentalTime
 @FlowPreview
 public fun <T> Flow<T>.debounce(timeout: Duration): Flow<T> =
     debounce(timeout.toDelayMillis())
@@ -197,7 +195,6 @@ public fun <T> Flow<T>.debounce(timeout: Duration): Flow<T> =
  *
  * @param timeout [T] is the emitted value and the return value is timeout in [Duration].
  */
-@ExperimentalTime
 @FlowPreview
 @JvmName("debounceDuration")
 @OptIn(kotlin.experimental.ExperimentalTypeInference::class)
@@ -346,6 +343,5 @@ internal fun CoroutineScope.fixedPeriodTicker(delayMillis: Long, initialDelayMil
  *
  * Note that the latest element is not emitted if it does not fit into the sampling window.
  */
-@ExperimentalTime
 @FlowPreview
 public fun <T> Flow<T>.sample(period: Duration): Flow<T> = sample(period.toDelayMillis())
diff --git a/kotlinx-coroutines-core/common/src/selects/Select.kt b/kotlinx-coroutines-core/common/src/selects/Select.kt
index a313de3d5d..921322244a 100644
--- a/kotlinx-coroutines-core/common/src/selects/Select.kt
+++ b/kotlinx-coroutines-core/common/src/selects/Select.kt
@@ -62,7 +62,6 @@ public interface SelectBuilder<in R> {
  * **Note: This is an experimental api.** It may be replaced with light-weight timer/timeout channels in the future.
  */
 @ExperimentalCoroutinesApi
-@ExperimentalTime
 public fun <R> SelectBuilder<R>.onTimeout(timeout: Duration, block: suspend () -> R): Unit =
         onTimeout(timeout.toDelayMillis(), block)
 
diff --git a/kotlinx-coroutines-core/common/test/DelayDurationTest.kt b/kotlinx-coroutines-core/common/test/DelayDurationTest.kt
index 1c6c189a44..f05440998f 100644
--- a/kotlinx-coroutines-core/common/test/DelayDurationTest.kt
+++ b/kotlinx-coroutines-core/common/test/DelayDurationTest.kt
@@ -13,7 +13,6 @@ import kotlin.time.*
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.Duration.Companion.nanoseconds
 
-@ExperimentalTime
 class DelayDurationTest : TestBase() {
 
     @Test
diff --git a/kotlinx-coroutines-core/common/test/WithTimeoutDurationTest.kt b/kotlinx-coroutines-core/common/test/WithTimeoutDurationTest.kt
index efd55fe231..60e64f5830 100644
--- a/kotlinx-coroutines-core/common/test/WithTimeoutDurationTest.kt
+++ b/kotlinx-coroutines-core/common/test/WithTimeoutDurationTest.kt
@@ -8,8 +8,9 @@ package kotlinx.coroutines
 
 import kotlin.test.*
 import kotlin.time.*
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
 
-@ExperimentalTime
 class WithTimeoutDurationTest : TestBase() {
     /**
      * Tests a case of no timeout and no suspension inside.
@@ -17,7 +18,7 @@ class WithTimeoutDurationTest : TestBase() {
     @Test
     fun testBasicNoSuspend() = runTest {
         expect(1)
-        val result = withTimeout(Duration.seconds(10)) {
+        val result = withTimeout(10.seconds) {
             expect(2)
             "OK"
         }
@@ -31,7 +32,7 @@ class WithTimeoutDurationTest : TestBase() {
     @Test
     fun testBasicSuspend() = runTest {
         expect(1)
-        val result = withTimeout(Duration.seconds(10)) {
+        val result = withTimeout(10.seconds) {
             expect(2)
             yield()
             expect(3)
@@ -54,7 +55,7 @@ class WithTimeoutDurationTest : TestBase() {
         }
         expect(2)
         // test that it does not yield to the above job when started
-        val result = withTimeout(Duration.seconds(1)) {
+        val result = withTimeout(1.seconds) {
             expect(3)
             yield() // yield only now
             expect(5)
@@ -74,7 +75,7 @@ class WithTimeoutDurationTest : TestBase() {
     fun testYieldBlockingWithTimeout() = runTest(
             expected = { it is CancellationException }
     ) {
-        withTimeout(Duration.milliseconds(100)) {
+        withTimeout(100.milliseconds) {
             while (true) {
                 yield()
             }
@@ -87,7 +88,7 @@ class WithTimeoutDurationTest : TestBase() {
     @Test
     fun testWithTimeoutChildWait() = runTest {
         expect(1)
-        withTimeout(Duration.milliseconds(100)) {
+        withTimeout(100.milliseconds) {
             expect(2)
             // launch child with timeout
             launch {
@@ -102,7 +103,7 @@ class WithTimeoutDurationTest : TestBase() {
     @Test
     fun testBadClass() = runTest {
         val bad = BadClass()
-        val result = withTimeout(Duration.milliseconds(100)) {
+        val result = withTimeout(100.milliseconds) {
             bad
         }
         assertSame(bad, result)
@@ -118,9 +119,9 @@ class WithTimeoutDurationTest : TestBase() {
     fun testExceptionOnTimeout() = runTest {
         expect(1)
         try {
-            withTimeout(Duration.milliseconds(100)) {
+            withTimeout(100.milliseconds) {
                 expect(2)
-                delay(Duration.milliseconds(1000))
+                delay(1000.milliseconds)
                 expectUnreached()
                 "OK"
             }
@@ -135,10 +136,10 @@ class WithTimeoutDurationTest : TestBase() {
             expected = { it is CancellationException }
     ) {
         expect(1)
-        withTimeout(Duration.milliseconds(100)) {
+        withTimeout(100.milliseconds) {
             expect(2)
             try {
-                delay(Duration.milliseconds(1000))
+                delay(1000.milliseconds)
             } catch (e: CancellationException) {
                 finish(3)
             }
@@ -151,10 +152,10 @@ class WithTimeoutDurationTest : TestBase() {
     fun testSuppressExceptionWithAnotherException() = runTest {
         expect(1)
         try {
-            withTimeout(Duration.milliseconds(100)) {
+            withTimeout(100.milliseconds) {
                 expect(2)
                 try {
-                    delay(Duration.milliseconds(1000))
+                    delay(1000.milliseconds)
                 } catch (e: CancellationException) {
                     expect(3)
                     throw TestException()
@@ -172,7 +173,7 @@ class WithTimeoutDurationTest : TestBase() {
     fun testNegativeTimeout() = runTest {
         expect(1)
         try {
-            withTimeout(-Duration.milliseconds(1)) {
+            withTimeout(-1.milliseconds) {
                 expectUnreached()
                 "OK"
             }
@@ -187,7 +188,7 @@ class WithTimeoutDurationTest : TestBase() {
         expect(1)
         try {
             expect(2)
-            withTimeout(Duration.seconds(1)) {
+            withTimeout(1.seconds) {
                 expect(3)
                 throw TestException()
             }
diff --git a/kotlinx-coroutines-core/common/test/WithTimeoutOrNullDurationTest.kt b/kotlinx-coroutines-core/common/test/WithTimeoutOrNullDurationTest.kt
index b5777753b6..992a0b52cc 100644
--- a/kotlinx-coroutines-core/common/test/WithTimeoutOrNullDurationTest.kt
+++ b/kotlinx-coroutines-core/common/test/WithTimeoutOrNullDurationTest.kt
@@ -10,8 +10,9 @@ package kotlinx.coroutines
 import kotlinx.coroutines.channels.*
 import kotlin.test.*
 import kotlin.time.*
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
 
-@ExperimentalTime
 class WithTimeoutOrNullDurationTest : TestBase() {
     /**
      * Tests a case of no timeout and no suspension inside.
@@ -19,7 +20,7 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testBasicNoSuspend() = runTest {
         expect(1)
-        val result = withTimeoutOrNull(Duration.seconds(10)) {
+        val result = withTimeoutOrNull(10.seconds) {
             expect(2)
             "OK"
         }
@@ -33,7 +34,7 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testBasicSuspend() = runTest {
         expect(1)
-        val result = withTimeoutOrNull(Duration.seconds(10)) {
+        val result = withTimeoutOrNull(10.seconds) {
             expect(2)
             yield()
             expect(3)
@@ -56,7 +57,7 @@ class WithTimeoutOrNullDurationTest : TestBase() {
         }
         expect(2)
         // test that it does not yield to the above job when started
-        val result = withTimeoutOrNull(Duration.seconds(1)) {
+        val result = withTimeoutOrNull(1.seconds) {
             expect(3)
             yield() // yield only now
             expect(5)
@@ -74,7 +75,7 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testYieldBlockingWithTimeout() = runTest {
         expect(1)
-        val result = withTimeoutOrNull(Duration.milliseconds(100)) {
+        val result = withTimeoutOrNull(100.milliseconds) {
             while (true) {
                 yield()
             }
@@ -86,7 +87,7 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testSmallTimeout() = runTest {
         val channel = Channel<Int>(1)
-        val value = withTimeoutOrNull(Duration.milliseconds(1)) {
+        val value = withTimeoutOrNull(1.milliseconds) {
             channel.receive()
         }
         assertNull(value)
@@ -103,8 +104,8 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     fun testInnerTimeout() = runTest(
         expected = { it is CancellationException }
     ) {
-        withTimeoutOrNull(Duration.milliseconds(1000)) {
-            withTimeout(Duration.milliseconds(10)) {
+        withTimeoutOrNull(1000.milliseconds) {
+            withTimeout(10.milliseconds) {
                 while (true) {
                     yield()
                 }
@@ -119,7 +120,7 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     fun testNestedTimeout() = runTest(expected = { it is TimeoutCancellationException }) {
         withTimeoutOrNull(Duration.INFINITE) {
             // Exception from this withTimeout is not suppressed by withTimeoutOrNull
-            withTimeout(Duration.milliseconds(10)) {
+            withTimeout(10.milliseconds) {
                 delay(Duration.INFINITE)
                 1
             }
@@ -131,9 +132,9 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testOuterTimeout() = runTest {
         var counter = 0
-        val result = withTimeoutOrNull(Duration.milliseconds(250)) {
+        val result = withTimeoutOrNull(250.milliseconds) {
             while (true) {
-                val inner = withTimeoutOrNull(Duration.milliseconds(100)) {
+                val inner = withTimeoutOrNull(100.milliseconds) {
                     while (true) {
                         yield()
                     }
@@ -149,7 +150,7 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testBadClass() = runTest {
         val bad = BadClass()
-        val result = withTimeoutOrNull(Duration.milliseconds(100)) {
+        val result = withTimeoutOrNull(100.milliseconds) {
             bad
         }
         assertSame(bad, result)
@@ -164,9 +165,9 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testNullOnTimeout() = runTest {
         expect(1)
-        val result = withTimeoutOrNull(Duration.milliseconds(100)) {
+        val result = withTimeoutOrNull(100.milliseconds) {
             expect(2)
-            delay(Duration.milliseconds(1000))
+            delay(1000.milliseconds)
             expectUnreached()
             "OK"
         }
@@ -177,10 +178,10 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testSuppressExceptionWithResult() = runTest {
         expect(1)
-        val result = withTimeoutOrNull(Duration.milliseconds(100)) {
+        val result = withTimeoutOrNull(100.milliseconds) {
             expect(2)
             try {
-                delay(Duration.milliseconds(1000))
+                delay(1000.milliseconds)
             } catch (e: CancellationException) {
                 expect(3)
             }
@@ -194,10 +195,10 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     fun testSuppressExceptionWithAnotherException() = runTest {
         expect(1)
         try {
-            withTimeoutOrNull(Duration.milliseconds(100)) {
+            withTimeoutOrNull(100.milliseconds) {
                 expect(2)
                 try {
-                    delay(Duration.milliseconds(1000))
+                    delay(1000.milliseconds)
                 } catch (e: CancellationException) {
                     expect(3)
                     throw TestException()
@@ -216,11 +217,11 @@ class WithTimeoutOrNullDurationTest : TestBase() {
     @Test
     fun testNegativeTimeout() = runTest {
         expect(1)
-        var result = withTimeoutOrNull(-Duration.milliseconds(1)) {
+        var result = withTimeoutOrNull(-1.milliseconds) {
             expectUnreached()
         }
         assertNull(result)
-        result = withTimeoutOrNull(Duration.milliseconds(0)) {
+        result = withTimeoutOrNull(0.milliseconds) {
             expectUnreached()
         }
         assertNull(result)
@@ -232,7 +233,7 @@ class WithTimeoutOrNullDurationTest : TestBase() {
         expect(1)
         try {
             expect(2)
-            withTimeoutOrNull<Unit>(Duration.milliseconds(1000)) {
+            withTimeoutOrNull<Unit>(1000.milliseconds) {
                 expect(3)
                 throw TestException()
             }
diff --git a/kotlinx-coroutines-core/common/test/flow/operators/DebounceTest.kt b/kotlinx-coroutines-core/common/test/flow/operators/DebounceTest.kt
index aa0893e888..0268a232a4 100644
--- a/kotlinx-coroutines-core/common/test/flow/operators/DebounceTest.kt
+++ b/kotlinx-coroutines-core/common/test/flow/operators/DebounceTest.kt
@@ -7,7 +7,7 @@ package kotlinx.coroutines.flow
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.*
 import kotlin.test.*
-import kotlin.time.*
+import kotlin.time.Duration.Companion.milliseconds
 
 class DebounceTest : TestBase() {
     @Test
@@ -198,31 +198,29 @@ class DebounceTest : TestBase() {
         finish(4)
     }
 
-    @ExperimentalTime
     @Test
     fun testDurationBasic() = withVirtualTime {
         expect(1)
         val flow = flow {
             expect(3)
             emit("A")
-            delay(Duration.milliseconds(1500))
+            delay(1500.milliseconds)
             emit("B")
-            delay(Duration.milliseconds(500))
+            delay(500.milliseconds)
             emit("C")
-            delay(Duration.milliseconds(250))
+            delay(250.milliseconds)
             emit("D")
-            delay(Duration.milliseconds(2000))
+            delay(2000.milliseconds)
             emit("E")
             expect(4)
         }
 
         expect(2)
-        val result = flow.debounce(Duration.milliseconds(1000)).toList()
+        val result = flow.debounce(1000.milliseconds).toList()
         assertEquals(listOf("A", "D", "E"), result)
         finish(5)
     }
 
-    @ExperimentalTime
     @Test
     fun testDebounceSelectorBasic() = withVirtualTime {
         expect(1)
@@ -271,7 +269,6 @@ class DebounceTest : TestBase() {
         finish(5)
     }
 
-    @ExperimentalTime
     @Test
     fun testZeroDebounceTimeSelector() = withVirtualTime {
         expect(1)
@@ -289,20 +286,19 @@ class DebounceTest : TestBase() {
         finish(5)
     }
 
-    @ExperimentalTime
     @Test
     fun testDebounceDurationSelectorBasic() = withVirtualTime {
         expect(1)
         val flow = flow {
             expect(3)
             emit("A")
-            delay(Duration.milliseconds(1500))
+            delay(1500.milliseconds)
             emit("B")
-            delay(Duration.milliseconds(500))
+            delay(500.milliseconds)
             emit("C")
-            delay(Duration.milliseconds(250))
+            delay(250.milliseconds)
             emit("D")
-            delay(Duration.milliseconds(2000))
+            delay(2000.milliseconds)
             emit("E")
             expect(4)
         }
@@ -310,9 +306,9 @@ class DebounceTest : TestBase() {
         expect(2)
         val result = flow.debounce {
             if (it == "C") {
-                Duration.milliseconds(0)
+                0.milliseconds
             } else {
-                Duration.milliseconds(1000)
+                1000.milliseconds
             }
         }.toList()
 
diff --git a/kotlinx-coroutines-core/common/test/flow/operators/SampleTest.kt b/kotlinx-coroutines-core/common/test/flow/operators/SampleTest.kt
index f7741fbd59..3c04abdd99 100644
--- a/kotlinx-coroutines-core/common/test/flow/operators/SampleTest.kt
+++ b/kotlinx-coroutines-core/common/test/flow/operators/SampleTest.kt
@@ -9,6 +9,7 @@ import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.flow.*
 import kotlin.test.*
 import kotlin.time.*
+import kotlin.time.Duration.Companion.milliseconds
 
 class SampleTest : TestBase() {
     @Test
@@ -273,26 +274,25 @@ class SampleTest : TestBase() {
         finish(4)
     }
 
-    @ExperimentalTime
     @Test
-    public fun testDurationBasic() = withVirtualTime {
+    fun testDurationBasic() = withVirtualTime {
         expect(1)
         val flow = flow {
             expect(3)
             emit("A")
-            delay(Duration.milliseconds(1500))
+            delay(1500.milliseconds)
             emit("B")
-            delay(Duration.milliseconds(500))
+            delay(500.milliseconds)
             emit("C")
-            delay(Duration.milliseconds(250))
+            delay(250.milliseconds)
             emit("D")
-            delay(Duration.milliseconds(2000))
+            delay(2000.milliseconds)
             emit("E")
             expect(4)
         }
 
         expect(2)
-        val result = flow.sample(Duration.milliseconds(1000)).toList()
+        val result = flow.sample(1000.milliseconds).toList()
         assertEquals(listOf("A", "B", "D"), result)
         finish(5)
     }
diff --git a/kotlinx-coroutines-core/common/test/flow/sharing/SharingStartedWhileSubscribedTest.kt b/kotlinx-coroutines-core/common/test/flow/sharing/SharingStartedWhileSubscribedTest.kt
index 3b961c5783..da2f3e5f3f 100644
--- a/kotlinx-coroutines-core/common/test/flow/sharing/SharingStartedWhileSubscribedTest.kt
+++ b/kotlinx-coroutines-core/common/test/flow/sharing/SharingStartedWhileSubscribedTest.kt
@@ -28,7 +28,6 @@ class SharingStartedWhileSubscribedTest : TestBase() {
         }
     }
 
-    @OptIn(ExperimentalTime::class)
     @Test
     fun testDurationParams() {
         assertEquals(SharingStarted.WhileSubscribed(0), SharingStarted.WhileSubscribed(Duration.ZERO))
@@ -37,7 +36,7 @@ class SharingStartedWhileSubscribedTest : TestBase() {
         assertEquals(SharingStarted.WhileSubscribed(Long.MAX_VALUE), SharingStarted.WhileSubscribed(Duration.INFINITE))
         assertEquals(SharingStarted.WhileSubscribed(replayExpirationMillis = 0), SharingStarted.WhileSubscribed(replayExpiration = Duration.ZERO))
         assertEquals(SharingStarted.WhileSubscribed(replayExpirationMillis = 3), SharingStarted.WhileSubscribed(
-            replayExpiration = Duration.milliseconds(3)
+            replayExpiration = 3.milliseconds
         ))
         assertEquals(SharingStarted.WhileSubscribed(replayExpirationMillis = 7000),
             SharingStarted.WhileSubscribed(replayExpiration = 7.seconds))
diff --git a/kotlinx-coroutines-core/common/test/selects/SelectTimeoutDurationTest.kt b/kotlinx-coroutines-core/common/test/selects/SelectTimeoutDurationTest.kt
index 26d6f809b8..62e62e5f2c 100644
--- a/kotlinx-coroutines-core/common/test/selects/SelectTimeoutDurationTest.kt
+++ b/kotlinx-coroutines-core/common/test/selects/SelectTimeoutDurationTest.kt
@@ -7,22 +7,23 @@ package kotlinx.coroutines.selects
 import kotlinx.coroutines.*
 import kotlin.test.*
 import kotlin.time.*
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
 
-@ExperimentalTime
 class SelectTimeoutDurationTest : TestBase() {
     @Test
     fun testBasic() = runTest {
         expect(1)
         val result = select<String> {
-            onTimeout(Duration.milliseconds(1000)) {
+            onTimeout(1000.milliseconds) {
                 expectUnreached()
                 "FAIL"
             }
-            onTimeout(Duration.milliseconds(100)) {
+            onTimeout(100.milliseconds) {
                 expect(2)
                 "OK"
             }
-            onTimeout(Duration.milliseconds(500)) {
+            onTimeout(500.milliseconds) {
                 expectUnreached()
                 "FAIL"
             }
@@ -35,7 +36,7 @@ class SelectTimeoutDurationTest : TestBase() {
     fun testZeroTimeout() = runTest {
         expect(1)
         val result = select<String> {
-            onTimeout(Duration.seconds(1)) {
+            onTimeout(1.seconds) {
                 expectUnreached()
                 "FAIL"
             }
@@ -52,11 +53,11 @@ class SelectTimeoutDurationTest : TestBase() {
     fun testNegativeTimeout() = runTest {
         expect(1)
         val result = select<String> {
-            onTimeout(Duration.seconds(1)) {
+            onTimeout(1.seconds) {
                 expectUnreached()
                 "FAIL"
             }
-            onTimeout(-Duration.milliseconds(10)) {
+            onTimeout(-10.milliseconds) {
                 expect(2)
                 "OK"
             }
@@ -71,13 +72,13 @@ class SelectTimeoutDurationTest : TestBase() {
         val iterations =10_000
         for (i in 0..iterations) {
             val result = selectUnbiased<Int> {
-                onTimeout(-Duration.seconds(1)) {
+                onTimeout((-1).seconds) {
                     0
                 }
                 onTimeout(Duration.ZERO) {
                     1
                 }
-                onTimeout(Duration.seconds(1)) {
+                onTimeout(1.seconds) {
                     expectUnreached()
                     2
                 }
diff --git a/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-01.kt b/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-01.kt
index 8c98684ed9..8b3d2d2422 100644
--- a/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-01.kt
+++ b/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-01.kt
@@ -1,4 +1,3 @@
-@file:OptIn(ExperimentalTime::class)
 /*
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
diff --git a/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-02.kt b/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-02.kt
index 27ee7a88f5..6500ecd35c 100644
--- a/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-02.kt
+++ b/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-02.kt
@@ -1,4 +1,3 @@
-@file:OptIn(ExperimentalTime::class)
 /*
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
diff --git a/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-03.kt b/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-03.kt
index 8a53979c33..4d5e40d78d 100644
--- a/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-03.kt
+++ b/kotlinx-coroutines-core/jvm/test/examples/example-delay-duration-03.kt
@@ -1,4 +1,3 @@
-@file:OptIn(ExperimentalTime::class)
 /*
  * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
diff --git a/kotlinx-coroutines-core/jvm/test/flow/SharedFlowStressTest.kt b/kotlinx-coroutines-core/jvm/test/flow/SharedFlowStressTest.kt
index 62a217cefa..58e3ef406f 100644
--- a/kotlinx-coroutines-core/jvm/test/flow/SharedFlowStressTest.kt
+++ b/kotlinx-coroutines-core/jvm/test/flow/SharedFlowStressTest.kt
@@ -10,9 +10,8 @@ import org.junit.*
 import org.junit.Test
 import kotlin.collections.ArrayList
 import kotlin.test.*
-import kotlin.time.*
+import kotlin.time.Duration.Companion.seconds
 
-@ExperimentalTime
 class SharedFlowStressTest : TestBase() {
     private val nProducers = 5
     private val nConsumers = 3
@@ -71,7 +70,7 @@ class SharedFlowStressTest : TestBase() {
         var lastProduced = 0L
         var lastConsumed = 0L
         for (sec in 1..nSeconds) {
-            delay(Duration.seconds(1))
+            delay(1.seconds)
             val produced = totalProduced.value
             val consumed = totalConsumed.value
             println("$sec sec: produced = $produced; consumed = $consumed")
diff --git a/kotlinx-coroutines-test/common/test/Helpers.kt b/kotlinx-coroutines-test/common/test/Helpers.kt
index a63311b7e4..98375b0905 100644
--- a/kotlinx-coroutines-test/common/test/Helpers.kt
+++ b/kotlinx-coroutines-test/common/test/Helpers.kt
@@ -28,7 +28,6 @@ inline fun <T> assertRunsFast(timeout: Duration, block: () -> T): T {
 /**
  * Asserts that a block completed within two seconds.
  */
-@OptIn(ExperimentalTime::class)
 inline fun <T> assertRunsFast(block: () -> T): T = assertRunsFast(2.seconds, block)
 
 /**