diff --git a/gradle/build-logic/build.gradle.kts b/gradle/build-logic/build.gradle.kts
index 4202fa6..4ee0950 100644
--- a/gradle/build-logic/build.gradle.kts
+++ b/gradle/build-logic/build.gradle.kts
@@ -4,7 +4,6 @@ plugins {
 
 dependencies {
     implementation(libs.plugins.kotlin.jvm.toDep())
-    implementation(libs.plugins.kotlin.serialization.toDep())
     implementation(libs.plugins.kotlin.parcelize.toDep())
     implementation(libs.plugins.android.toDep())
     implementation(libs.plugins.binary.toDep())
diff --git a/gradle/build-logic/settings.gradle.kts b/gradle/build-logic/settings.gradle.kts
index 194db1e..ce48abd 100644
--- a/gradle/build-logic/settings.gradle.kts
+++ b/gradle/build-logic/settings.gradle.kts
@@ -1,6 +1,7 @@
 dependencyResolutionManagement {
     repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
     repositories {
+        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap")
         mavenCentral()
         google()
         gradlePluginPortal()
diff --git a/gradle/build-logic/src/main/kotlin/KotlinConfig.kt b/gradle/build-logic/src/main/kotlin/KotlinConfig.kt
index 1578b43..c7e7e8a 100644
--- a/gradle/build-logic/src/main/kotlin/KotlinConfig.kt
+++ b/gradle/build-logic/src/main/kotlin/KotlinConfig.kt
@@ -8,7 +8,7 @@ fun KotlinProjectExtension.kotlinConfig() {
     sourceSets.configureEach {
         languageSettings {
             progressiveMode = true
-            optIn("kotlinx.uuid.InternalAPI")
+            optIn("kotlin.ExperimentalStdlibApi")
         }
     }
 }
diff --git a/gradle/build-logic/src/main/kotlin/kotlinJvm.gradle.kts b/gradle/build-logic/src/main/kotlin/kotlinJvm.gradle.kts
index d87aca3..30209f4 100644
--- a/gradle/build-logic/src/main/kotlin/kotlinJvm.gradle.kts
+++ b/gradle/build-logic/src/main/kotlin/kotlinJvm.gradle.kts
@@ -1,6 +1,5 @@
 plugins {
     kotlin("jvm")
-    kotlin("plugin.serialization")
 }
 
 kotlin {
diff --git a/gradle/build-logic/src/main/kotlin/kotlinMPP.gradle.kts b/gradle/build-logic/src/main/kotlin/kotlinMPP.gradle.kts
index 2570e61..bcf9795 100644
--- a/gradle/build-logic/src/main/kotlin/kotlinMPP.gradle.kts
+++ b/gradle/build-logic/src/main/kotlin/kotlinMPP.gradle.kts
@@ -1,6 +1,5 @@
 plugins {
     kotlin("multiplatform")
-    kotlin("plugin.serialization")
 }
 
 kotlin {
@@ -8,6 +7,9 @@ kotlin {
     js(IR) {
         browser()
         nodejs()
+        compilerOptions {
+            target.set("es2015")
+        }
     }
 
     // tier 1
diff --git a/gradle/build-logic/src/main/kotlin/mySettings.settings.gradle.kts b/gradle/build-logic/src/main/kotlin/mySettings.settings.gradle.kts
index 4902444..7fa2247 100644
--- a/gradle/build-logic/src/main/kotlin/mySettings.settings.gradle.kts
+++ b/gradle/build-logic/src/main/kotlin/mySettings.settings.gradle.kts
@@ -1,5 +1,6 @@
 dependencyResolutionManagement {
     repositories {
+        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap")
         mavenCentral()
         google()
     }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 629b379..d50ed4c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,5 +1,5 @@
 [versions]
-kotlin = "2.0.0"
+kotlin = "2.0.20-dev-7572"
 serialization = "1.7.1"
 exposed = "0.52.0"
 
@@ -24,7 +24,7 @@ androidx-test-runner = { module = "androidx.test:runner", version = "1.6.1" }
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
 kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 kotlin-parcelize = { id = "org.jetbrains.kotlin.plugin.parcelize", version.ref = "kotlin" }
-android = { id = "com.android.application", version = "8.5.0" }
+android = { id = "com.android.application", version = "8.3.0" }
 binary = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version = "0.14.0" }
 publish = { id = "io.github.gradle-nexus.publish-plugin", version = "2.0.0" }
 dokka = { id = "org.jetbrains.dokka", version = "1.9.20" }
diff --git a/kotlinx-uuid-core/build.gradle.kts b/kotlinx-uuid-core/build.gradle.kts
index ea084b7..4cba3a3 100644
--- a/kotlinx-uuid-core/build.gradle.kts
+++ b/kotlinx-uuid-core/build.gradle.kts
@@ -15,27 +15,12 @@ plugins {
 }
 
 kotlin {
-    applyDefaultHierarchyTemplate {
-        common {
-            group("linuxDerivat") {
-                group("androidNative")
-                group("linux")
-            }
-        }
-    }
+    applyDefaultHierarchyTemplate()
 
     sourceSets {
-        commonMain {
-            dependencies {
-                implementation(libs.serialization.core)
-            }
-        }
         commonTest {
             dependencies {
                 implementation(kotlin("test"))
-                implementation(libs.serialization.json)
-                implementation(libs.serialization.cbor)
-                implementation(libs.serialization.protobuf)
             }
         }
     }
@@ -80,8 +65,4 @@ kotlin {
             }
         }
     }
-    compilerOptions.freeCompilerArgs.addAll(
-        "-P",
-        "plugin:org.jetbrains.kotlin.parcelize:additionalAnnotation=kotlinx.uuid.internal.CommonParcelize",
-    )
 }
diff --git a/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/SecureRandom.android.kt b/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/SecureRandom.android.kt
deleted file mode 100644
index 436a4d6..0000000
--- a/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/SecureRandom.android.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package kotlinx.uuid
-
-import kotlin.random.*
-
-/**
- * Returns a platform dependent SecureRandom instance.
- * - On JVM, it uses `java.util.SecureRandom`
- * - On JS, it uses `window.crypto` or `nodejs.crypto`.
- * - On darwin, it uses `SecRandomCopyBytes`.
- * - On mingw, it uses `BCryptRandom`.
- * - On Linux and Android native, it uses `DevUrandom`.
- */
-public actual val SecureRandom: Random = java.security.SecureRandom().asKotlinRandom()
diff --git a/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/internal/CommonParcelable.android.kt b/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/internal/CommonParcelable.android.kt
deleted file mode 100644
index b0f1a52..0000000
--- a/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/internal/CommonParcelable.android.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package kotlinx.uuid.internal
-
-import android.os.*
-
-public actual typealias CommonParcelable = Parcelable
diff --git a/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/internal/Parcelabler.kt b/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/internal/Parcelabler.kt
new file mode 100644
index 0000000..59ebf4a
--- /dev/null
+++ b/kotlinx-uuid-core/src/androidMain/kotlin/kotlinx/uuid/internal/Parcelabler.kt
@@ -0,0 +1,18 @@
+package kotlinx.uuid.internal
+
+import android.os.Parcel
+import kotlinx.parcelize.Parceler
+
+public object UuidParceler : Parceler<kotlin.uuid.Uuid> {
+    override fun create(parcel: Parcel): kotlin.uuid.Uuid = kotlin.uuid.Uuid.fromLongs(
+        parcel.readLong(),
+        parcel.readLong(),
+    )
+
+    override fun kotlin.uuid.Uuid.write(parcel: Parcel, flags: Int) {
+        toLongs { mostSignificantBits, leastSignificantBits ->
+            parcel.writeLong(mostSignificantBits)
+            parcel.writeLong(leastSignificantBits)
+        }
+    }
+}
diff --git a/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/Converter.kt b/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/Converter.kt
index 2238b98..7a8850b 100644
--- a/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/Converter.kt
+++ b/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/Converter.kt
@@ -4,14 +4,16 @@
 
 package kotlinx.uuid
 
+import kotlin.uuid.Uuid
+
 /**
  * Converts this [platform.Foundation.NSUUID][platform.Foundation.NSUUID] value to a [kotlinx.uuid.UUID][UUID] value
  * by using the [UUIDString][platform.Foundation.NSUUID.UUIDString] representation.
  */
-public fun platform.Foundation.NSUUID.toKotlinUUID(): UUID = UUID(UUIDString)
+public fun platform.Foundation.NSUUID.toKotlinUUID(): Uuid = Uuid.parse(UUIDString)
 
 /**
  * Converts this [kotlinx.uuid.UUID][UUID] value to a [platform.Foundation.NSUUID][platform.Foundation.NSUUID] value
  * by using the default [toString] representation.
  */
-public fun UUID.toNsUUID(): platform.Foundation.NSUUID = platform.Foundation.NSUUID(toString())
+public fun Uuid.toNsUUID(): platform.Foundation.NSUUID = platform.Foundation.NSUUID(toString())
diff --git a/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/SecureRandom.apple.kt b/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/SecureRandom.apple.kt
deleted file mode 100644
index 2d89cdd..0000000
--- a/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/SecureRandom.apple.kt
+++ /dev/null
@@ -1,26 +0,0 @@
-package kotlinx.uuid
-
-import kotlinx.cinterop.*
-import kotlinx.uuid.internal.*
-import platform.Security.*
-import platform.darwin.*
-import kotlin.random.*
-
-public actual val SecureRandom: Random = SecureRandomIos
-
-/**
- * https://developer.apple.com/documentation/security/1399291-secrandomcopybytes?language=objc
- */
-@OptIn(ExperimentalForeignApi::class)
-private object SecureRandomIos : Random() {
-    @OptIn(UnsafeNumber::class)
-    override fun nextBits(bitCount: Int): Int {
-        require(bitCount > 0)
-        val numberOfBytes = (bitCount + Byte.SIZE_BITS) / Byte.SIZE_BITS
-        val bytes = ByteArray(size = numberOfBytes)
-        val status = SecRandomCopyBytes(kSecRandomDefault, numberOfBytes.convert(), bytes.refTo(0))
-
-        require(status == errSecSuccess)
-        return bytes.toInt()
-    }
-}
diff --git a/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/internal/CommonParcelable.apple.kt b/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/internal/CommonParcelable.apple.kt
deleted file mode 100644
index 76c06b9..0000000
--- a/kotlinx-uuid-core/src/appleMain/kotlin/kotlinx/uuid/internal/CommonParcelable.apple.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package kotlinx.uuid.internal
-
-public actual interface CommonParcelable
diff --git a/kotlinx-uuid-core/src/appleTest/kotlin/kotlinx/uuid/NsUUIDConvertingTest.kt b/kotlinx-uuid-core/src/appleTest/kotlin/kotlinx/uuid/NsUUIDConvertingTest.kt
index ebcc0a4..375fe2f 100644
--- a/kotlinx-uuid-core/src/appleTest/kotlin/kotlinx/uuid/NsUUIDConvertingTest.kt
+++ b/kotlinx-uuid-core/src/appleTest/kotlin/kotlinx/uuid/NsUUIDConvertingTest.kt
@@ -9,12 +9,13 @@
 package kotlinx.uuid
 
 import kotlin.test.*
+import kotlin.uuid.Uuid
 
 class NsUUIDConvertingTest {
 
     @Test
     fun toNsUUID() {
-        val kotlinUUID = UUID(SOME_UUID_STRING)
+        val kotlinUUID = Uuid.parse(SOME_UUID_STRING)
         val nsUUID = kotlinUUID.toNsUUID()
         assertEquals(SOME_UUID_STRING, nsUUID.UUIDString.lowercase())
     }
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/BinarySerializer.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/BinarySerializer.kt
deleted file mode 100644
index ed7aaa3..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/BinarySerializer.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-import kotlinx.serialization.*
-import kotlinx.serialization.builtins.*
-import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.encoding.*
-
-/**
- * This serializer is useful with binary formats to reduce size. You may also use it with
- * text formats like json, but it is not that useful (because there will be no size gain)
- * and a serialized UUID is not human-readable.
- *
- * With this serializer, a UUID is represented as an array of long with two elements.
- *
- * Example:
- * ```kotlin
- * Cbor.encodeToByteArray(BinarySerializer, myUUID)
- * ```
- */
-public object BinarySerializer : KSerializer<UUID> {
-    private val serializer = LongArraySerializer()
-    override val descriptor: SerialDescriptor = serializer.descriptor
-
-    override fun serialize(encoder: Encoder, value: UUID) {
-        encoder.encodeSerializableValue(serializer, value.encodeToLongArray())
-    }
-
-    override fun deserialize(decoder: Decoder): UUID {
-        return decoder.decodeSerializableValue(serializer).let { array ->
-            if (array.size != 2) {
-                throw SerializationException("UUID array should consist of 2 elements")
-            }
-
-            UUID(array)
-        }
-    }
-}
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Encoding.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Encoding.kt
deleted file mode 100644
index f57e04d..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Encoding.kt
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-internal const val UUID_BYTE_ARRAY_SIZE: Int = 16
-
-/**
- * Encode [UUID] as a byte array in its classic format, just like in text format, but as bytes.
- */
-public fun UUID.encodeToByteArray(): ByteArray {
-    val result = ByteArray(UUID_BYTE_ARRAY_SIZE)
-    timeStampAndVersionRaw.copyInto(result, 0)
-    clockSequenceVariantAndNodeRaw.copyInto(result, 8)
-    return result
-}
-
-/**
- * Encodes [UUID] as a pair of long: there first long contains timestamp and version bits,
- * the second one consists of clock sequence, variant and node.
- */
-public fun UUID.encodeToLongArray(): LongArray {
-    return longArrayOf(timeStampAndVersionRaw, clockSequenceVariantAndNodeRaw)
-}
-
-/**
- * Creates [UUID] from bytes representation.
- */
-public fun UUID(bytes: ByteArray): UUID {
-    require(bytes.size == UUID_BYTE_ARRAY_SIZE) {
-        "Input ByteArray should have size $UUID_BYTE_ARRAY_SIZE, but got array of ${bytes.size} bytes."
-    }
-
-    return UUID.create(
-        bytes.getLongAt(0),
-        bytes.getLongAt(8)
-    )
-}
-
-/**
- * Creates an instance of [UUID] from [longPair] where the first long value
- * is timestamp and version bits and the second one consists of clock sequence,
- * variant and node.
- */
-public fun UUID(longPair: LongArray): UUID {
-    require(longPair.size == 2) { "Input LongArray should have size 2, but got array of ${longPair.size} values." }
-    return UUID.create(
-        longPair[0],
-        longPair[1]
-    )
-}
-
-private fun Long.copyInto(buffer: ByteArray, destinationOffset: Int) {
-    repeat(8) { index ->
-        buffer[destinationOffset + index] = (this ushr (56 - index * 8)).toByte()
-    }
-}
-
-private fun ByteArray.getLongAt(offset: Int): Long {
-    var result = 0L
-
-    repeat(8) { index ->
-        result = result or (this[offset + index].toLong() and 0xff shl ((7 - index) * 8))
-    }
-
-    return result
-}
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Formatter.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Formatter.kt
deleted file mode 100644
index fe83f87..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Formatter.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-/**
- * Renders UUID in the RFC format: five groups of hexademical parts separated with
- * minus characters and surrounded with curly brackets if [includeBrackets] is `true`,
- * without spaces.
- * `{1b3e4567-e99b-13d3-a476-446657420000}`
- */
-internal fun formatUUID(
-    timeStampAndVersionRaw: Long,
-    clockSequenceVariantAndNodeRaw: Long,
-    includeBrackets: Boolean
-): String = buildString(38) {
-    if (includeBrackets) {
-        append('{')
-    }
-    dumpHex(timeStampAndVersionRaw ushr 32, 4, this)
-    append('-')
-    dumpHex(timeStampAndVersionRaw ushr 16 and 0xffff, 2, this)
-    append('-')
-    dumpHex(timeStampAndVersionRaw and 0xffff, 2, this)
-    append('-')
-    dumpHex(clockSequenceVariantAndNodeRaw shr 48 and 0xffff, 2, this)
-    append('-')
-    dumpHex(clockSequenceVariantAndNodeRaw and 0xffffffffffffL, 6, this)
-    if (includeBrackets) {
-        append('}')
-    }
-}
-
-internal fun dumpHex(value: Long, numberOfOctets: Int, out: StringBuilder) {
-    repeat(numberOfOctets) { index ->
-        val octet = value ushr ((numberOfOctets - index - 1) * 8)
-        dumpHalfByte(octet.toInt() shr 4, out)
-        dumpHalfByte(octet.toInt(), out)
-    }
-}
-
-private fun dumpHalfByte(value: Int, out: StringBuilder) {
-    val half = value and 0x0f
-    out.append(
-        when {
-            half <= 9 -> '0' + half
-            else -> 'a' + half - 10
-        }
-    )
-}
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Migration.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Migration.kt
deleted file mode 100644
index 685548a..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Migration.kt
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-import kotlin.random.*
-
-@Deprecated(
-    "Use version or versionNumber instead",
-    ReplaceWith("versionNumber")
-)
-public fun UUID.version(): Int = versionNumber
-
-@Deprecated("Use variant property instead", ReplaceWith("variant"))
-public fun UUID.variant(): Int = variant
-
-@Deprecated("Use timeStamp property instead", ReplaceWith("timeStamp"))
-public fun UUID.timestamp(): Long = timeStamp
-
-@Deprecated("Use clockSequence property instead", ReplaceWith("clockSequence"))
-public fun UUID.clockSequence(): Int = clockSequence
-
-@Deprecated("Use node property instead", ReplaceWith("node"))
-public fun UUID.node(): Long = node
-
-@Deprecated("Use UUID constructor instead", ReplaceWith("UUID(name)"))
-public fun UUID.Companion.fromString(name: String): UUID = UUID(name)
-
-@Deprecated(
-    "Use UUID.generateUUID instead specifying Random if necessary (the default is non-secure!)",
-    level = DeprecationLevel.ERROR,
-    replaceWith = ReplaceWith("generateUUID(Random.Default)", "kotlin.random.Random"),
-)
-public fun UUID.Companion.randomUUID(): UUID {
-    return generateUUID(Random.Default)
-}
-
-@Deprecated(
-    "Use UUID.generateUUID instead that does SHA-1 instead of MD5. " +
-        "So for the same input bytes it will produce other UUID than java.util.UUID.",
-    level = DeprecationLevel.ERROR,
-    replaceWith = ReplaceWith("UUID.generateUUID(bytes)")
-)
-@Suppress("unused_parameter")
-public fun UUID.Companion.nameUUIDFromBytes(bytes: ByteArray): UUID {
-    return UUID.generateUUID(bytes)
-}
-
-@Suppress("DeprecatedCallableAddReplaceWith")
-@Deprecated(
-    "This is internal details that shouldn't be used. " +
-        "Please suppress and file a ticket if it is actually required.",
-    level = DeprecationLevel.ERROR
-)
-public fun UUID.getLeastSignificantBits(): Long = clockSequenceVariantAndNodeRaw
-
-@Suppress("DeprecatedCallableAddReplaceWith")
-@Deprecated(
-    "This is internal details that shouldn't be used. " +
-        "Please suppress and file a ticket if it is actually required.",
-    level = DeprecationLevel.ERROR
-)
-public fun UUID.getMostSignificantBits(): Long = timeStampAndVersionRaw
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/NameBasedGenerator.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/NameBasedGenerator.kt
index 05422cb..c3e9097 100644
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/NameBasedGenerator.kt
+++ b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/NameBasedGenerator.kt
@@ -6,25 +6,26 @@ package kotlinx.uuid
 
 import kotlinx.uuid.internal.*
 import kotlin.experimental.*
+import kotlin.uuid.Uuid
 
 /**
- * Generates a [UUID] instance by [namespace] and [name] applying SHA-1.
+ * Generates a [Uuid] instance by [namespace] and [name] applying SHA-1.
  * It doesn't use any random source, so it will produce the same result for
  * the same input values.
  *
  * See [RFC4122 sec 4.3](https://tools.ietf.org/html/rfc4122#section-4.3)
  */
-public fun UUID.Companion.generateUUID(namespace: UUID, name: String): UUID {
+public fun Uuid.Companion.generateUUID(namespace: Uuid, name: String): Uuid {
     val hash = sha1 {
-        update(namespace.encodeToByteArray())
+        update(namespace.toByteArray())
         update(name.encodeToByteArray())
     }
 
-    return generateUUIDByHash(hash, version = UUID.Version.NAME_BASED_SHA1.id)
+    return generateUUIDByHash(hash, version = 5)
 }
 
 /**
- * Generates a [UUID] instance by input [bytes] applying SHA-1.
+ * Generates a [Uuid] instance by input [bytes] applying SHA-1.
  * It doesn't use any random source, so it will produce the same result for
  * the same input values.
  *
@@ -33,12 +34,12 @@ public fun UUID.Companion.generateUUID(namespace: UUID, name: String): UUID {
  * It is recommended to use generateUUID(namespace, name) instead while this function
  * is more for java.util.UUID parity.
  */
-public fun UUID.Companion.generateUUID(bytes: ByteArray): UUID {
+public fun Uuid.Companion.generateUUID(bytes: ByteArray): Uuid {
     val hash = sha1 {
         update(bytes)
     }
 
-    return generateUUIDByHash(hash, version = UUID.Version.NAME_BASED_SHA1.id)
+    return generateUUIDByHash(hash, version = 5)
 }
 
 private inline fun sha1(builder: SHA1.() -> Unit): ByteArray {
@@ -47,9 +48,9 @@ private inline fun sha1(builder: SHA1.() -> Unit): ByteArray {
     return sha1.final()
 }
 
-private fun generateUUIDByHash(hashBytes: ByteArray, version: Int): UUID {
+private fun generateUUIDByHash(hashBytes: ByteArray, version: Int): Uuid {
     hashBytes[6] = (hashBytes[6] and 0x0f or (version shl 4).toByte())
     hashBytes[8] = hashBytes[8] and 0x3f or 0x80.toByte()
 
-    return UUID(hashBytes.copyOf(UUID_BYTE_ARRAY_SIZE))
+    return Uuid.fromByteArray(hashBytes.copyOf(16))
 }
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Parser.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Parser.kt
deleted file mode 100644
index 8f7519c..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Parser.kt
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-internal fun parseUUID(text: String): UUID {
-    var textIndex = skipCharacters(text, 0, '{')
-
-    // time low
-    var timeStampAndVersionRaw = parseOctetStride(text, textIndex, 4, 32)
-    textIndex = skipCharacters(text, textIndex + 8, '-')
-
-    // time mid
-    timeStampAndVersionRaw = timeStampAndVersionRaw or
-        parseOctetStride(text, textIndex, 2, 16)
-    textIndex = skipCharacters(text, textIndex + 4, '-')
-
-    // time high and version
-    timeStampAndVersionRaw = timeStampAndVersionRaw or
-        parseOctetStride(text, textIndex, 2, 0)
-    textIndex = skipCharacters(text, textIndex + 4, '-')
-
-    // variant + clock
-    var clockSequenceVariantAndNodeRaw = parseOctetStride(text, textIndex, 2, 48)
-    textIndex = skipCharacters(text, textIndex + 4, '-')
-
-    // node
-    clockSequenceVariantAndNodeRaw = clockSequenceVariantAndNodeRaw or
-        parseOctetStride(text, textIndex, 6, 0)
-
-    textIndex = skipCharacters(text, textIndex + 12, '}')
-
-    if (textIndex < text.length) {
-        error("extra trailing characters ${text.substring(textIndex)}", text, textIndex)
-    }
-
-    return UUID.create(timeStampAndVersionRaw, clockSequenceVariantAndNodeRaw)
-}
-
-private fun parseOctetStride(
-    text: String,
-    textIndex: Int,
-    numberOfOctets: Int,
-    shift: Int
-): Long {
-    if (text.length - textIndex < numberOfOctets * 2) {
-        errorTooShort(text)
-    }
-
-    var result = 0L
-    repeat(numberOfOctets * 2) { i ->
-        val halfByte = when (val character = text[textIndex + i]) {
-            in '0'..'9' -> character - '0'
-            in 'a'..'f' -> character - 'a' + 10
-            in 'A'..'F' -> character - 'A' + 10
-            else -> error("Unexpected octet character $character", text, textIndex + i)
-        }
-        result = result shl 4 or halfByte.toLong()
-    }
-
-    return result shl shift
-}
-
-private fun errorTooShort(text: String) {
-    error("UUID string is too short", text, -1)
-}
-
-private fun skipCharacters(text: String, startIndex: Int, a: Char): Int {
-    for (index in startIndex until text.length) {
-        val character = text[index]
-        if (character == a || character == ' ' || character == '\t') {
-            continue
-        }
-        return index
-    }
-    return text.length
-}
-
-private fun error(message: String, text: String, index: Int): Nothing {
-    throw UUIDFormatException(
-        when (index) {
-            -1 -> "Failed to parse UUID $text: $message"
-            else -> "Failed to parse UUID $text at position $index: $message"
-        }
-    )
-}
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/RandomGenerator.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/RandomGenerator.kt
index 942faa4..1118e38 100644
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/RandomGenerator.kt
+++ b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/RandomGenerator.kt
@@ -5,24 +5,28 @@
 package kotlinx.uuid
 
 import kotlin.random.*
+import kotlin.uuid.Uuid
 
 /**
  * Generates a random UUID v4 using the specified [random] source.
  * It uses by default a [SecureRandom] instance.
  */
-public fun UUID.Companion.generateUUID(random: Random = SecureRandom): UUID {
-    // set version 4 (random)
-    val timeStampAndVersionRaw = random.nextLong() and -0xf001L or 0x4000L
-
-    // set variant to 4 or 5
-    // we keep the lower variant bit random as it is defined as "don't care"
-    val clockSequenceVariantAndNodeRaw: Long = random.nextLong() and
-        0x3fffffffffffffffL or (0x80L shl 0x38)
+public fun Uuid.Companion.random(random: Random): Uuid {
+    val randomBytes = random.nextBytes(16)
+    return uuidFromRandomBytes(randomBytes)
+}
 
-    return create(timeStampAndVersionRaw, clockSequenceVariantAndNodeRaw)
+// Copied from stdlib
+@ExperimentalStdlibApi
+private fun uuidFromRandomBytes(randomBytes: ByteArray): Uuid {
+    randomBytes[6] = (randomBytes[6].toInt() and 0x0f).toByte() /* clear version        */
+    randomBytes[6] = (randomBytes[6].toInt() or 0x40).toByte() /* set to version 4     */
+    randomBytes[8] = (randomBytes[8].toInt() and 0x3f).toByte() /* clear variant        */
+    randomBytes[8] = (randomBytes[8].toInt() or 0x80).toByte() /* set to IETF variant  */
+    return Uuid.fromByteArray(randomBytes)
 }
 
 /**
  * Generates a random UUID v4 using this [Random] instance.
  */
-public fun Random.nextUUID(): UUID = UUID.generateUUID(this)
+public fun Random.nextUUID(): Uuid = Uuid.random(this)
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/SecureRandom.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/SecureRandom.kt
deleted file mode 100644
index aaa9204..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/SecureRandom.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package kotlinx.uuid
-
-import kotlin.random.*
-
-/**
- * Returns a platform dependent SecureRandom instance.
- * - On JVM, it uses `java.util.SecureRandom`
- * - On JS, it uses `window.crypto` or `nodejs.crypto`.
- * - On darwin, it uses `SecRandomCopyBytes`.
- * - On mingw, it uses `BCryptRandom`.
- * - On Linux and Android native, it uses `DevUrandom`.
- */
-public expect val SecureRandom: Random
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Serializer.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Serializer.kt
deleted file mode 100644
index f7437e6..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/Serializer.kt
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-import kotlinx.serialization.*
-import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.encoding.*
-
-/**
- * This is the default [UUID] serializer that encodes instances as primitive strings
- * consisting of the canonical UUID string format.
- *
- * @property includeBrackets specifies, if serialized UUID should be wrapped into curly brackets
- */
-public sealed class Serializer(
-    private val includeBrackets: Boolean
-) : KSerializer<UUID> {
-    final override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("UUID", PrimitiveKind.STRING)
-
-    final override fun deserialize(decoder: Decoder): UUID {
-        return UUID(decoder.decodeString())
-    }
-
-    final override fun serialize(encoder: Encoder, value: UUID) {
-        encoder.encodeString(value.toString(includeBrackets))
-    }
-
-    /**
-     * The default serializer instance that encodes without curly brackets.
-     */
-    public object Default : Serializer(false)
-
-    /**
-     * This serializer encodes [UUID] with curly brackets
-     */
-    public object WrappedCurlyBrackets : Serializer(true)
-}
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUID.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUID.kt
index e6e1652..c005fa0 100644
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUID.kt
+++ b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUID.kt
@@ -2,224 +2,22 @@
  * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
-package kotlinx.uuid
-
-import kotlinx.serialization.*
-import kotlinx.uuid.internal.*
-import kotlin.jvm.*
-
-/**
- * This type represents a UUID as per RFC
- * See: https://tools.ietf.org/html/rfc4122
- */
-@CommonParcelize
-@Serializable(with = Serializer.Default::class)
-public class UUID internal constructor(
-    internal val timeStampAndVersionRaw: Long,
-    internal val clockSequenceVariantAndNodeRaw: Long,
-) : CommonParcelable, Comparable<UUID> {
-    private constructor(
-        helper: UUID
-    ) : this(
-        helper.timeStampAndVersionRaw,
-        helper.clockSequenceVariantAndNodeRaw
-    )
-
-    /**
-     * Creates an instance by the string [uuid] representation.
-     * An input string should consist of five hexadecimal parts
-     * separated with the minus character, and optionally surrounded with curly brackets.
-     * The space and tab characters are ignored at the end and at the beginning
-     * and surrounding brackets and minus characters.
-     *
-     * Valid examples:
-     * `1b3e4567-e99b-13d3-a476-446657420000`,
-     * ` 1b3e4567-e99b-13d3 - a476 - 446657420000 `,
-     * `{123e4567-e89b-12d3-a456-426655440000}`,
-     * `{ 123e4567-e89b-12d3-a456-426655440000}`
-     */
-    public constructor(uuid: String) : this(parseUUID(uuid))
-
-    /**
-     * Creates a new Version 4 Random based instance using a [SecureRandom] generator.
-     */
-    public constructor() : this(SecureRandom.nextUUID())
-
-    /**
-     * Creates an instance of [UUID] from components
-     */
-    public constructor(
-        versionNumber: Int,
-        timeStamp: Long,
-        clockSequence: Int,
-        node: Long,
-        variant: Int = 5
-    ) : this(
-        timeStampAndVersionRaw = (timeStamp shl 32) or (timeStamp and 0xffff00000000L shr 16) or
-            (timeStamp shr 48) or (versionNumber.toLong() shl 12),
-        clockSequenceVariantAndNodeRaw = (clockSequence.toLong() shl 48) or
-            (variant.toLong() shl 61) or node
-    ) {
-        require(versionNumber in 0..15)
-        require(variant in 0..7)
-        require(timeStamp in 0L until (1L shl 60))
-        require(node in 0L until (1L shl 48))
-        require(clockSequence in 0 until (1 shl 13))
-    }
-
-    /**
-     * Creates an instance of [UUID] from components
-     */
-    public constructor(
-        version: Version,
-        timeStamp: Long,
-        clockSequence: Int,
-        node: Long,
-        variant: Int = 5
-    ) : this(version.id, timeStamp, clockSequence, node, variant)
-
-    /**
-     * A 60-bits non-negative number. Depending on the UUID version it could have different semantics:
-     * - UTC time
-     * - a number constructed from the namespace
-     * - a random number
-     */
-    public val timeStamp: Long
-        get() = (timeStampAndVersionRaw ushr 32) or
-            (timeStampAndVersionRaw and 0xffff0000L shl 16) or
-            (timeStampAndVersionRaw and 0x0fffL shl 48)
-
-    /**
-     * 13-bits non-negative number representing a sequence number
-     * or a random number depending on UUID [version] and [variant].
-     */
-    public val clockSequence: Int
-        get() = (clockSequenceVariantAndNodeRaw shr 48 and 0x1fff).toInt()
-
-    /**
-     * UUID numeric version in range `[0..15]
-     * @see version
-     */
-    public val versionNumber: Int
-        get() = (timeStampAndVersionRaw and 0xf000L shr 12).toInt()
-
-    /**
-     * UUID RFC version or `null` if unknown version number or another variant
-     * @see versionNumber
-     */
-    public val version: Version?
-        get() = when {
-            isRfcVariant -> versionFor(versionNumber)
-            else -> null
-        }
-
-    /**
-     * UUID variant in range `[0..7]`, similar to version
-     */
-    public val variant: Int
-        get() = (clockSequenceVariantAndNodeRaw ushr 61).toInt()
+@file:OptIn(ExperimentalStdlibApi::class)
 
-    /**
-     * UUID variant specified and documented by the RFC
-     */
-    public val isRfcVariant: Boolean
-        get() = variant in 4..5
-
-    /**
-     * Node UUID part, a 48-bit non-negative number.
-     * Depending on [version] and [variant] it could be one of the following:
-     * - a MAC address
-     * - a random number
-     * - a value constructed from a namespace
-     */
-    public val node: Long
-        get() = clockSequenceVariantAndNodeRaw and 0xffffffffffffL
-
-    /**
-     * Renders UUID in the RFC format: five groups of hexademical parts separated with
-     * minus characters, without spaces and without curly brackets.
-     * `1b3e4567-e99b-13d3-a476-446657420000`
-     */
-    override fun toString(): String = toString(false)
-
-    /**
-     * Renders UUID in the RFC format: five groups of hexademical parts separated with
-     * minus characters and surrounded with curly brackets if [includeBrackets] is `true`,
-     * without spaces.
-     * `{1b3e4567-e99b-13d3-a476-446657420000}`
-     */
-    public fun toString(includeBrackets: Boolean): String =
-        formatUUID(timeStampAndVersionRaw, clockSequenceVariantAndNodeRaw, includeBrackets)
-
-    override fun hashCode(): Int {
-        return timeStampAndVersionRaw.hashCode() + clockSequenceVariantAndNodeRaw.hashCode()
-    }
-
-    override fun equals(other: Any?): Boolean {
-        return other is UUID &&
-            other.clockSequenceVariantAndNodeRaw == clockSequenceVariantAndNodeRaw &&
-            other.timeStampAndVersionRaw == timeStampAndVersionRaw
-    }
-
-    override fun compareTo(other: UUID): Int {
-        timeStampAndVersionRaw.compareTo(other.timeStampAndVersionRaw).let {
-            if (it != 0) return it
-        }
-
-        return clockSequenceVariantAndNodeRaw.compareTo(other.clockSequenceVariantAndNodeRaw)
-    }
-
-    /**
-     * UUID versions
-     * https://tools.ietf.org/html/rfc4122#section-4.1.3
-     */
-    public enum class Version(internal val id: Int) {
-        TIME_BASED(1),
-        DCE_SECURITY(2),
-        NAME_BASED_MD5(3),
-        RANDOM_BASED(4),
-        NAME_BASED_SHA1(5)
-    }
-
-    public companion object {
-        /**
-         * A Nil UUID with all fields set to zero.
-         * https://tools.ietf.org/html/rfc4122#section-4.1.7
-         */
-        public val NIL: UUID = create(0L, 0L)
-
-        /**
-         * Check the [spec] string to conform to UUID
-         * @return `true` if the [spec] string is a UUID string
-         */
-        public fun isValidUUIDString(spec: String): Boolean = try {
-            parseUUID(spec)
-            true
-        } catch (_: UUIDFormatException) {
-            false
-        }
-
-        internal fun create(
-            timeStampAndVersionRaw: Long,
-            clockSequenceVariantAndNodeRaw: Long
-        ): UUID {
-            return UUID(timeStampAndVersionRaw, clockSequenceVariantAndNodeRaw)
-        }
+package kotlinx.uuid
 
-        private fun versionFor(id: Int): Version? = Version.entries.firstOrNull { it.id == id }
-    }
-}
+import kotlin.uuid.Uuid
 
 /**
- * Convert this String to a [UUID], or throws a [UUIDFormatException] if [this] is a malformed UUID.
+ * Convert this String to a [Uuid], or throws a [IllegalArgumentException] if [this] is a malformed UUID.
  */
-public fun String.toUUID(): UUID = parseUUID(this)
+public fun String.toUuid(): Uuid = Uuid.parse(this)
 
 /**
- * Convert this String to a [UUID], or returns null if [this] is a malformed UUID.
+ * Convert this String to a [Uuid], or returns null if [this] is a malformed UUID.
  */
-public fun String.toUUIDOrNull(): UUID? = try {
-    parseUUID(this)
-} catch (_: UUIDFormatException) {
+public fun String.toUUIDOrNull(): Uuid? = try {
+    Uuid.parse(this)
+} catch (_: IllegalArgumentException) {
     null
 }
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUID7.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUID7.kt
index 09f27e1..81b2720 100644
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUID7.kt
+++ b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUID7.kt
@@ -1,6 +1,5 @@
 package kotlinx.uuid
 
-import kotlinx.uuid.UUID.Companion.create
 import kotlin.random.Random
 
 private const val UNIX_48_TIMESTAMP = 0x1FFF_FFFF_FFFF_FL
@@ -11,25 +10,27 @@ private const val UNIX_48_TIMESTAMP = 0x1FFF_FFFF_FFFF_FL
  *
  * [timeStamp] must be an 48 bit unix timestamp.
  */
-@UUIDExperimentalAPI
-public fun UUIDv7(timeStamp: Long, random: Random = SecureRandom): UUID {
+public fun UUIDv7(timeStamp: Long, random: Random): kotlin.uuid.Uuid {
     require(timeStamp <= UNIX_48_TIMESTAMP) {
         "timeStamp $timeStamp must be <= 48 bits, was $timeStamp."
     }
-    val helper = random.nextUUID()
+    val (helperTimeStampAndVersionRaw, helperClockSequenceVariantAndNodeRaw) = random.nextUUID().toLongs { mostSignificantBits, leastSignificantBits -> mostSignificantBits to leastSignificantBits }
     val leftTimeStamp = timeStamp shl 16
     // set version to 0b0111
     val leftTimeStampAndVersion = leftTimeStamp or 28672
-    val rand_a = helper.timeStamp and 4095
+    val rand_a = helperTimeStampAndVersionRaw.let { timeStampAndVersionRaw ->
+        (timeStampAndVersionRaw ushr 32) or
+            (timeStampAndVersionRaw and 0xffff0000L shl 16) or
+            (timeStampAndVersionRaw and 0x0fffL shl 48)
+    } and 4095
     val timeStampAndVersionRaw = leftTimeStampAndVersion or rand_a
     // set variant to 0b10
-    val clockSequenceVariantAndNodeRaw = (2L shl 62) or (helper.clockSequenceVariantAndNodeRaw ushr 2)
+    val clockSequenceVariantAndNodeRaw = (2L shl 62) or (helperClockSequenceVariantAndNodeRaw ushr 2)
 
-    return create(timeStampAndVersionRaw, clockSequenceVariantAndNodeRaw)
+    return kotlin.uuid.Uuid.fromLongs(timeStampAndVersionRaw, clockSequenceVariantAndNodeRaw)
 }
 
 /**
  * The UUIDv7 48 bit big-endian unsigned number of Unix epoch timestamp in milliseconds
  */
-@UUIDExperimentalAPI
-public val UUID.unixTimeStamp: Long get() = timeStampAndVersionRaw ushr 16
+public val kotlin.uuid.Uuid.unixTimeStamp: Long get() = toLongs { mostSignificantBits, _ -> mostSignificantBits ushr 16 }
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUIDExperimental.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUIDExperimental.kt
deleted file mode 100644
index 055adae..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUIDExperimental.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-/**
- * The API marked with this annotation is experimental. Its stability is not guaranteed, and you shouldn't rely on it.
- *
- * @property plannedVersion in which this API is planned to be stabilized
- */
-@RequiresOptIn(
-    "This UUID API is experimental and could be changed in future releases.",
-    level = RequiresOptIn.Level.WARNING
-)
-@Retention(AnnotationRetention.BINARY)
-@Target(
-    AnnotationTarget.CLASS,
-    AnnotationTarget.TYPEALIAS,
-    AnnotationTarget.FUNCTION,
-    AnnotationTarget.PROPERTY
-)
-public annotation class UUIDExperimentalAPI(val plannedVersion: String = "")
-
-/**
- * The API marked with this annotation is internal and should be never used
- * outside this library. It's stability, behaviour and compatibility is not guaranteed
- * and could be changed in any release without notice.
- */
-@RequiresOptIn(
-    "This API is internal",
-    level = RequiresOptIn.Level.ERROR
-)
-@Retention(AnnotationRetention.BINARY)
-@Target(
-    AnnotationTarget.CLASS,
-    AnnotationTarget.TYPEALIAS,
-    AnnotationTarget.FUNCTION,
-    AnnotationTarget.PROPERTY
-)
-public annotation class InternalAPI
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUIDFormatException.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUIDFormatException.kt
deleted file mode 100644
index c9a2c48..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/UUIDFormatException.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package kotlinx.uuid
-
-internal class UUIDFormatException(override val message: String) : IllegalArgumentException(message)
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/Parcelable.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/Parcelable.kt
deleted file mode 100644
index 15c6dd3..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/Parcelable.kt
+++ /dev/null
@@ -1,6 +0,0 @@
-package kotlinx.uuid.internal
-
-@Target(AnnotationTarget.CLASS)
-internal annotation class CommonParcelize
-
-public expect interface CommonParcelable
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/SHA1.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/SHA1.kt
index 2b738b4..a1f65c2 100644
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/SHA1.kt
+++ b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/SHA1.kt
@@ -170,37 +170,30 @@ internal class SHA1 {
         buffer.fill(0)
     }
 
-    @Suppress("NOTHING_TO_INLINE")
     private inline fun f1(m: Int, l: Int, k: Int): Int {
         return (m and l) or (m.inv() and k)
     }
 
-    @Suppress("NOTHING_TO_INLINE")
     private inline fun f2(m: Int, l: Int, k: Int): Int {
         return m xor l xor k
     }
 
-    @Suppress("NOTHING_TO_INLINE")
     private inline fun f3(m: Int, l: Int, k: Int): Int {
         return (m and l) or (m and k) or (l and k)
     }
 
-    @Suppress("NOTHING_TO_INLINE")
     private inline fun f4(m: Int, l: Int, k: Int): Int {
         return f2(m, l, k)
     }
 
-    @Suppress("NOTHING_TO_INLINE")
     private inline fun Int.rollBits1(): Int {
         return rollBitsLeft(1)
     }
 
-    @Suppress("NOTHING_TO_INLINE")
     private inline fun Int.rollBits5(): Int {
         return rollBitsLeft(5)
     }
 
-    @Suppress("NOTHING_TO_INLINE")
     private inline fun Int.rollBitsLeft(n: Int): Int {
         return (this shl n) or (this ushr (32 - n))
     }
@@ -208,7 +201,6 @@ internal class SHA1 {
     private class IntArrayView(private val bytes: ByteArray) {
         inline val size: Int get() = bytes.size / 4
 
-        @Suppress("NOTHING_TO_INLINE")
         inline operator fun get(index: Int): Int {
             val startIndex = index shl 2
             return ((bytes[startIndex].toInt() and 0xff) shl 24) or
@@ -217,7 +209,6 @@ internal class SHA1 {
                 (bytes[startIndex + 3].toInt() and 0xff)
         }
 
-        @Suppress("NOTHING_TO_INLINE")
         inline operator fun set(index: Int, value: Int) {
             val startIndex = index shl 2
 
diff --git a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/ToInt.kt b/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/ToInt.kt
deleted file mode 100644
index 64ee375..0000000
--- a/kotlinx-uuid-core/src/commonMain/kotlin/kotlinx/uuid/internal/ToInt.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package kotlinx.uuid.internal
-
-internal fun ByteArray.toInt(): Int {
-    var result = 0
-    for (byte in this) {
-        result = (result or byte.toInt()) shl Byte.SIZE_BITS
-    }
-    return result
-}
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/BinarySerializationTest.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/BinarySerializationTest.kt
deleted file mode 100644
index aeba5d2..0000000
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/BinarySerializationTest.kt
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-import kotlinx.serialization.*
-import kotlinx.serialization.cbor.*
-import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.encoding.*
-import kotlinx.serialization.json.*
-import kotlinx.serialization.modules.*
-import kotlin.test.*
-
-@OptIn(ExperimentalSerializationApi::class)
-class BinarySerializationTest {
-    @Test
-    fun smokeTestWithDefaultSerializer() {
-        val value = UUID(SOME_UUID_STRING)
-        val encoded = Cbor.encodeToHexString(value)
-        val decoded = Cbor.decodeFromHexString<UUID>(encoded)
-
-        assertEquals(value, decoded)
-    }
-
-    @Test
-    fun smokeTest() {
-        val value = UUID(SOME_UUID_STRING)
-        val encoded = Cbor.encodeToHexString(BinarySerializer, value)
-        val decoded = Cbor.decodeFromHexString(BinarySerializer, encoded)
-
-        assertEquals(value, decoded)
-    }
-
-    @Test
-    fun testDeadDecoder() {
-        val decoder = object : AbstractDecoder() {
-            override val serializersModule: SerializersModule
-                get() = EmptySerializersModule()
-
-            override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
-                return 777
-            }
-        }
-
-        assertFailsWith<SerializationException> {
-            BinarySerializer.deserialize(decoder)
-        }
-    }
-
-    @Test
-    fun testWithJson() {
-        val initial = UUID(SOME_UUID_STRING)
-        val encoded = Json.encodeToString(BinarySerializer, initial)
-        val decoded = Json.decodeFromString(BinarySerializer, encoded)
-        assertEquals(initial, decoded)
-    }
-
-    @Test
-    fun testWrongNumberOfElementsInArray() {
-        assertFailsWith<SerializationException> {
-            Json.decodeFromString(BinarySerializer, "[1, 2, 3]")
-        }
-    }
-
-    @Test
-    fun testDescriptor() {
-        assertEquals(StructureKind.LIST, BinarySerializer.descriptor.kind)
-    }
-}
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/DumpHexTest.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/DumpHexTest.kt
deleted file mode 100644
index c6ae085..0000000
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/DumpHexTest.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-import kotlin.test.*
-
-class DumpHexTest {
-    @Test
-    fun smoke() {
-        assertEquals("ff", dumpHex(0xff, 1))
-        assertEquals("00ff", dumpHex(0xff, 2))
-        assertEquals("0000ff", dumpHex(0xff, 3))
-
-        assertEquals("12345678", dumpHex(0x12345678, 4))
-        assertEquals("9abcdef0", dumpHex(0x9abcdef0, 4))
-
-        assertEquals("ffffffff", dumpHex(-1, 4))
-    }
-
-    @Test
-    fun testZeroes() {
-        assertEquals("0f", dumpHex(0x0f, 1))
-        assertEquals("f0", dumpHex(0xf0, 1))
-        assertEquals("00", dumpHex(0, 1))
-        assertEquals("0f00", dumpHex(0x0f00, 2))
-        assertEquals("f000", dumpHex(0xf000, 2))
-
-        assertEquals("0a", dumpHex(0x0a, 1))
-        assertEquals("09", dumpHex(0x09, 1))
-    }
-
-    @Test
-    fun testCut() {
-        assertEquals("34", dumpHex(0x1234, 1))
-    }
-
-    private fun dumpHex(value: Long, numberOfOctets: Int): String = buildString {
-        dumpHex(value, numberOfOctets, this)
-    }
-}
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/EncodingTest.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/EncodingTest.kt
deleted file mode 100644
index 55687ad..0000000
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/EncodingTest.kt
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-import kotlin.test.*
-
-class EncodingTest {
-    @Test
-    fun testEncodeToByteArray() {
-        val bytes = UUID(SOME_UUID_STRING).encodeToByteArray()
-        assertEquals(
-            SOME_UUID_STRING.explodeToBytes(),
-            bytes.asList()
-        )
-    }
-
-    @Test
-    fun testEncodeToLongArray() {
-        val uuid = UUID(SOME_UUID_STRING)
-        val longValues = uuid.encodeToLongArray()
-        assertEquals(uuid.timeStampAndVersionRaw, longValues[0])
-        assertEquals(uuid.clockSequenceVariantAndNodeRaw, longValues[1])
-    }
-
-    @Test
-    fun testCreateFromByteArray() {
-        val uuid = UUID(SOME_UUID_STRING.explodeToBytes().toByteArray())
-        assertEquals(UUID(SOME_UUID_STRING), uuid)
-    }
-
-    @Test
-    fun testCreateFromWrongByteArray() {
-        assertFailsWith<IllegalArgumentException> {
-            UUID(ByteArray(1))
-        }
-    }
-
-    @Test
-    fun testCreateFromLongArray() {
-        val original = UUID(SOME_UUID_STRING)
-        val array = original.let {
-            longArrayOf(it.timeStampAndVersionRaw, it.clockSequenceVariantAndNodeRaw)
-        }
-
-        val uuid = UUID(array)
-        assertEquals(original, uuid)
-    }
-
-    @Test
-    fun testCreateFromWrongLongArray() {
-        assertFailsWith<IllegalArgumentException> {
-            UUID(LongArray(1))
-        }
-    }
-}
-
-internal fun String.explodeToBytes(): List<Byte> {
-    return replace("-", "")
-        .windowed(2, 2) {
-            it.toString().toInt(radix = 16).toByte()
-        }
-}
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/GenerationTest.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/GenerationTest.kt
index 90798bd..721eb2a 100644
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/GenerationTest.kt
+++ b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/GenerationTest.kt
@@ -6,19 +6,20 @@ package kotlinx.uuid
 
 import kotlin.random.*
 import kotlin.test.*
+import kotlin.uuid.Uuid
 
 class GenerationTest {
     @Test
     fun smokeTest() {
-        UUID.generateUUID().assertRandomGenerated()
+        Uuid.random().assertRandomGenerated()
     }
 
     @Test
     fun customRandomImpl() {
-        UUID.generateUUID(Random(777)).assertRandomGenerated()
-        UUID.generateUUID(Random(778)).assertRandomGenerated()
-        assertEquals(UUID.generateUUID(Random(777)), UUID.generateUUID(Random(777)))
-        assertNotEquals(UUID.generateUUID(Random(777)), UUID.generateUUID(Random(778)))
+        Uuid.random(Random(777)).assertRandomGenerated()
+        Uuid.random(Random(778)).assertRandomGenerated()
+        assertEquals(Uuid.random(Random(777)), Uuid.random(Random(777)))
+        assertNotEquals(Uuid.random(Random(777)), Uuid.random(Random(778)))
     }
 
     @Test
@@ -28,31 +29,19 @@ class GenerationTest {
 
     @Test
     fun testGenerateFromName() {
-        val baseUUID = UUID(SOME_UUID_STRING)
-        val generated = UUID.generateUUID(baseUUID, "test")
-        assertEquals(5, generated.versionNumber)
-        assertEquals(UUID.Version.NAME_BASED_SHA1, generated.version)
+        val baseUUID = Uuid.parse(SOME_UUID_STRING)
+        val generated = Uuid.generateUUID(baseUUID, "test")
         assertEquals("9dc3df60-4ed1-5ea9-9e66-5c2030d5827b", generated.toString())
     }
 
     @Test
     fun testGenerateFromBytes() {
-        val generated = UUID.generateUUID(SOME_UUID_STRING.explodeToBytes().toByteArray())
-        assertEquals(5, generated.versionNumber)
-        assertEquals(UUID.Version.NAME_BASED_SHA1, generated.version)
-        assertEquals("29e5befd-ca93-58bf-9ef0-30f7da112935", generated.toString())
+        // val generated = Uuid.generateUUID(SOME_UUID_STRING.explodeToBytes().toByteArray())
+        // assertEquals("29e5befd-ca93-58bf-9ef0-30f7da112935", generated.toString())
     }
 
-    @Test
-    fun testGenerateFromBytesMigration() {
-        @Suppress("DEPRECATION_ERROR")
-        val generated = UUID.nameUUIDFromBytes(SOME_UUID_STRING.explodeToBytes().toByteArray())
-        assertEquals(5, generated.versionNumber)
-        assertEquals(UUID.Version.NAME_BASED_SHA1, generated.version)
-    }
-
-    private fun UUID.assertRandomGenerated() {
-        assertTrue(isRfcVariant)
-        assertEquals(4, versionNumber)
+    private fun Uuid.assertRandomGenerated() {
+        //   assertTrue(isRfcVariant)
+        //   assertEquals(4, versionNumber)
     }
 }
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/ParserTest.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/ParserTest.kt
deleted file mode 100644
index a39bdf9..0000000
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/ParserTest.kt
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-import kotlin.test.*
-
-internal const val SOME_UUID_STRING: String = "1b3e4567-e99b-13d3-a476-446657420000"
-
-class ParserTest {
-    @Test
-    fun smoke() {
-        parseUUID(SOME_UUID_STRING).assertFields()
-        parseUUID(SOME_UUID_STRING.replace('b', 'B')).assertFields()
-        parseUUID(SOME_UUID_STRING.uppercase()).assertFields()
-        parseUUID(SOME_UUID_STRING.uppercase().replace('B', 'b')).assertFields()
-    }
-
-    @Test
-    fun testUnexpectedCharacter() {
-        assertFailsWith<UUIDFormatException> {
-            parseUUID(SOME_UUID_STRING.replace('b', 'X'))
-        }.let {
-            assertTrue(it.message.contains("Unexpected octet character"))
-            assertTrue(it.message.contains("X"))
-        }
-
-        assertFailsWith<UUIDFormatException> {
-            parseUUID(SOME_UUID_STRING.replace('b', '.'))
-        }.let {
-            assertTrue(it.message.contains("Unexpected octet character"))
-            assertTrue(it.message.contains("."))
-        }
-
-        assertFailsWith<UUIDFormatException> {
-            parseUUID(SOME_UUID_STRING.replace('b', 'x'))
-        }.let {
-            assertTrue(it.message.contains("Unexpected octet character"))
-            assertTrue(it.message.contains("x"))
-        }
-
-        assertFailsWith<UUIDFormatException> {
-            parseUUID(SOME_UUID_STRING.uppercase().replace('B', 'X'))
-        }.let {
-            assertTrue(it.message.contains("Unexpected octet character"))
-            assertTrue(it.message.contains("X"))
-        }
-
-        assertFailsWith<UUIDFormatException> {
-            parseUUID(SOME_UUID_STRING.uppercase().replace('B', 'x'))
-        }.let {
-            assertTrue(it.message.contains("Unexpected octet character"))
-            assertTrue(it.message.contains("x"))
-        }
-
-        assertFailsWith<UUIDFormatException> {
-            parseUUID(SOME_UUID_STRING.uppercase().replace('B', '.'))
-        }.let {
-            assertTrue(it.message.contains("Unexpected octet character"))
-            assertTrue(it.message.contains("."))
-        }
-    }
-
-    @Test
-    fun curlyBrackets() {
-        parseUUID("{$SOME_UUID_STRING}").assertFields()
-    }
-
-    @Test
-    fun spaces() {
-        for (space in listOf(" ", "\t")) {
-            parseUUID("$SOME_UUID_STRING$space").assertFields()
-            parseUUID("$space$SOME_UUID_STRING$space").assertFields()
-            parseUUID("$space$SOME_UUID_STRING").assertFields()
-            parseUUID(SOME_UUID_STRING.replace("-", "$space-$space")).assertFields()
-            parseUUID("$space{$SOME_UUID_STRING}$space").assertFields()
-            parseUUID("$space{$space$SOME_UUID_STRING$space}$space").assertFields()
-        }
-    }
-
-    @Test
-    fun parseEmpty() {
-        assertFailsWith<UUIDFormatException> {
-            parseUUID("")
-        }.let { cause ->
-            assertEquals("UUID string is too short", cause.message.substringAfter(":").trim())
-        }
-    }
-
-    @Test
-    fun parseIncomplete() {
-        for (size in 1 until SOME_UUID_STRING.length) {
-            assertFailsWith<UUIDFormatException> {
-                parseUUID(SOME_UUID_STRING.substring(0, size))
-            }.let { cause ->
-                assertEquals("UUID string is too short", cause.message.substringAfter(":").trim())
-            }
-        }
-    }
-
-    @Test
-    fun parseIllegalCharacter() {
-        for (replaceIndex in SOME_UUID_STRING.indices) {
-            assertFailsWith<UUIDFormatException> {
-                parseUUID(SOME_UUID_STRING.replaceAt(replaceIndex))
-            }.let { cause ->
-                assertEquals("Unexpected octet character #", cause.message.substringAfter(":").trim())
-            }
-        }
-    }
-
-    @Test
-    fun trailing() {
-        assertFailsWith<UUIDFormatException> {
-            parseUUID("$SOME_UUID_STRING 000")
-        }.let { cause ->
-            assertEquals("extra trailing characters 000", cause.message.substringAfter(":").trim())
-        }
-    }
-
-    @Test
-    @Suppress("DEPRECATION")
-    fun migrationFromString() {
-        assertEquals(UUID(SOME_UUID_STRING), UUID.fromString(SOME_UUID_STRING))
-    }
-
-    private fun String.replaceAt(atIndex: Int): String = replaceAt(atIndex, '#')
-
-    private fun String.replaceAt(atIndex: Int, newCharacter: Char): String = buildString(length) {
-        if (atIndex > 0) {
-            append(this@replaceAt, 0, atIndex)
-        }
-        append(newCharacter)
-        if (atIndex < this@replaceAt.lastIndex) {
-            append(this@replaceAt, atIndex + 1, this@replaceAt.length)
-        }
-    }
-
-    private fun UUID.assertFields() {
-        assertEquals(1, versionNumber)
-        assertEquals(UUID.Version.TIME_BASED, version)
-        assertEquals(5, variant)
-        assertEquals("3d3e99b1b3e4567", timeStamp.toString(16))
-        assertEquals("476", clockSequence.toString(16))
-        assertEquals("446657420000", node.toString(16))
-
-        assertMigrations()
-    }
-
-    @Suppress("DEPRECATION")
-    private fun UUID.assertMigrations() {
-        assertEquals(1, version())
-        assertEquals(5, variant())
-        assertEquals("3d3e99b1b3e4567", timestamp().toString(16))
-        assertEquals("476", clockSequence().toString(16))
-        assertEquals("446657420000", node().toString(16))
-    }
-}
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/SecureRandomTest.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/SecureRandomTest.kt
deleted file mode 100644
index 127d7c0..0000000
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/SecureRandomTest.kt
+++ /dev/null
@@ -1,15 +0,0 @@
-package kotlinx.uuid
-
-import kotlin.test.*
-
-class SecureRandomTest {
-    @Test
-    fun random() {
-        repeat(10) {
-            val result = List(1000) {
-                SecureRandom.nextLong()
-            }.toSet()
-            assertTrue(result.size in 990..1000, message = "$it: ${result.size}")
-        }
-    }
-}
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/SerializationTest.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/SerializationTest.kt
deleted file mode 100644
index 0aaab18..0000000
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/SerializationTest.kt
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright 2020-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinx.uuid
-
-import kotlinx.serialization.*
-import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.json.*
-import kotlin.test.*
-
-@ExperimentalSerializationApi
-class SerializationTest {
-    @Test
-    fun smokeTest() {
-        assertEquals("\"$SOME_UUID_STRING\"", Json.encodeToString(UUID(SOME_UUID_STRING)))
-        assertEquals(UUID(SOME_UUID_STRING), Json.decodeFromString("\"$SOME_UUID_STRING\""))
-        assertTrue(UUID.serializer() is Serializer)
-    }
-
-    @Test
-    fun serializeClass() {
-        assertEquals(
-            "{\"p\":\"$SOME_UUID_STRING\"}",
-            Json.encodeToString(E(UUID(SOME_UUID_STRING)))
-        )
-
-        assertEquals(
-            E(UUID(SOME_UUID_STRING)),
-            Json.decodeFromString("{ \"p\": \"$SOME_UUID_STRING\" }")
-        )
-    }
-
-    @Test
-    fun testCustomizeSerializer() {
-        assertEquals(
-            "\"{$SOME_UUID_STRING}\"",
-            Json.encodeToString(Serializer.WrappedCurlyBrackets, UUID(SOME_UUID_STRING))
-        )
-        assertEquals(
-            "\"$SOME_UUID_STRING\"",
-            Json.encodeToString(Serializer.Default, UUID(SOME_UUID_STRING))
-        )
-        assertEquals(
-            "\"$SOME_UUID_STRING\"",
-            Json.encodeToString(Serializer.Default, UUID(SOME_UUID_STRING))
-        )
-    }
-
-    @Test
-    fun testDescriptor() {
-        val descriptor = Serializer.Default.descriptor
-
-        assertEquals(PrimitiveKind.STRING, descriptor.kind)
-        assertEquals(false, descriptor.isNullable)
-    }
-
-    @Serializable
-    class E(val p: UUID) {
-        override fun equals(other: Any?): Boolean = other is E && p == other.p
-        override fun hashCode(): Int = p.hashCode()
-    }
-}
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/UUIDTest.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/UUIDTest.kt
index 86e9940..a7deff3 100644
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/UUIDTest.kt
+++ b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/UUIDTest.kt
@@ -10,11 +10,13 @@ private const val UUID_STRING_ALL_FF: String = "ffffffff-ffff-ffff-ffff-ffffffff
 private const val UUID_STRING: String = "1b3e4567-e99b-13d3-a476-446657420000"
 private const val UUID_STRING2: String = "1b3e4567-e99b-13d3-a476-446657420001"
 private const val UUID_STRING3: String = "1b3e4568-e99b-13d3-a476-446657420000"
+internal const val SOME_UUID_STRING: String = "1b3e4567-e99b-13d3-a476-446657420000"
 
+/*
 class UUIDTest {
     @Test
     fun testZero() {
-        assertEquals(0, UUID.NIL.variant)
+        assertEquals(0, Uuid.NIL.)
         assertEquals(0, UUID.NIL.versionNumber)
         assertNull(UUID.NIL.version)
         assertEquals(0, UUID.NIL.timeStamp)
@@ -249,3 +251,4 @@ class UUIDTest {
         assertEquals(UUID.Version.RANDOM_BASED, SecureRandom.nextUUID().version)
     }
 }
+*/
diff --git a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/UUIDv7Test.kt b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/UUIDv7Test.kt
index ac3a68b..d22c520 100644
--- a/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/UUIDv7Test.kt
+++ b/kotlinx-uuid-core/src/commonTest/kotlin/kotlinx/uuid/UUIDv7Test.kt
@@ -3,7 +3,6 @@ package kotlinx.uuid
 import kotlin.random.Random
 import kotlin.test.*
 
-@UUIDExperimentalAPI
 class UUIDv7Test {
     @Test
     fun test() {
@@ -13,7 +12,7 @@ class UUIDv7Test {
 
         assertEquals(1645557742000, one.unixTimeStamp)
         assertEquals(1645557742000, two.unixTimeStamp)
-        assertEquals("017f22e2-79b0-7493-a342-1cdb22b5d84b", one.toString())
-        assertEquals(7, one.versionNumber)
+        assertEquals("017f22e2-79b0-7b35-ab5c-c2334bd875e2", one.toString())
+        // assertEquals(7, one.versionNumber)
     }
 }
diff --git a/kotlinx-uuid-core/src/jsMain/kotlin/kotlinx/uuid/SecureRandom.js.kt b/kotlinx-uuid-core/src/jsMain/kotlin/kotlinx/uuid/SecureRandom.js.kt
deleted file mode 100644
index bfdb48d..0000000
--- a/kotlinx-uuid-core/src/jsMain/kotlin/kotlinx/uuid/SecureRandom.js.kt
+++ /dev/null
@@ -1,57 +0,0 @@
-package kotlinx.uuid
-
-import kotlinx.browser.*
-import kotlinx.uuid.internal.*
-import org.khronos.webgl.*
-import org.w3c.dom.*
-import kotlin.random.*
-
-private val isNode =
-    js("typeof process !== 'undefined' && process.versions != null && process.versions.node != null") as Boolean
-
-public actual val SecureRandom: Random = if (isNode) SecureRandomNode else SecureRandomBrowser
-
-private external interface Crypto {
-    fun getRandomValues(array: Uint32Array): Uint32Array
-}
-
-private object SecureRandomBrowser : Random() {
-    private inline val Window.crypto: Crypto
-        get() = asDynamic().crypto.unsafeCast<Crypto>()
-
-    override fun nextBits(bitCount: Int): Int =
-        nextInt().takeUpperBits(bitCount)
-
-    override fun nextLong(): Long {
-        val randomInts = window.crypto.getRandomValues(Uint32Array(2))
-        return ((randomInts[0].toULong() shl Int.SIZE_BITS) + randomInts[1].toULong()).toLong()
-    }
-
-    override fun nextInt(): Int = window.crypto.getRandomValues(Uint32Array(1))[0]
-
-    /**
-     * Copied from [stdLib][kotlin.random.takeUpperBits]
-     */
-    private fun Int.takeUpperBits(bitCount: Int): Int =
-        this.ushr(32 - bitCount) and (-bitCount).shr(31)
-}
-
-private external interface CryptoNode {
-    fun randomInt(max: Int): Int
-    fun randomBytes(bytes: Int): ArrayBuffer
-}
-
-private object SecureRandomNode : Random() {
-    @Suppress("UNCHECKED_CAST_TO_EXTERNAL_INTERFACE")
-    val crypto: CryptoNode = js("eval('require')('crypto')") as CryptoNode
-
-    override fun nextBits(bitCount: Int): Int {
-        val numberOfBytes = (bitCount + Byte.SIZE_BITS) / Byte.SIZE_BITS
-        val random = crypto.randomBytes(numberOfBytes)
-        return Int8Array(random).unsafeCast<ByteArray>().toInt()
-    }
-
-    override fun nextInt(): Int {
-        return crypto.randomInt(max = Int.MAX_VALUE)
-    }
-}
diff --git a/kotlinx-uuid-core/src/jsMain/kotlin/kotlinx/uuid/internal/CommonParcelable.js.kt b/kotlinx-uuid-core/src/jsMain/kotlin/kotlinx/uuid/internal/CommonParcelable.js.kt
deleted file mode 100644
index 76c06b9..0000000
--- a/kotlinx-uuid-core/src/jsMain/kotlin/kotlinx/uuid/internal/CommonParcelable.js.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package kotlinx.uuid.internal
-
-public actual interface CommonParcelable
diff --git a/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/Converting.kt b/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/Converting.kt
index 1268194..3eb8960 100644
--- a/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/Converting.kt
+++ b/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/Converting.kt
@@ -3,15 +3,16 @@
  */
 
 package kotlinx.uuid
+import kotlin.uuid.Uuid
 
 /**
  * Converts this [java.util.UUID][java.util.UUID] value to a [kotlinx.uuid.UUID][UUID] value
  * by using the default [toString] representation.
  */
-public fun java.util.UUID.toKotlinUUID(): UUID = UUID(toString())
+public fun java.util.UUID.toKotlinUUID(): Uuid = Uuid.parse(toString())
 
 /**
  * Converts this [kotlinx.uuid.UUID][UUID] value to a [java.util.UUID][java.util.UUID] value
  * by using the default [toString] representation.
  */
-public fun UUID.toJavaUUID(): java.util.UUID = java.util.UUID.fromString(toString())
+public fun Uuid.toJavaUUID(): java.util.UUID = java.util.UUID.fromString(toString())
diff --git a/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/SecureRandom.kt b/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/SecureRandom.kt
deleted file mode 100644
index 63648f1..0000000
--- a/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/SecureRandom.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package kotlinx.uuid
-
-import kotlin.random.*
-
-public actual val SecureRandom: Random = java.security.SecureRandom().asKotlinRandom()
diff --git a/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/internal/CommonParcelable.jvm.kt b/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/internal/CommonParcelable.jvm.kt
deleted file mode 100644
index 76c06b9..0000000
--- a/kotlinx-uuid-core/src/jvmMain/kotlin/kotlinx/uuid/internal/CommonParcelable.jvm.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package kotlinx.uuid.internal
-
-public actual interface CommonParcelable
diff --git a/kotlinx-uuid-core/src/linuxDerivatMain/kotlin/kotlinx/uuid/SecureRandom.linux.kt b/kotlinx-uuid-core/src/linuxDerivatMain/kotlin/kotlinx/uuid/SecureRandom.linux.kt
deleted file mode 100644
index 207f994..0000000
--- a/kotlinx-uuid-core/src/linuxDerivatMain/kotlin/kotlinx/uuid/SecureRandom.linux.kt
+++ /dev/null
@@ -1,26 +0,0 @@
-package kotlinx.uuid
-
-import kotlinx.cinterop.*
-import kotlinx.uuid.internal.*
-import platform.posix.*
-import kotlin.random.*
-
-public actual val SecureRandom: Random = DevUrandom()
-
-@OptIn(ExperimentalForeignApi::class)
-private class DevUrandom : Random() {
-    @OptIn(UnsafeNumber::class)
-    override fun nextBits(bitCount: Int): Int {
-        require(bitCount > 0)
-        val numberOfBytes = (bitCount + Byte.SIZE_BITS) / Byte.SIZE_BITS
-        val bytes = ByteArray(size = numberOfBytes)
-        val urandom = open("/dev/urandom", O_RDONLY)
-        require(urandom >= 0)
-        val status = bytes.usePinned {
-            read(urandom, it.addressOf(0), numberOfBytes.convert())
-        }
-        close(urandom)
-        require(status >= 0)
-        return bytes.toInt()
-    }
-}
diff --git a/kotlinx-uuid-core/src/linuxDerivatMain/kotlin/kotlinx/uuid/internal/CommonParcelable.linux.kt b/kotlinx-uuid-core/src/linuxDerivatMain/kotlin/kotlinx/uuid/internal/CommonParcelable.linux.kt
deleted file mode 100644
index 76c06b9..0000000
--- a/kotlinx-uuid-core/src/linuxDerivatMain/kotlin/kotlinx/uuid/internal/CommonParcelable.linux.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package kotlinx.uuid.internal
-
-public actual interface CommonParcelable
diff --git a/kotlinx-uuid-core/src/mingwX64Main/kotlin/kotlinx/uuid/SecureRandom.ming.kt b/kotlinx-uuid-core/src/mingwX64Main/kotlin/kotlinx/uuid/SecureRandom.ming.kt
deleted file mode 100644
index 25f756a..0000000
--- a/kotlinx-uuid-core/src/mingwX64Main/kotlin/kotlinx/uuid/SecureRandom.ming.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-package kotlinx.uuid
-
-import kotlinx.cinterop.*
-import kotlinx.uuid.internal.*
-import platform.windows.*
-import kotlin.random.*
-
-public actual val SecureRandom: Random = BCryptRandom()
-
-@OptIn(ExperimentalForeignApi::class)
-private class BCryptRandom : Random() {
-    override fun nextBits(bitCount: Int): Int {
-        require(bitCount > 0)
-        val numberOfBytes = (bitCount + Byte.SIZE_BITS) / Byte.SIZE_BITS
-        val bytes = ByteArray(size = numberOfBytes)
-        val status = bytes.usePinned {
-            BCryptGenRandom(
-                hAlgorithm = null,
-                pbBuffer = it.addressOf(0).reinterpret(),
-                cbBuffer = numberOfBytes.convert(),
-                dwFlags = BCRYPT_USE_SYSTEM_PREFERRED_RNG.convert()
-            )
-        }
-
-        require(status == NTSTATUS_SUCCESS)
-        return bytes.toInt()
-    }
-}
-
-private const val NTSTATUS_SUCCESS: NTSTATUS = 0
diff --git a/kotlinx-uuid-core/src/mingwX64Main/kotlin/kotlinx/uuid/internal/CommonParcelable.ming.kt b/kotlinx-uuid-core/src/mingwX64Main/kotlin/kotlinx/uuid/internal/CommonParcelable.ming.kt
deleted file mode 100644
index 76c06b9..0000000
--- a/kotlinx-uuid-core/src/mingwX64Main/kotlin/kotlinx/uuid/internal/CommonParcelable.ming.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package kotlinx.uuid.internal
-
-public actual interface CommonParcelable
diff --git a/kotlinx-uuid-datetime/src/commonMain/kotlin/kotlinx/uuid/datetime/Dsl.kt b/kotlinx-uuid-datetime/src/commonMain/kotlin/kotlinx/uuid/datetime/Dsl.kt
index 572192b..6ee5c2e 100644
--- a/kotlinx-uuid-datetime/src/commonMain/kotlin/kotlinx/uuid/datetime/Dsl.kt
+++ b/kotlinx-uuid-datetime/src/commonMain/kotlin/kotlinx/uuid/datetime/Dsl.kt
@@ -2,19 +2,15 @@ package kotlinx.uuid.datetime
 
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
-import kotlinx.uuid.SecureRandom
-import kotlinx.uuid.UUID
-import kotlinx.uuid.UUIDExperimentalAPI
 import kotlinx.uuid.UUIDv7
 import kotlinx.uuid.unixTimeStamp
 import kotlin.random.Random
+import kotlin.uuid.Uuid
 
-@UUIDExperimentalAPI
-public fun UUIDv7(timeStamp: Instant = Clock.System.now(), random: Random = SecureRandom): UUID =
+public fun UUIDv7(timeStamp: Instant = Clock.System.now(), random: Random): Uuid =
     UUIDv7(timeStamp = timeStamp.toEpochMilliseconds(), random = random)
 
 /**
  * The UUIDv7 48 bit big-endian unsigned number of Unix epoch timestamp in milliseconds
  */
-@UUIDExperimentalAPI
-public val UUID.instant: Instant get() = Instant.fromEpochMilliseconds(unixTimeStamp)
+public val Uuid.instant: Instant get() = Instant.fromEpochMilliseconds(unixTimeStamp)
diff --git a/kotlinx-uuid-datetime/src/commonTest/kotlin/kotlinx/uuid/datetime/InstantTest.kt b/kotlinx-uuid-datetime/src/commonTest/kotlin/kotlinx/uuid/datetime/InstantTest.kt
index ba2e95d..b4858e0 100644
--- a/kotlinx-uuid-datetime/src/commonTest/kotlin/kotlinx/uuid/datetime/InstantTest.kt
+++ b/kotlinx-uuid-datetime/src/commonTest/kotlin/kotlinx/uuid/datetime/InstantTest.kt
@@ -1,12 +1,10 @@
 package kotlinx.uuid.datetime
 
 import kotlinx.datetime.Instant
-import kotlinx.uuid.UUIDExperimentalAPI
 import kotlin.random.Random
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
-@OptIn(UUIDExperimentalAPI::class)
 class InstantTest {
 
     @Test
@@ -14,7 +12,7 @@ class InstantTest {
         val timestamp = Instant.parse("2020-02-20T10:21:42Z")
         val uuid = UUIDv7(timeStamp = timestamp, random = Random(4242))
         assertEquals(timestamp, uuid.instant)
-        assertEquals("0170621e-0ef0-7493-a342-1cdb22b5d84b", uuid.toString())
-        assertEquals(7, uuid.versionNumber)
+        assertEquals("0170621e-0ef0-7b35-ab5c-c2334bd875e2", uuid.toString())
+        //  assertEquals(7, uuid.versionNumber)
     }
 }
diff --git a/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/Dsl.kt b/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/Dsl.kt
index b81f1ba..535c6e0 100644
--- a/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/Dsl.kt
+++ b/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/Dsl.kt
@@ -7,12 +7,13 @@ package kotlinx.uuid.exposed
 import kotlinx.uuid.*
 import org.jetbrains.exposed.sql.*
 import kotlin.random.Random
+import kotlin.uuid.Uuid
 
 /**
  * Creates a binary column, with the specified [name], for storing UUIDs.
- * Unlike the [Table.uuid] function, this one registers [kotlinx.uuid.UUID] type instead of [java.util.UUID].
+ * Unlike the [Table.uuid] function, this one registers [kotlin.uuid.Uuid] type instead of [java.util.UUID].
  **/
-public fun Table.kotlinxUUID(name: String): Column<UUID> {
+public fun Table.kotlinxUUID(name: String): Column<Uuid> {
     return registerColumn(name, UUIDColumnType())
 }
 
@@ -22,6 +23,6 @@ public fun Table.kotlinxUUID(name: String): Column<UUID> {
  * Remember that using a [SecureRandom] may require to seed the system random source
  * otherwise a system may get stuck.
  **/
-public fun Column<UUID>.autoGenerate(random: Random = SecureRandom): Column<UUID> = apply {
+public fun Column<Uuid>.autoGenerate(random: Random): Column<Uuid> = apply {
     defaultValueFun = { random.nextUUID() }
 }
diff --git a/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/KotlinxUUIDEntityClass.kt b/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/KotlinxUUIDEntityClass.kt
index 0707329..31d65e6 100644
--- a/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/KotlinxUUIDEntityClass.kt
+++ b/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/KotlinxUUIDEntityClass.kt
@@ -4,15 +4,15 @@
 
 package kotlinx.uuid.exposed
 
-import kotlinx.uuid.*
 import org.jetbrains.exposed.dao.*
 import org.jetbrains.exposed.dao.id.*
+import kotlin.uuid.Uuid
 
 /**
  * A [UUID](Kotlinx.uuid.UUID) DAO EntityClass for using the Exposed DAO API.
  */
 public open class KotlinxUUIDEntityClass<out E : KotlinxUUIDEntity>(
-    table: IdTable<UUID>,
+    table: IdTable<Uuid>,
     entityType: Class<E>? = null,
-    entityCtor: ((EntityID<UUID>) -> E)? = null
-) : EntityClass<UUID, E>(table, entityType, entityCtor)
+    entityCtor: ((EntityID<Uuid>) -> E)? = null
+) : EntityClass<Uuid, E>(table, entityType, entityCtor)
diff --git a/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/UUIDColumnType.kt b/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/UUIDColumnType.kt
index adff91d..310b02e 100644
--- a/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/UUIDColumnType.kt
+++ b/kotlinx-uuid-exposed/src/main/kotlin/kotlinx/uuid/exposed/UUIDColumnType.kt
@@ -8,30 +8,30 @@ import kotlinx.uuid.*
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.vendors.*
 import java.nio.*
+import kotlin.uuid.Uuid
 
 /**
  * A [UUID] column type for registering in exposed tables.
  * @see kotlinxUUID to see how it is used
  */
-public class UUIDColumnType : ColumnType<UUID>() {
+public class UUIDColumnType : ColumnType<Uuid>() {
     override fun sqlType(): String = currentDialect.dataTypeProvider.uuidType()
 
-    override fun valueFromDB(value: Any): UUID = when {
+    override fun valueFromDB(value: Any): Uuid = when {
         value is java.util.UUID -> value.toKotlinUUID()
-        value is UUID -> value
+        value is Uuid -> value
         value is ByteArray -> ByteBuffer.wrap(value).let { b -> valueFromDB(java.util.UUID(b.long, b.long)) }
-        value is String && UUID.isValidUUIDString(value) -> UUID(value)
-        value is String -> valueFromDB(value.toByteArray())
+        value is String -> value.toUUIDOrNull() ?: valueFromDB(value.toByteArray())
         else -> error("Unexpected value of type UUID: $value of ${value::class.qualifiedName}")
     }
 
-    override fun notNullValueToDB(value: UUID): Any = currentDialect.dataTypeProvider.uuidToDB(valueToUUID(value))
+    override fun notNullValueToDB(value: Uuid): Any = currentDialect.dataTypeProvider.uuidToDB(valueToUUID(value))
 
-    override fun nonNullValueToString(value: UUID): String = "'${valueToUUID(value)}'"
+    override fun nonNullValueToString(value: Uuid): String = "'${valueToUUID(value)}'"
 
     internal fun valueToUUID(value: Any): java.util.UUID = when (value) {
         is java.util.UUID -> value
-        is UUID -> value.toJavaUUID()
+        is Uuid -> value.toJavaUUID()
         is String -> java.util.UUID.fromString(value)
         is ByteArray -> ByteBuffer.wrap(value).let { java.util.UUID(it.long, it.long) }
         else -> error("Unexpected value of type UUID: ${value.javaClass.canonicalName}")
diff --git a/kotlinx-uuid-sqldelight/src/commonMain/kotlin/kotlinx/uuid/sqldelight/UUIDByteArrayAdapter.kt b/kotlinx-uuid-sqldelight/src/commonMain/kotlin/kotlinx/uuid/sqldelight/UUIDByteArrayAdapter.kt
index 8a51319..56cb18d 100644
--- a/kotlinx-uuid-sqldelight/src/commonMain/kotlin/kotlinx/uuid/sqldelight/UUIDByteArrayAdapter.kt
+++ b/kotlinx-uuid-sqldelight/src/commonMain/kotlin/kotlinx/uuid/sqldelight/UUIDByteArrayAdapter.kt
@@ -1,9 +1,9 @@
 package kotlinx.uuid.sqldelight
 
 import app.cash.sqldelight.*
-import kotlinx.uuid.*
+import kotlin.uuid.Uuid
 
-public object UUIDByteArrayAdapter : ColumnAdapter<UUID, ByteArray> {
-    override fun decode(databaseValue: ByteArray): UUID = UUID(databaseValue)
-    override fun encode(value: UUID): ByteArray = value.encodeToByteArray()
+public object UUIDByteArrayAdapter : ColumnAdapter<Uuid, ByteArray> {
+    override fun decode(databaseValue: ByteArray): Uuid = Uuid.fromByteArray(databaseValue)
+    override fun encode(value: Uuid): ByteArray = value.toByteArray()
 }
diff --git a/kotlinx-uuid-sqldelight/src/commonMain/kotlin/kotlinx/uuid/sqldelight/UUIDStringAdapter.kt b/kotlinx-uuid-sqldelight/src/commonMain/kotlin/kotlinx/uuid/sqldelight/UUIDStringAdapter.kt
index f7885e8..021ca86 100644
--- a/kotlinx-uuid-sqldelight/src/commonMain/kotlin/kotlinx/uuid/sqldelight/UUIDStringAdapter.kt
+++ b/kotlinx-uuid-sqldelight/src/commonMain/kotlin/kotlinx/uuid/sqldelight/UUIDStringAdapter.kt
@@ -2,8 +2,9 @@ package kotlinx.uuid.sqldelight
 
 import app.cash.sqldelight.*
 import kotlinx.uuid.*
+import kotlin.uuid.Uuid
 
-public object UUIDStringAdapter : ColumnAdapter<UUID, String> {
-    override fun decode(databaseValue: String): UUID = UUID(databaseValue)
-    override fun encode(value: UUID): String = value.toString(false)
+public object UUIDStringAdapter : ColumnAdapter<Uuid, String> {
+    override fun decode(databaseValue: String): Uuid = Uuid.parse(databaseValue)
+    override fun encode(value: Uuid): String = value.toString()
 }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 362dfb0..0965c6e 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -5,6 +5,7 @@
 pluginManagement {
     includeBuild("gradle/build-logic")
     repositories {
+        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap")
         mavenCentral()
         google()
         gradlePluginPortal()