diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmSymbols.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmSymbols.kt
index bb9797d..66b6d7a 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmSymbols.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmSymbols.kt
@@ -142,7 +142,7 @@
         context.irBuiltIns.floatType to getInternalFunction("consumeFloatIntoVoid"),
         context.irBuiltIns.doubleType to getInternalFunction("consumeDoubleIntoVoid")
     )
-    
+
     fun findVoidConsumer(type: IrType): IrSimpleFunctionSymbol =
         consumePrimitiveIntoVoid[type] ?: consumeAnyIntoVoid
 
@@ -236,6 +236,7 @@
 
     val newJsArray = getInternalFunction("newJsArray")
     val jsArrayPush = getInternalFunction("jsArrayPush")
+    val jsArrayPushString = getInternalFunction("jsArrayPushString")
 
     val startCoroutineUninterceptedOrReturnIntrinsics =
         (0..2).map { getInternalFunction("startCoroutineUninterceptedOrReturnIntrinsic$it") }
@@ -304,6 +305,9 @@
     private val wasmStructRefClass = getIrClass(FqName("kotlin.wasm.internal.reftypes.structref"))
     val wasmStructRefType by lazy { wasmStructRefClass.defaultType }
 
+    private val wasmStringRefClass = getIrClass(FqName("kotlin.wasm.internal.reftypes.stringref"))
+    val wasmStringRefType by lazy { wasmStringRefClass.defaultType }
+
     val wasmAnyRefClass = getIrClass(FqName("kotlin.wasm.internal.reftypes.anyref"))
 
     private val jsAnyClass = getIrClass(FqName("kotlin.js.JsAny"))
@@ -385,4 +389,4 @@
     fun getKFunctionType(type: IrType, list: List<IrType>): IrType {
         return irBuiltIns.functionN(list.size).typeWith(list + type)
     }
-}
+}
\ No newline at end of file
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt
index ecde31b..531be39 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt
@@ -137,7 +137,7 @@
         check(wasmArrayType != null)
 
         val location = expression.getSourceLocation()
-        generateAnyParameters(arrayClass.symbol, location)
+        generateAnyParameters(context, body, arrayClass.symbol, location)
         if (!tryGenerateConstVarargArray(expression, wasmArrayType)) tryGenerateVarargArray(expression, wasmArrayType)
         body.buildStructNew(context.referenceGcType(expression.type.getRuntimeClass(irBuiltIns).symbol), location)
     }
@@ -294,7 +294,7 @@
         }
 
         if (expression.symbol.owner.hasWasmPrimitiveConstructorAnnotation()) {
-            generateAnyParameters(klassSymbol, location)
+            generateAnyParameters(context, body, klassSymbol, location)
             for (i in 0 until expression.valueArgumentsCount) {
                 generateExpression(expression.getValueArgument(i)!!)
             }
@@ -307,21 +307,6 @@
         generateCall(expression)
     }
 
-    private fun generateAnyParameters(klassSymbol: IrClassSymbol, location: SourceLocation) {
-        //ClassITable and VTable load
-        body.commentGroupStart { "Any parameters" }
-        body.buildGetGlobal(context.referenceGlobalVTable(klassSymbol), location)
-        if (klassSymbol.owner.hasInterfaceSuperClass()) {
-            body.buildGetGlobal(context.referenceGlobalClassITable(klassSymbol), location)
-        } else {
-            body.buildRefNull(WasmHeapType.Simple.Struct, location)
-        }
-
-        body.buildConstI32Symbol(context.referenceTypeId(klassSymbol), location)
-        body.buildConstI32(0, location) // Any::_hashCode
-        body.commentGroupEnd()
-    }
-
     fun generateObjectCreationPrefixIfNeeded(constructor: IrConstructor) {
         val parentClass = constructor.parentAsClass
         if (constructor.origin == PrimaryConstructorLowering.SYNTHETIC_PRIMARY_CONSTRUCTOR) return
@@ -332,7 +317,7 @@
             body.buildGetLocal(thisParameter, location)
             body.buildInstr(WasmOp.REF_IS_NULL, location)
             body.buildIf("this_init")
-            generateAnyParameters(parentClass.symbol, location)
+            generateAnyParameters(context, body, parentClass.symbol, location)
             val irFields: List<IrField> = parentClass.allFields(backendContext.irBuiltIns)
             irFields.forEachIndexed { index, field ->
                 if (index > 1) {
@@ -362,7 +347,7 @@
     private fun generateBox(expression: IrExpression, type: IrType) {
         val klassSymbol = type.getRuntimeClass(irBuiltIns).symbol
         val location = expression.getSourceLocation()
-        generateAnyParameters(klassSymbol, location)
+        generateAnyParameters(context, body, klassSymbol, location)
         generateExpression(expression)
         body.buildStructNew(context.referenceGcType(klassSymbol), location)
         body.commentPreviousInstr { "box" }
@@ -963,4 +948,21 @@
     }
 
     private fun IrElement.getSourceLocation() = getSourceLocation(functionContext.irFunction.fileOrNull?.fileEntry)
+
+    companion object {
+        fun generateAnyParameters(context: WasmModuleCodegenContext, body: WasmExpressionBuilder, klassSymbol: IrClassSymbol, location: SourceLocation) {
+            //ClassITable and VTable load
+            body.commentGroupStart { "Any parameters" }
+            body.buildGetGlobal(context.referenceGlobalVTable(klassSymbol), location)
+            if (klassSymbol.owner.hasInterfaceSuperClass()) {
+                body.buildGetGlobal(context.referenceGlobalClassITable(klassSymbol), location)
+            } else {
+                body.buildRefNull(WasmHeapType.Simple.Struct, location)
+            }
+
+            body.buildConstI32Symbol(context.referenceTypeId(klassSymbol), location)
+            body.buildConstI32(0, location) // Any::_hashCode
+            body.commentGroupEnd()
+        }
+    }
 }
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt
index ca28d41..dfb560c 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt
@@ -490,6 +490,8 @@
             is WasmRefNullExternrefType -> g.buildRefNull(WasmHeapType.Simple.NullNoExtern, location)
             is WasmAnyRef -> g.buildRefNull(WasmHeapType.Simple.Any, location)
             is WasmExternRef -> g.buildRefNull(WasmHeapType.Simple.Extern, location)
+            is WasmStringRef -> g.buildRefNull(WasmHeapType.Simple.StringRef, location)
+            is WasmStringViewWTF16 -> g.buildRefNull(WasmHeapType.Simple.StringViewWtf16, location)
             WasmUnreachableType -> error("Unreachable type can't be initialized")
             else -> error("Unknown value type ${type.name}")
         }
@@ -535,4 +537,4 @@
             body.commentGroupEnd()
         }
         else -> error("Unknown constant kind")
-    }
+    }
\ No newline at end of file
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt
index bc48119..9df15c9 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt
@@ -104,6 +104,9 @@
                         "structref" -> WasmRefNullType(WasmHeapType.Simple.Struct)
                         "i31ref" -> WasmI31Ref
                         "funcref" -> WasmRefNullType(WasmHeapType.Simple.Func)
+                        "stringref" -> WasmStringRef
+                        "stringview_wtf16" -> WasmStringViewWTF16
+                        "stringview_iter" -> WasmStringViewIter
                         else -> error("Unknown reference type $name")
                     }
                 } else if (ic != null) {
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmModuleCodegenContext.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmModuleCodegenContext.kt
index 7e9e84e..d31cd32 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmModuleCodegenContext.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmModuleCodegenContext.kt
@@ -195,5 +195,4 @@
     fun addJsModuleImport(module: String) {
         wasmFragment.jsModuleImports += module
     }
-}
-
+}
\ No newline at end of file
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/JsInteropFunctionsLowering.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/JsInteropFunctionsLowering.kt
index c0fa36c..7f54fde 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/JsInteropFunctionsLowering.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/JsInteropFunctionsLowering.kt
@@ -265,7 +265,6 @@
             builtIns.doubleType,
             context.wasmSymbols.voidType ->
                 return null
-
         }
 
         if (isExternalType(this))
@@ -858,7 +857,11 @@
                             ),
                             this@irBlock
                         )
-                        +irCall(symbols.jsArrayPush).apply {
+                        val jsArrayPush =
+                            if (elementAdapter?.toType?.makeNotNull() != symbols.wasmStringRefType) symbols.jsArrayPush
+                            else symbols.jsArrayPushString
+
+                        +irCall(jsArrayPush).apply {
                             putValueArgument(0, irGet(newJsArrayVar))
                             putValueArgument(1, adaptedValue)
                         }
diff --git a/libraries/stdlib/wasm/builtins/kotlin/String.kt b/libraries/stdlib/wasm/builtins/kotlin/String.kt
index 85d08d8..72611da 100644
--- a/libraries/stdlib/wasm/builtins/kotlin/String.kt
+++ b/libraries/stdlib/wasm/builtins/kotlin/String.kt
@@ -1,32 +1,28 @@
 /*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package kotlin
 
 import kotlin.wasm.internal.*
-import kotlin.math.min
+import kotlin.wasm.internal.reftypes.*
 
-/**
- * The `String` class represents character strings. All string literals in Kotlin programs, such as `"abc"`, are
- * implemented as instances of this class.
- */
-public class String internal @WasmPrimitiveConstructor constructor(
-    private var leftIfInSum: String?,
-    @kotlin.internal.IntrinsicConstEvaluation
-    public override val length: Int,
-    private var _chars: WasmCharArray,
-) : Comparable<String>, CharSequence {
+public class String internal @WasmPrimitiveConstructor constructor(internal val reference: stringref) : Comparable<String>, CharSequence {
     public companion object {}
 
-    /**
-     * Returns a string obtained by concatenating this string with the string representation of the given [other] object.
-     */
-    @kotlin.internal.IntrinsicConstEvaluation
-    public operator fun plus(other: Any?): String {
-        val right = other.toString()
-        return String(this, this.length + right.length, right.chars)
+    public override val length: Int get() =
+        wasm_stringview_wtf16_length(wasm_string_as_wtf16(reference))
+
+    public override fun get(index: Int): Char =
+        wasm_stringview_wtf16_get_codeunit(wasm_string_as_wtf16(reference), index).toChar()
+
+    public override fun subSequence(startIndex: Int, endIndex: Int): CharSequence {
+        val view = wasm_string_as_wtf16(reference)
+        val length = wasm_stringview_wtf16_length(view)
+        val actualStartIndex = startIndex.coerceAtLeast(0)
+        val actualEndIndex = endIndex.coerceAtMost(length)
+        return String(wasm_stringview_wtf16_slice(view, actualStartIndex, actualEndIndex))
     }
 
     /**
@@ -35,99 +31,42 @@
      * If the [index] is out of bounds of this string, throws an [IndexOutOfBoundsException] except in Kotlin/JS
      * where the behavior is unspecified.
      */
-    @kotlin.internal.IntrinsicConstEvaluation
-    public override fun get(index: Int): Char {
-        rangeCheck(index, this.length)
-        return chars.get(index)
-    }
-
-    internal fun foldChars() {
-        val stringLength = this.length
-        val newArray = WasmCharArray(stringLength)
-
-        var currentStartIndex = stringLength
-        var currentLeftString: String? = this
-        while (currentLeftString != null) {
-            val currentLeftStringChars = currentLeftString._chars
-            val currentLeftStringLen = currentLeftStringChars.len()
-            currentStartIndex -= currentLeftStringLen
-            copyWasmArray(currentLeftStringChars, newArray, 0, currentStartIndex, currentLeftStringLen)
-            currentLeftString = currentLeftString.leftIfInSum
+    public operator fun plus(other: Any?): String {
+        val otherReference = when (other) {
+            is String -> other.reference
+            else -> other.toString().reference
         }
-        check(currentStartIndex == 0)
-        _chars = newArray
-        leftIfInSum = null
+        return String(wasm_string_concat(reference, otherReference))
     }
 
-    internal inline val chars: WasmCharArray get() {
-        if (leftIfInSum != null) {
-            foldChars()
-        }
-        return _chars
-    }
-
-    public override fun subSequence(startIndex: Int, endIndex: Int): CharSequence {
-        val actualStartIndex = startIndex.coerceAtLeast(0)
-        val actualEndIndex = endIndex.coerceAtMost(this.length)
-        val newLength = actualEndIndex - actualStartIndex
-        if (newLength <= 0) return ""
-        val newChars = WasmCharArray(newLength)
-        copyWasmArray(chars, newChars, actualStartIndex, 0, newLength)
-        return newChars.createString()
-    }
-
-    @kotlin.internal.IntrinsicConstEvaluation
     public override fun compareTo(other: String): Int {
-        if (this === other) return 0
-        val thisChars = this.chars
-        val otherChars = other.chars
-        val thisLength = thisChars.len()
-        val otherLength = otherChars.len()
-        val minimumLength = if (thisLength < otherLength) thisLength else otherLength
+        val thisIterator = wasm_string_as_iter(this.reference)
+        val otherIterator = wasm_string_as_iter(other.reference)
 
-        repeat(minimumLength) {
-            val l = thisChars.get(it)
-            val r = otherChars.get(it)
-            if (l != r) return l - r
+        var thisCode = wasm_stringview_iter_next(thisIterator)
+        var otherCode = wasm_stringview_iter_next(otherIterator)
+        while (thisCode != -1 && otherCode != -1) {
+            val diff = thisCode - otherCode
+            if (diff != 0) return diff
+            thisCode = wasm_stringview_iter_next(thisIterator)
+            otherCode = wasm_stringview_iter_next(otherIterator)
         }
-        return thisLength - otherLength
+        return if (thisCode == -1 && otherCode == -1) 0 else this.length - other.length
     }
 
-    @kotlin.internal.IntrinsicConstEvaluation
     public override fun equals(other: Any?): Boolean {
-        if (other == null) return false
-        if (other === this) return true
-        val otherString = other as? String ?: return false
-
-        val thisLength = this.length
-        val otherLength = otherString.length
-        if (thisLength != otherLength) return false
-
-        val thisHash = this._hashCode
-        val otherHash = other._hashCode
-        if (thisHash != otherHash && thisHash != 0 && otherHash != 0) return false
-
-        val thisChars = this.chars
-        val otherChars = other.chars
-        repeat(thisLength) {
-            if (thisChars.get(it) != otherChars.get(it)) return false
-        }
-        return true
+        if (other === null) return false
+        if (this === other) return true
+        return other is String && wasm_string_eq(reference, other.reference)
     }
 
-    @kotlin.internal.IntrinsicConstEvaluation
     public override fun toString(): String = this
 
     public override fun hashCode(): Int {
         if (_hashCode != 0) return _hashCode
-        val thisLength = this.length
-        if (thisLength == 0) return 0
 
-        val thisChars = chars
         var hash = 0
-        repeat(thisLength) {
-            hash = (hash shl 5) - hash + thisChars.get(it).toInt()
-        }
+        forEachCodePoint { hash = 31 * hash + it }
         _hashCode = hash
         return _hashCode
     }
@@ -135,7 +74,16 @@
 
 @Suppress("NOTHING_TO_INLINE")
 internal inline fun WasmCharArray.createString(): String =
-    String(null, this.len(), this)
+    String(wasm_string_new_wtf16_array(this, 0, len()))
+
+internal inline fun String.forEachCodePoint(body: (Int) -> Unit) {
+    val iter = wasm_string_as_iter(reference)
+    var codePoint = wasm_stringview_iter_next(iter)
+    while (codePoint != -1) {
+        body(codePoint)
+        codePoint = wasm_stringview_iter_next(iter)
+    }
+}
 
 internal fun stringLiteral(poolId: Int, startAddress: Int, length: Int): String {
     val cached = stringPool[poolId]
@@ -144,7 +92,7 @@
     }
 
     val chars = array_new_data0<WasmCharArray>(startAddress, length)
-    val newString = String(null, length, chars)
+    val newString = chars.createString()
     stringPool[poolId] = newString
     return newString
 }
\ No newline at end of file
diff --git a/libraries/stdlib/wasm/builtins/kotlin/Throwable.kt b/libraries/stdlib/wasm/builtins/kotlin/Throwable.kt
index ca47635..6468591 100644
--- a/libraries/stdlib/wasm/builtins/kotlin/Throwable.kt
+++ b/libraries/stdlib/wasm/builtins/kotlin/Throwable.kt
@@ -5,10 +5,6 @@
 
 package kotlin
 
-import kotlin.wasm.internal.ExternalInterfaceType
-import kotlin.wasm.internal.getSimpleName
-import kotlin.wasm.internal.jsToKotlinStringAdapter
-
 /**
  * The base class for all errors and exceptions. Only instances of this class can be thrown or caught.
  *
@@ -22,19 +18,7 @@
 
     constructor() : this(null, null)
 
-    internal val jsStack: ExternalInterfaceType = captureStackTrace()
-
-    private var _stack: String? = null
-    internal val stack: String
-        get() {
-            var value = _stack
-            if (value == null) {
-                value = jsToKotlinStringAdapter(jsStack).removePrefix("Error\n")
-                _stack = value
-            }
-
-            return value
-        }
+    internal val stack: String = captureStackTrace()
 
     internal var suppressedExceptionsList: MutableList<Throwable>? = null
 
@@ -43,10 +27,11 @@
      * followed by the exception message if it is not null.
      */
     public override fun toString(): String {
-        val s = getSimpleName(this.typeInfo)
+        val kClass = this::class
+        val s = kClass.simpleName ?: "Throwable"
         return if (message != null) s + ": " + message.toString() else s
     }
 }
 
-private fun captureStackTrace(): ExternalInterfaceType =
-    js("new Error().stack")
+private fun captureStackTrace(): String =
+    js("new Error().stack.replace(/^Error\\n/, '')")
\ No newline at end of file
diff --git a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/ExceptionHelpers.kt b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/ExceptionHelpers.kt
index 893899e..368fb60 100644
--- a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/ExceptionHelpers.kt
+++ b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/ExceptionHelpers.kt
@@ -6,7 +6,7 @@
 package kotlin.wasm.internal
 
 @Suppress("UNUSED_PARAMETER") // TODO: Remove after bootstrap update
-private fun throwJsError(message: String?, wasmTypeName: String?, stack: ExternalInterfaceType): Nothing {
+private fun throwJsError(message: String?, wasmTypeName: String?, stack: String): Nothing {
     js("""
     const error = new Error();
     error.message = message;
@@ -17,7 +17,7 @@
 }
 
 internal fun throwAsJsException(t: Throwable): Nothing {
-    throwJsError(t.message, getSimpleName(t.typeInfo), t.jsStack)
+    throwJsError(t.message, getSimpleName(t.typeInfo), t.stack)
 }
 
 internal var isNotFirstWasmExportCall: Boolean = false
\ No newline at end of file
diff --git a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/ExternalWrapper.kt b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/ExternalWrapper.kt
index ebcf85c..f928e65 100644
--- a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/ExternalWrapper.kt
+++ b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/ExternalWrapper.kt
@@ -10,6 +10,7 @@
 import kotlin.wasm.internal.reftypes.anyref
 import kotlin.wasm.unsafe.withScopedMemoryAllocator
 import kotlin.wasm.unsafe.UnsafeWasmMemoryApi
+import kotlin.wasm.internal.reftypes.stringref
 
 internal typealias ExternalInterfaceType = JsAny
 
@@ -185,93 +186,11 @@
         x.asWasmExternRef()
 }
 
-internal fun stringLength(x: ExternalInterfaceType): Int =
-    js("x.length")
-
-// kotlin string to js string export
-// TODO Uint16Array may work with byte endian different with Wasm (i.e. little endian)
-internal fun importStringFromWasm(address: Int, length: Int, prefix: ExternalInterfaceType?): JsString {
-    js("""
-    const mem16 = new Uint16Array(wasmExports.memory.buffer, address, length);
-    const str = String.fromCharCode.apply(null, mem16);
-    return (prefix == null) ? str : prefix + str;
-    """)
-}
-
-internal fun kotlinToJsStringAdapter(x: String?): JsString? {
-    // Using nullable String to represent default value
-    // for parameters with default values
-    if (x == null) return null
-    if (x.isEmpty()) return jsEmptyString
-
-    val srcArray = x.chars
-    val stringLength = srcArray.len()
-    val maxStringLength = STRING_INTEROP_MEM_BUFFER_SIZE / CHAR_SIZE_BYTES
-
-    @OptIn(UnsafeWasmMemoryApi::class)
-    withScopedMemoryAllocator { allocator ->
-        val memBuffer = allocator.allocate(stringLength.coerceAtMost(maxStringLength) * CHAR_SIZE_BYTES).address.toInt()
-
-        var result: ExternalInterfaceType? = null
-        var srcStartIndex = 0
-        while (srcStartIndex < stringLength - maxStringLength) {
-            unsafeWasmCharArrayToRawMemory(srcArray, srcStartIndex, maxStringLength, memBuffer)
-            result = importStringFromWasm(memBuffer, maxStringLength, result)
-            srcStartIndex += maxStringLength
-        }
-
-        unsafeWasmCharArrayToRawMemory(srcArray, srcStartIndex, stringLength - srcStartIndex, memBuffer)
-        return importStringFromWasm(memBuffer, stringLength - srcStartIndex, result)
-    }
-}
-
 internal fun jsCheckIsNullOrUndefinedAdapter(x: ExternalInterfaceType?): ExternalInterfaceType? =
     x.takeIf { !isNullish(it) }
 
-// js string to kotlin string import
-// TODO Uint16Array may work with byte endian different with Wasm (i.e. little endian)
-internal fun jsExportStringToWasm(src: ExternalInterfaceType, srcOffset: Int, srcLength: Int, dstAddr: Int) {
-    js("""
-    const mem16 = new Uint16Array(wasmExports.memory.buffer, dstAddr, srcLength);
-    let arrayIndex = 0;
-    let srcIndex = srcOffset;
-    while (arrayIndex < srcLength) {
-        mem16.set([src.charCodeAt(srcIndex)], arrayIndex);
-        srcIndex++;
-        arrayIndex++;
-    }     
-    """)
-}
-
 private const val STRING_INTEROP_MEM_BUFFER_SIZE = 65_536 // 1 page 4KiB
 
-internal fun jsToKotlinStringAdapter(x: ExternalInterfaceType): String {
-    val stringLength = stringLength(x)
-    val dstArray = WasmCharArray(stringLength)
-    if (stringLength == 0) {
-        return dstArray.createString()
-    }
-
-    @OptIn(UnsafeWasmMemoryApi::class)
-    withScopedMemoryAllocator { allocator ->
-        val maxStringLength = STRING_INTEROP_MEM_BUFFER_SIZE / CHAR_SIZE_BYTES
-        val memBuffer = allocator.allocate(stringLength.coerceAtMost(maxStringLength) * CHAR_SIZE_BYTES).address.toInt()
-
-        var srcStartIndex = 0
-        while (srcStartIndex < stringLength - maxStringLength) {
-            jsExportStringToWasm(x, srcStartIndex, maxStringLength, memBuffer)
-            unsafeRawMemoryToWasmCharArray(memBuffer, srcStartIndex, maxStringLength, dstArray)
-            srcStartIndex += maxStringLength
-        }
-
-        jsExportStringToWasm(x, srcStartIndex, stringLength - srcStartIndex, memBuffer)
-        unsafeRawMemoryToWasmCharArray(memBuffer, srcStartIndex, stringLength - srcStartIndex, dstArray)
-    }
-
-    return dstArray.createString()
-}
-
-
 private fun getJsEmptyString(): JsString =
     js("''")
 
@@ -293,29 +212,8 @@
         return value
     }
 
-private var _jsTrue: JsBoolean? = null
-private val jsTrue: JsBoolean
-    get() {
-        var value = _jsTrue
-        if (value == null) {
-            value = getJsTrue()
-            _jsTrue = value
-        }
-
-        return value
-    }
-
-private var _jsFalse: JsBoolean? = null
-private val jsFalse: JsBoolean
-    get() {
-        var value = _jsFalse
-        if (value == null) {
-            value = getJsFalse()
-            _jsFalse = value
-        }
-
-        return value
-    }
+private val jsTrue by lazy(::getJsTrue)
+private val jsFalse by lazy(::getJsFalse)
 
 internal fun numberToDoubleAdapter(x: Number): Double =
     x.toDouble()
@@ -369,9 +267,18 @@
 internal fun kotlinCharToExternRefAdapter(x: Char): ExternalInterfaceType =
     intToExternref(x.toInt())
 
+internal fun kotlinToJsStringAdapter(x: String?): stringref? =
+    x?.reference
+
+internal fun jsToKotlinStringAdapter(x: stringref): String =
+    String(x)
+
 internal fun newJsArray(): ExternalInterfaceType =
     js("[]")
 
 internal fun jsArrayPush(array: ExternalInterfaceType, element: ExternalInterfaceType) {
     js("array.push(element);")
 }
+
+internal fun jsArrayPushString(array: ExternalInterfaceType, element: stringref): Unit =
+    js("array.push(element)")
diff --git a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/TypeInfo.kt b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/TypeInfo.kt
index a093b14..716efcb 100644
--- a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/TypeInfo.kt
+++ b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/TypeInfo.kt
@@ -80,4 +80,4 @@
 
 @ExcludedFromCodegen
 internal fun <T> wasmGetTypeInfoData(): TypeInfoData =
-    implementedAsIntrinsic
+    implementedAsIntrinsic
\ No newline at end of file
diff --git a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/WasmInstructions.kt b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/WasmInstructions.kt
index ab1fb81..5fbaa63 100644
--- a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/WasmInstructions.kt
+++ b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/WasmInstructions.kt
@@ -9,6 +9,7 @@
 
 package kotlin.wasm.internal
 
+import kotlin.wasm.internal.reftypes.*
 import kotlin.wasm.internal.ExternalInterfaceType
 
 @WasmOp(WasmOp.UNREACHABLE)
@@ -390,3 +391,80 @@
 
 @WasmOp(WasmOp.REF_IS_NULL)
 internal external fun wasm_externref_is_null(a: ExternalInterfaceType?): Boolean
+
+// stringref proposal
+
+internal fun wasm_string_new_wtf16(address: Int, codeunits: Int): stringref =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_NEW_WTF16_ARRAY)
+internal fun wasm_string_new_wtf16_array(codeunits: WasmCharArray, start: Int, end: Int): stringref =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_MEASURE_WTF16)
+internal fun wasm_string_measure_wtf16(string: stringref): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_MEASURE_UTF8)
+internal fun wasm_string_measure_utf8(string: stringref): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_MEASURE_WTF8)
+internal fun wasm_string_measure_wtf8(string: stringref): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_ENCODE_WTF16_ARRAY)
+internal fun wasm_string_encode_wtf16_array(string: stringref, array: WasmCharArray, start: Int): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_NEW_LOSSY_UTF8_ARRAY)
+internal fun wasm_string_new_lossy_utf8_array(codeunits: WasmByteArray, start: Int, end: Int): stringref =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_ENCODE_LOSSY_UTF8_ARRAY)
+internal fun wasm_string_encode_lossy_utf8_array(string: stringref, array: WasmByteArray, start: Int): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_CONCAT)
+internal fun wasm_string_concat(string1: stringref, string2: stringref): stringref =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_EQ)
+internal fun wasm_string_eq(string1: stringref, string2: stringref): Boolean =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRINGVIEW_AS_WTF16)
+internal fun wasm_string_as_wtf16(string: stringref): stringview_wtf16 =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRINGVIEW_WTF16_LENGTH)
+internal fun wasm_stringview_wtf16_length(stringView: stringview_wtf16): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRINGVIEW_WTF16_GET_CODEUNIT)
+internal fun wasm_stringview_wtf16_get_codeunit(stringView: stringview_wtf16, pos: Int): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRINGVIEW_WTF16_SLICE)
+internal fun wasm_stringview_wtf16_slice(stringView: stringview_wtf16, start: Int, end: Int): stringref =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRING_AS_ITER)
+internal fun wasm_string_as_iter(string: stringref): stringview_iter =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRINGVIEW_ITER_NEXT)
+internal fun wasm_stringview_iter_next(view: stringview_iter): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRINGVIEW_ITER_ADVANCE)
+internal fun wasm_stringview_iter_advance(view: stringview_iter, codepoints: Int): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRINGVIEW_ITER_REWIND)
+internal fun wasm_stringview_iter_rewind(view: stringview_iter, codepoints: Int): Int =
+    implementedAsIntrinsic
+
+@WasmOp(WasmOp.STRINGVIEW_ITER_SLICE)
+internal fun wasm_stringview_iter_slice(view: stringview_iter, codepoints: Int): Int =
+    implementedAsIntrinsic
\ No newline at end of file
diff --git a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/reftypes/WasmReferenceTypes.kt b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/reftypes/WasmReferenceTypes.kt
index 6c75bb4..38a2425 100644
--- a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/reftypes/WasmReferenceTypes.kt
+++ b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/reftypes/WasmReferenceTypes.kt
@@ -23,4 +23,7 @@
 internal interface eqref : anyref
 internal interface structref : eqref
 internal interface i31ref : eqref
-internal interface funcref : anyref
\ No newline at end of file
+internal interface funcref : anyref
+internal interface stringref
+internal interface stringview_wtf16
+internal interface stringview_iter
diff --git a/libraries/stdlib/wasm/src/generated/wasm/internal/_WasmOp.kt b/libraries/stdlib/wasm/src/generated/wasm/internal/_WasmOp.kt
index 766593a..47fe837 100644
--- a/libraries/stdlib/wasm/src/generated/wasm/internal/_WasmOp.kt
+++ b/libraries/stdlib/wasm/src/generated/wasm/internal/_WasmOp.kt
@@ -255,6 +255,25 @@
         const val BR_ON_CAST_FAIL = "BR_ON_CAST_FAIL"
         const val EXTERN_INTERNALIZE = "EXTERN_INTERNALIZE"
         const val EXTERN_EXTERNALIZE = "EXTERN_EXTERNALIZE"
+        const val STRING_CONST = "STRING_CONST"
+        const val STRING_CONCAT = "STRING_CONCAT"
+        const val STRING_EQ = "STRING_EQ"
+        const val STRING_AS_ITER = "STRING_AS_ITER"
+        const val STRING_NEW_WTF16_ARRAY = "STRING_NEW_WTF16_ARRAY"
+        const val STRING_MEASURE_UTF8 = "STRING_MEASURE_UTF8"
+        const val STRING_MEASURE_WTF8 = "STRING_MEASURE_WTF8"
+        const val STRING_MEASURE_WTF16 = "STRING_MEASURE_WTF16"
+        const val STRING_ENCODE_WTF16_ARRAY = "STRING_ENCODE_WTF16_ARRAY"
+        const val STRING_NEW_LOSSY_UTF8_ARRAY = "STRING_NEW_LOSSY_UTF8_ARRAY"
+        const val STRING_ENCODE_LOSSY_UTF8_ARRAY = "STRING_ENCODE_LOSSY_UTF8_ARRAY"
+        const val STRINGVIEW_ITER_NEXT = "STRINGVIEW_ITER_NEXT"
+        const val STRINGVIEW_ITER_ADVANCE = "STRINGVIEW_ITER_ADVANCE"
+        const val STRINGVIEW_ITER_REWIND = "STRINGVIEW_ITER_REWIND"
+        const val STRINGVIEW_ITER_SLICE = "STRINGVIEW_ITER_SLICE"
+        const val STRINGVIEW_AS_WTF16 = "STRINGVIEW_AS_WTF16"
+        const val STRINGVIEW_WTF16_LENGTH = "STRINGVIEW_WTF16_LENGTH"
+        const val STRINGVIEW_WTF16_GET_CODEUNIT = "STRINGVIEW_WTF16_GET_CODEUNIT"
+        const val STRINGVIEW_WTF16_SLICE = "STRINGVIEW_WTF16_SLICE"
         const val GET_UNIT = "GET_UNIT"
         const val PSEUDO_COMMENT_PREVIOUS_INSTR = "PSEUDO_COMMENT_PREVIOUS_INSTR"
         const val PSEUDO_COMMENT_GROUP_START = "PSEUDO_COMMENT_GROUP_START"
diff --git a/libraries/stdlib/wasm/src/kotlin/js/JsString.kt b/libraries/stdlib/wasm/src/kotlin/js/JsString.kt
index 103eea1..fa8a20e 100644
--- a/libraries/stdlib/wasm/src/kotlin/js/JsString.kt
+++ b/libraries/stdlib/wasm/src/kotlin/js/JsString.kt
@@ -6,11 +6,13 @@
 package kotlin.js
 
 import kotlin.wasm.internal.JsPrimitive
-import kotlin.wasm.internal.kotlinToJsStringAdapter
+import kotlin.wasm.internal.reftypes.stringref
 
-/** JavaScript primitive string */
+///** JavaScript primitive string */
 @JsPrimitive("string")
 public external class JsString internal constructor() : JsAny
 
+private fun unsafeCastToJsString(@Suppress("UNUSED_PARAMETER") ref: stringref): JsString = js("ref")
+
 public fun String.toJsString(): JsString =
-    kotlinToJsStringAdapter(this)!!
\ No newline at end of file
+    unsafeCastToJsString(reference)
\ No newline at end of file
diff --git a/libraries/stdlib/wasm/src/kotlin/text/StringBuilderWasm.kt b/libraries/stdlib/wasm/src/kotlin/text/StringBuilderWasm.kt
index e9afcaa..57fcc3a 100644
--- a/libraries/stdlib/wasm/src/kotlin/text/StringBuilderWasm.kt
+++ b/libraries/stdlib/wasm/src/kotlin/text/StringBuilderWasm.kt
@@ -8,7 +8,9 @@
 import kotlin.wasm.internal.*
 
 internal fun insertString(array: CharArray, destinationIndex: Int, value: String, sourceIndex: Int, count: Int): Int {
-    copyWasmArray(value.chars, array.storage, sourceIndex, destinationIndex, count)
+    val valueArray = WasmCharArray(value.length)
+    wasm_string_encode_wtf16_array(value.reference, valueArray, 0)
+    copyWasmArray(valueArray, array.storage, sourceIndex, destinationIndex, count)
     return count
 }
 
diff --git a/libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt b/libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt
index 753439f..295c197 100644
--- a/libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt
+++ b/libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt
@@ -118,11 +118,10 @@
 @SinceKotlin("1.4")
 @WasExperimental(ExperimentalStdlibApi::class)
 public actual fun String.toCharArray(): CharArray {
-    val thisChars = this.chars
-    val thisLength = thisChars.len()
-    val newArray = CharArray(thisLength)
-    copyWasmArray(thisChars, newArray.storage, 0, 0, thisLength)
-    return newArray
+    val thisLength = length
+    val newArray = WasmCharArray(thisLength)
+    wasm_string_encode_wtf16_array(reference, newArray, 0)
+    return CharArray(newArray)
 }
 
 /**
@@ -141,7 +140,11 @@
     AbstractList.checkBoundsIndexes(startIndex, endIndex, length)
     val newLength = endIndex - startIndex
     val newArray = CharArray(newLength)
-    copyWasmArray(this.chars, newArray.storage, startIndex, 0, newLength)
+
+    val thisArray = WasmCharArray(length)
+    wasm_string_encode_wtf16_array(reference, thisArray, 0)
+
+    copyWasmArray(thisArray, newArray.storage, startIndex, 0, newLength)
     return newArray
 }
 
diff --git a/libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt b/libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt
index b389955..9649150 100644
--- a/libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt
+++ b/libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt
@@ -5,150 +5,7 @@
 
 package kotlin.text
 
-/** Returns the negative [size] if [throwOnMalformed] is false, throws [CharacterCodingException] otherwise. */
-private fun malformed(size: Int, index: Int, throwOnMalformed: Boolean): Int {
-    if (throwOnMalformed) throw CharacterCodingException("Malformed sequence starting at ${index - 1}")
-    return -size
-}
-
-/**
- * Returns code point corresponding to UTF-16 surrogate pair,
- * where the first of the pair is the [high] and the second is in the [string] at the [index].
- * Returns zero if the pair is malformed and [throwOnMalformed] is false.
- *
- * @throws CharacterCodingException if the pair is malformed and [throwOnMalformed] is true.
- */
-private fun codePointFromSurrogate(string: String, high: Int, index: Int, endIndex: Int, throwOnMalformed: Boolean): Int {
-    if (high !in 0xD800..0xDBFF || index >= endIndex) {
-        return malformed(0, index, throwOnMalformed)
-    }
-    val low = string[index].code
-    if (low !in 0xDC00..0xDFFF) {
-        return malformed(0, index, throwOnMalformed)
-    }
-    return 0x10000 + ((high and 0x3FF) shl 10) or (low and 0x3FF)
-}
-
-/**
- * Returns code point corresponding to UTF-8 sequence of two bytes,
- * where the first byte of the sequence is the [byte1] and the second byte is in the [bytes] array at the [index].
- * Returns zero if the sequence is malformed and [throwOnMalformed] is false.
- *
- * @throws CharacterCodingException if the sequence of two bytes is malformed and [throwOnMalformed] is true.
- */
-private fun codePointFrom2(bytes: ByteArray, byte1: Int, index: Int, endIndex: Int, throwOnMalformed: Boolean): Int {
-    if (byte1 and 0x1E == 0 || index >= endIndex) {
-        return malformed(0, index, throwOnMalformed)
-    }
-    val byte2 = bytes[index].toInt()
-    if (byte2 and 0xC0 != 0x80) {
-        return malformed(0, index, throwOnMalformed)
-    }
-    return (byte1 shl 6) xor byte2 xor 0xF80
-}
-
-/**
- * Returns code point corresponding to UTF-8 sequence of three bytes,
- * where the first byte of the sequence is the [byte1] and the others are in the [bytes] array starting from the [index].
- * Returns a non-positive value indicating number of bytes from [bytes] included in malformed sequence
- * if the sequence is malformed and [throwOnMalformed] is false.
- *
- * @throws CharacterCodingException if the sequence of three bytes is malformed and [throwOnMalformed] is true.
- */
-private fun codePointFrom3(bytes: ByteArray, byte1: Int, index: Int, endIndex: Int, throwOnMalformed: Boolean): Int {
-    if (index >= endIndex) {
-        return malformed(0, index, throwOnMalformed)
-    }
-
-    val byte2 = bytes[index].toInt()
-    if (byte1 and 0xF == 0) {
-        if (byte2 and 0xE0 != 0xA0) {
-            // Non-shortest form
-            return malformed(0, index, throwOnMalformed)
-        }
-    } else if (byte1 and 0xF == 0xD) {
-        if (byte2 and 0xE0 != 0x80) {
-            // Surrogate code point
-            return malformed(0, index, throwOnMalformed)
-        }
-    } else if (byte2 and 0xC0 != 0x80) {
-        return malformed(0, index, throwOnMalformed)
-    }
-
-    if (index + 1 == endIndex) {
-        return malformed(1, index, throwOnMalformed)
-    }
-    val byte3 = bytes[index + 1].toInt()
-    if (byte3 and 0xC0 != 0x80) {
-        return malformed(1, index, throwOnMalformed)
-    }
-
-    return (byte1 shl 12) xor (byte2 shl 6) xor byte3 xor -0x1E080
-}
-
-/**
- * Returns code point corresponding to UTF-8 sequence of four bytes,
- * where the first byte of the sequence is the [byte1] and the others are in the [bytes] array starting from the [index].
- * Returns a non-positive value indicating number of bytes from [bytes] included in malformed sequence
- * if the sequence is malformed and [throwOnMalformed] is false.
- *
- * @throws CharacterCodingException if the sequence of four bytes is malformed and [throwOnMalformed] is true.
- */
-private fun codePointFrom4(bytes: ByteArray, byte1: Int, index: Int, endIndex: Int, throwOnMalformed: Boolean): Int {
-    if (index >= endIndex) {
-        malformed(0, index, throwOnMalformed)
-    }
-
-    val byte2 = bytes[index].toInt()
-    if (byte1 and 0xF == 0x0) {
-        if (byte2 and 0xF0 <= 0x80) {
-            // Non-shortest form
-            return malformed(0, index, throwOnMalformed)
-        }
-    } else if (byte1 and 0xF == 0x4) {
-        if (byte2 and 0xF0 != 0x80) {
-            // Out of Unicode code points domain (larger than U+10FFFF)
-            return malformed(0, index, throwOnMalformed)
-        }
-    } else if (byte1 and 0xF > 0x4) {
-        return malformed(0, index, throwOnMalformed)
-    } else if (byte2 and 0xC0 != 0x80) {
-        return malformed(0, index, throwOnMalformed)
-    }
-
-    if (index + 1 == endIndex) {
-        return malformed(1, index, throwOnMalformed)
-    }
-    val byte3 = bytes[index + 1].toInt()
-    if (byte3 and 0xC0 != 0x80) {
-        return malformed(1, index, throwOnMalformed)
-    }
-
-    if (index + 2 == endIndex) {
-        return malformed(2, index, throwOnMalformed)
-    }
-    val byte4 = bytes[index + 2].toInt()
-    if (byte4 and 0xC0 != 0x80) {
-        return malformed(2, index, throwOnMalformed)
-    }
-    return (byte1 shl 18) xor (byte2 shl 12) xor (byte3 shl 6) xor byte4 xor 0x381F80
-}
-
-/**
- * Maximum number of bytes needed to encode a single char.
- *
- * Code points in `0..0x7F` are encoded in a single byte.
- * Code points in `0x80..0x7FF` are encoded in two bytes.
- * Code points in `0x800..0xD7FF` or in `0xE000..0xFFFF` are encoded in three bytes.
- * Surrogate code points in `0xD800..0xDFFF` are not Unicode scalar values, therefore aren't encoded.
- * Code points in `0x10000..0x10FFFF` are represented by a pair of surrogate `Char`s and are encoded in four bytes.
- */
-private const val MAX_BYTES_PER_CHAR = 3
-
-/**
- * The byte sequence a malformed UTF-16 char sequence is replaced by.
- */
-private val REPLACEMENT_BYTE_SEQUENCE: ByteArray = byteArrayOf(0xEF.toByte(), 0xBF.toByte(), 0xBD.toByte())
+import kotlin.wasm.internal.*
 
 /**
  * Encodes the [string] using UTF-8 and returns the resulting [ByteArray].
@@ -163,42 +20,12 @@
 internal fun encodeUtf8(string: String, startIndex: Int, endIndex: Int, throwOnMalformed: Boolean): ByteArray {
     require(startIndex >= 0 && endIndex <= string.length && startIndex <= endIndex)
 
-    val bytes = ByteArray((endIndex - startIndex) * MAX_BYTES_PER_CHAR)
-    var byteIndex = 0
-    var charIndex = startIndex
-
-    while (charIndex < endIndex) {
-        val code = string[charIndex++].code
-        when {
-            code < 0x80 ->
-                bytes[byteIndex++] = code.toByte()
-            code < 0x800 -> {
-                bytes[byteIndex++] = ((code shr 6) or 0xC0).toByte()
-                bytes[byteIndex++] = ((code and 0x3F) or 0x80).toByte()
-            }
-            code < 0xD800 || code >= 0xE000 -> {
-                bytes[byteIndex++] = ((code shr 12) or 0xE0).toByte()
-                bytes[byteIndex++] = (((code shr 6) and 0x3F) or 0x80).toByte()
-                bytes[byteIndex++] = ((code and 0x3F) or 0x80).toByte()
-            }
-            else -> { // Surrogate char value
-                val codePoint = codePointFromSurrogate(string, code, charIndex, endIndex, throwOnMalformed)
-                if (codePoint <= 0) {
-                    bytes[byteIndex++] = REPLACEMENT_BYTE_SEQUENCE[0]
-                    bytes[byteIndex++] = REPLACEMENT_BYTE_SEQUENCE[1]
-                    bytes[byteIndex++] = REPLACEMENT_BYTE_SEQUENCE[2]
-                } else {
-                    bytes[byteIndex++] = ((codePoint shr 18) or 0xF0).toByte()
-                    bytes[byteIndex++] = (((codePoint shr 12) and 0x3F) or 0x80).toByte()
-                    bytes[byteIndex++] = (((codePoint shr 6) and 0x3F) or 0x80).toByte()
-                    bytes[byteIndex++] = ((codePoint and 0x3F) or 0x80).toByte()
-                    charIndex++
-                }
-            }
-        }
+    val slicedString = wasm_stringview_wtf16_slice(wasm_string_as_wtf16(string.reference), startIndex, endIndex)
+    val arraySize = if (throwOnMalformed) wasm_string_measure_utf8(slicedString) else wasm_string_measure_wtf8(slicedString)
+    if (arraySize == -1) throw CharacterCodingException("Malformed sequence")
+    return ByteArray(arraySize).also {
+        wasm_string_encode_lossy_utf8_array(slicedString, it.storage, 0)
     }
-
-    return if (bytes.size == byteIndex) bytes else bytes.copyOf(byteIndex)
 }
 
 /**
@@ -219,53 +46,9 @@
 internal fun decodeUtf8(bytes: ByteArray, startIndex: Int, endIndex: Int, throwOnMalformed: Boolean): String {
     require(startIndex >= 0 && endIndex <= bytes.size && startIndex <= endIndex)
 
-    var byteIndex = startIndex
-    val stringBuilder = StringBuilder()
-
-    while (byteIndex < endIndex) {
-        val byte = bytes[byteIndex++].toInt()
-        when {
-            byte >= 0 ->
-                stringBuilder.append(byte.toChar())
-            byte shr 5 == -2 -> {
-                val code = codePointFrom2(bytes, byte, byteIndex, endIndex, throwOnMalformed)
-                if (code <= 0) {
-                    stringBuilder.append(REPLACEMENT_CHAR)
-                    byteIndex += -code
-                } else {
-                    stringBuilder.append(code.toChar())
-                    byteIndex += 1
-                }
-            }
-            byte shr 4 == -2 -> {
-                val code = codePointFrom3(bytes, byte, byteIndex, endIndex, throwOnMalformed)
-                if (code <= 0) {
-                    stringBuilder.append(REPLACEMENT_CHAR)
-                    byteIndex += -code
-                } else {
-                    stringBuilder.append(code.toChar())
-                    byteIndex += 2
-                }
-            }
-            byte shr 3 == -2 -> {
-                val code = codePointFrom4(bytes, byte, byteIndex, endIndex, throwOnMalformed)
-                if (code <= 0) {
-                    stringBuilder.append(REPLACEMENT_CHAR)
-                    byteIndex += -code
-                } else {
-                    val high = (code - 0x10000) shr 10 or 0xD800
-                    val low = (code and 0x3FF) or 0xDC00
-                    stringBuilder.append(high.toChar())
-                    stringBuilder.append(low.toChar())
-                    byteIndex += 3
-                }
-            }
-            else -> {
-                malformed(0, byteIndex, throwOnMalformed)
-                stringBuilder.append(REPLACEMENT_CHAR)
-            }
-        }
+    val result = String(wasm_string_new_lossy_utf8_array(bytes.storage, startIndex, endIndex))
+    if (throwOnMalformed) {
+        result.forEachCodePoint { if (it == 0xFFFD) throw CharacterCodingException("Malformed sequence") }
     }
-
-    return stringBuilder.toString()
+    return result
 }
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/utils.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/utils.kt
index 2fc9ea9..a33c444 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/utils.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/utils.kt
@@ -114,4 +114,5 @@
 
 internal fun MutableList<String>.addWasmExperimentalArguments() {
     add("--experimental-wasm-gc")
+    add("--experimental-wasm-stringref")
 }
diff --git a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Declarations.kt b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Declarations.kt
index 8eb805c..8e92cad 100644
--- a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Declarations.kt
+++ b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Declarations.kt
@@ -25,6 +25,7 @@
     val exports: List<WasmExport<*>> = emptyList(),
     val elements: List<WasmElement> = emptyList(),
     val tags: List<WasmTag> = emptyList(),
+    val constantStrings: List<String> = emptyList(),
 
     val startFunction: WasmFunction? = null,
 
diff --git a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Operators.kt b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Operators.kt
index d274135..fb6ad1c 100644
--- a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Operators.kt
+++ b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Operators.kt
@@ -385,6 +385,29 @@
     EXTERN_INTERNALIZE("extern.internalize", 0xfb70), // externref -> anyref
     EXTERN_EXTERNALIZE("extern.externalize", 0xfb71), // anyref -> externref
 
+    // stringref proposal
+    STRING_CONST("string.const", 0xFB_82, CONST_I32),
+    STRING_CONCAT("string.concat", 0xFB_88),
+    STRING_EQ("string.eq", 0xFB_89),
+    STRING_AS_ITER("string.as_iter", 0xFB_A0),
+
+    STRING_NEW_WTF16_ARRAY("string.new_wtf16_array", 0xFB_B1),
+    STRING_MEASURE_UTF8("string.measure_utf8", 0xFB_83),
+    STRING_MEASURE_WTF8("string.measure_wtf8", 0xFB_84),
+    STRING_MEASURE_WTF16("string.measure_wtf16", 0xFB_85),
+    STRING_ENCODE_WTF16_ARRAY("encode_wtf16_array", 0xFB_B3),
+    STRING_NEW_LOSSY_UTF8_ARRAY("string.new_lossy_utf8_array", 0xFB_B4),
+    STRING_ENCODE_LOSSY_UTF8_ARRAY("string.encode_lossy_utf8_array", 0xFB_B6),
+
+    STRINGVIEW_ITER_NEXT("stringview_iter.next", 0xFB_A1),
+    STRINGVIEW_ITER_ADVANCE("stringview_iter.advance", 0xFB_A2),
+    STRINGVIEW_ITER_REWIND("stringview_iter.rewind", 0xFB_A3),
+    STRINGVIEW_ITER_SLICE("stringview_iter.slice", 0xFB_A4),
+    STRINGVIEW_AS_WTF16("string.as_wtf16", 0xFB_98),
+    STRINGVIEW_WTF16_LENGTH("stringview_wtf16.length", 0xFB_99),
+    STRINGVIEW_WTF16_GET_CODEUNIT("stringview_wtf16.get_codeunit", 0xFB_9A),
+    STRINGVIEW_WTF16_SLICE("stringview_wtf16.slice", 0xFB_9C),
+
     // ============================================================
     // Pseudo-instruction, just alias for a normal call. It's used to easily spot get_unit on the wasm level.
     GET_UNIT("call", 0x10, FUNC_IDX),
diff --git a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Types.kt b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Types.kt
index 210560a..55276cc 100644
--- a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Types.kt
+++ b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Types.kt
@@ -27,6 +27,9 @@
 object WasmEqRef : WasmType("eqref", -0x13)
 object WasmRefNullNoneType : WasmType("nullnone", -0x1b)
 object WasmRefNullExternrefType : WasmType("nullexternref", -0x17)
+object WasmStringRef : WasmType("stringref", -0x1c)
+object WasmStringViewWTF16 : WasmType("stringview_wtf16", -0x1e)
+object WasmStringViewIter : WasmType("stringview_iter", -0x1f)
 
 data class WasmRefNullType(val heapType: WasmHeapType) : WasmType("ref null", -0x14)
 data class WasmRefType(val heapType: WasmHeapType) : WasmType("ref", -0x15)
@@ -49,6 +52,12 @@
         object Extern : Simple("extern", -0x11)
         object Any : Simple("any", -0x12)
         object Eq : Simple("eq", -0x13)
+        object StringRef : Simple("string", -0x1c)
+        object StringViewWtf16 : Simple("stringview", -0x1e)
+
+        @Suppress("unused")
+        object ExnH : Simple("exn", -0x18)
+
         object Struct : Simple("struct", -0x19)
         object NullNone : Simple("nullref", -0x1b)
         object NullNoExtern : Simple("nullexternref", -0x17)
diff --git a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/WasmExpressionBuilder.kt b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/WasmExpressionBuilder.kt
index 1de08074..f0a4d58 100644
--- a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/WasmExpressionBuilder.kt
+++ b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/WasmExpressionBuilder.kt
@@ -47,6 +47,10 @@
         buildInstr(WasmOp.UNREACHABLE, location)
     }
 
+    fun buildConstStringSymbol(value: WasmSymbol<Int>, location: SourceLocation) {
+        buildInstr(WasmOp.STRING_CONST, location, WasmImmediate.SymbolI32(value))
+    }
+
     @Suppress("UNUSED_PARAMETER")
     inline fun buildBlock(label: String?, resultType: WasmType? = null, body: (Int) -> Unit) {
         numberOfNestedBlocks++
diff --git a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/convertors/WasmIrToBinary.kt b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/convertors/WasmIrToBinary.kt
index 3cd8df4..d029b93 100644
--- a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/convertors/WasmIrToBinary.kt
+++ b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/convertors/WasmIrToBinary.kt
@@ -90,6 +90,12 @@
                 tags.forEach { appendTag(it) }
             }
 
+            appendSection(14u) {
+                b.writeByte(0)
+                appendVectorSize(constantStrings.size)
+                constantStrings.forEach { appendConstString(it) }
+            }
+
             appendSection(6u) {
                 appendVectorSize(globals.size)
                 globals.forEach { appendGlobal(it) }
@@ -216,8 +222,13 @@
             return
 
         if (opcode > 0xFF) {
-            b.writeByte((opcode ushr 8).toByte())
-            b.writeByte((opcode and 0xFF).toByte())
+            val prefix = opcode ushr 8
+            b.writeByte(prefix.toByte())
+            if (prefix == 0xFB) { //stringref proposal encodes instruction with uleb
+                b.writeVarUInt32((opcode and 0xFF).toUInt())
+            } else {
+                b.writeByte((opcode and 0xFF).toByte())
+            }
         } else {
             b.writeByte(opcode.toByte())
         }
@@ -393,6 +404,12 @@
         appendExpr(c.init)
     }
 
+    private fun appendConstString(s: String) {
+        val utf8Array = s.toByteArray(Charsets.UTF_8)
+        appendVectorSize(utf8Array.size)
+        b.writeBytes(utf8Array)
+    }
+
     private fun appendTag(t: WasmTag) {
         if (t.importPair != null) {
             b.writeString(t.importPair.moduleName)
diff --git a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/convertors/WasmIrToText.kt b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/convertors/WasmIrToText.kt
index 6e34930..3eaaad9 100644
--- a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/convertors/WasmIrToText.kt
+++ b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/convertors/WasmIrToText.kt
@@ -58,7 +58,7 @@
             appendElement("align=$alignEffective")
     }
 
-    private fun appendInstr(wasmInstr: WasmInstr) {
+    private fun appendInstr(wasmInstr: WasmInstr, constantStrings: List<String>) {
         val op = wasmInstr.operator
 
         if (op.opcode == WASM_OP_PSEUDO_OPCODE) {
@@ -103,8 +103,13 @@
             }
             return
         }
+
         wasmInstr.immediates.forEach {
-            appendImmediate(it)
+            if (wasmInstr.operator == WasmOp.STRING_CONST && it is WasmImmediate.SymbolI32) {
+                appendElement("\"${constantStrings[it.value.owner]}\"")
+            } else {
+                appendImmediate(it)
+            }
         }
     }
 
@@ -243,19 +248,19 @@
                         is WasmFunction.Imported -> appendImportedFunction(it)
                         is WasmMemory -> appendMemory(it)
                         is WasmTable -> appendTable(it)
-                        is WasmGlobal -> appendGlobal(it)
+                        is WasmGlobal -> appendGlobal(it, constantStrings)
                         is WasmTag -> appendTag(it)
                         else -> error("Unknown import kind ${it::class}")
                     }
                 }
-                definedFunctions.forEach { appendDefinedFunction(it) }
+                definedFunctions.forEach { appendDefinedFunction(it, constantStrings) }
                 tables.forEach { appendTable(it) }
                 memories.forEach { appendMemory(it) }
-                globals.forEach { appendGlobal(it) }
+                globals.forEach { appendGlobal(it, constantStrings) }
                 exports.forEach { appendExport(it) }
-                elements.forEach { appendWasmElement(it) }
+                elements.forEach { appendWasmElement(it, constantStrings) }
                 startFunction?.let { appendStartFunction(it) }
-                data.forEach { appendData(it) }
+                data.forEach { appendData(it, constantStrings) }
                 tags.forEach { appendTag(it) }
             }
         }
@@ -327,7 +332,7 @@
         }
     }
 
-    private fun appendDefinedFunction(function: WasmFunction.Defined) {
+    private fun appendDefinedFunction(function: WasmFunction.Defined, constantStrings: List<String>) {
         newLineList("func") {
             appendModuleFieldReference(function)
             sameLineList("type") { appendModuleFieldReference(function.type) }
@@ -338,7 +343,7 @@
                 }
             }
             function.locals.forEach { if (!it.isParameter) appendLocal(it) }
-            function.instructions.forEach { appendInstr(it) }
+            function.instructions.forEach { appendInstr(it, constantStrings) }
         }
     }
 
@@ -364,7 +369,7 @@
         limits.maxSize?.let { appendElement(it.toString()) }
     }
 
-    private fun appendGlobal(global: WasmGlobal) {
+    private fun appendGlobal(global: WasmGlobal, constantStrings: List<String>) {
         newLineList("global") {
             appendModuleFieldReference(global)
 
@@ -375,7 +380,7 @@
             else
                 appendType(global.type)
 
-            global.init.forEach { appendInstr(it) }
+            global.init.forEach { appendInstr(it, constantStrings) }
         }
     }
 
@@ -388,7 +393,7 @@
         }
     }
 
-    private fun appendWasmElement(element: WasmElement) {
+    private fun appendWasmElement(element: WasmElement, constantStrings: List<String>) {
         newLineList("elem") {
             when (val mode = element.mode) {
                 WasmElement.Mode.Passive -> {
@@ -397,7 +402,7 @@
                     if (mode.table.id != 0) {
                         sameLineList("table") { appendModuleFieldReference(mode.table) }
                     }
-                    sameLineList("") { appendInstr(mode.offset.single()) }
+                    sameLineList("") { appendInstr(mode.offset.single(), constantStrings) }
                 }
                 WasmElement.Mode.Declarative -> {
                     appendElement("declare")
@@ -416,7 +421,7 @@
                 for (value in element.values) {
                     require(value is WasmTable.Value.Expression)
                     sameLineList("item") {
-                        appendInstr(value.expr.single())
+                        appendInstr(value.expr.single(), constantStrings)
                     }
                 }
             }
@@ -429,7 +434,7 @@
         }
     }
 
-    private fun appendData(wasmData: WasmData) {
+    private fun appendData(wasmData: WasmData, constantStrings: List<String>) {
         newLineList("data") {
             when (val mode = wasmData.mode) {
                 is WasmDataMode.Active -> {
@@ -437,7 +442,7 @@
                         sameLineList("memory") { appendElement(mode.memoryIdx.toString()) }
                     }
                     sameLineList("") {
-                        appendInstr(mode.offset.single())
+                        appendInstr(mode.offset.single(), constantStrings)
                     }
                 }
                 WasmDataMode.Passive -> {
diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/BasicWasmBoxTest.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/BasicWasmBoxTest.kt
index 97f74e0..27e96d8 100644
--- a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/BasicWasmBoxTest.kt
+++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/BasicWasmBoxTest.kt
@@ -299,7 +299,7 @@
 
                 val failsIn = InTextDirectivesUtils.findListWithPrefixes(testFile, "// WASM_FAILS_IN: ")
 
-                val exceptions = listOf(WasmVM.V8, WasmVM.SpiderMonkey).mapNotNull map@{ vm ->
+                val exceptions = listOf(WasmVM.V8/*, WasmVM.SpiderMonkey*/).mapNotNull map@{ vm ->
                     try {
                         if (debugMode >= DebugMode.DEBUG) {
                             println(" ------ Run in ${vm.name}" + if (vm.shortName in failsIn) " (expected to fail)" else "")
diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/tools/WasmVM.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/tools/WasmVM.kt
index 28e2b96..fb3a025 100644
--- a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/tools/WasmVM.kt
+++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/tools/WasmVM.kt
@@ -23,6 +23,7 @@
         override fun run(entryMjs: String, jsFiles: List<String>, workingDirectory: File?) {
             tool.run(
                 "--experimental-wasm-gc",
+                "--experimental-wasm-stringref",
                 *jsFiles.toTypedArray(),
                 "--module",
                 entryMjs,