diff --git a/ets2panda/bindings/native/include/panda_types.h b/ets2panda/bindings/native/include/panda_types.h
index d29f51c232b1a2f311df23449f378d9a876ff151..4304bef4d5bc86f0c61028a26019e211a4ab644f 100644
--- a/ets2panda/bindings/native/include/panda_types.h
+++ b/ets2panda/bindings/native/include/panda_types.h
@@ -179,7 +179,7 @@ private:
 
 using KBoolean = int8_t;
 using KByte = uint8_t;
-using KChar = int16_t;
+using KChar = uint32_t;
 using KShort = int16_t;
 using KUShort = uint16_t;
 using KInt = int32_t;
diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp
index 4498536bb1f300d01c8b1a2ba89667e544d50c3f..a9244318e37e82bbb3c1f2301465e3b4be7c300d 100644
--- a/ets2panda/checker/ETSAnalyzer.cpp
+++ b/ets2panda/checker/ETSAnalyzer.cpp
@@ -3058,8 +3058,8 @@ static bool CheckIfLiteralValueIsAppropriate(ETSChecker *checker, Type *type, ir
         }
     } else if (relation->IsIdenticalTo(type, checker->GlobalCharBuiltinType())) {
         auto val = number.GetValueAndCastTo<int64_t>();
-        return !number.IsReal() && val >= std::numeric_limits<uint16_t>::min() &&
-               val <= std::numeric_limits<uint16_t>::max();
+        return !number.IsReal() && val >= std::numeric_limits<char32_t>::min() &&
+               val <= std::numeric_limits<char32_t>::max();
     } else if (number.IsDouble()) {
         if (relation->IsIdenticalTo(type, checker->GlobalFloatBuiltinType())) {
             auto doubleVal = number.GetDouble();
diff --git a/ets2panda/checker/ETSchecker.h b/ets2panda/checker/ETSchecker.h
index ae3090d76a652210c0b1dbcc48f6c488e21f8f50..62974016eb5de0593ec08760de0a987d29dd04da 100644
--- a/ets2panda/checker/ETSchecker.h
+++ b/ets2panda/checker/ETSchecker.h
@@ -311,7 +311,7 @@ public:
     IntType *CreateIntType(int32_t value);
     LongType *CreateLongType(int64_t value);
     ShortType *CreateShortType(int16_t value);
-    CharType *CreateCharType(char16_t value);
+    CharType *CreateCharType(char32_t value);
     ETSBigIntType *CreateETSBigIntLiteralType(util::StringView value);
     ETSStringType *CreateETSStringLiteralType(util::StringView value);
     ETSResizableArrayType *CreateETSMultiDimResizableArrayType(Type *element, size_t dimSize);
diff --git a/ets2panda/checker/ets/typeCreation.cpp b/ets2panda/checker/ets/typeCreation.cpp
index e9fa26308f58a54379107de036c4787763b43164..0927301b25999e57d34a9e10b4ef21b50d62dee5 100644
--- a/ets2panda/checker/ets/typeCreation.cpp
+++ b/ets2panda/checker/ets/typeCreation.cpp
@@ -61,7 +61,7 @@ ShortType *ETSChecker::CreateShortType(int16_t value)
     return ProgramAllocator()->New<ShortType>(value);
 }
 
-CharType *ETSChecker::CreateCharType(char16_t value)
+CharType *ETSChecker::CreateCharType(char32_t value)
 {
     return ProgramAllocator()->New<CharType>(value);
 }
diff --git a/ets2panda/checker/types/ets/charType.h b/ets2panda/checker/types/ets/charType.h
index 793a64ea4ed52a5ed44f86b1a6439623f9e55375..f69645a0e0799da386a3d67982277363de286b71 100644
--- a/ets2panda/checker/types/ets/charType.h
+++ b/ets2panda/checker/types/ets/charType.h
@@ -21,7 +21,7 @@
 namespace ark::es2panda::checker {
 class CharType : public Type {
 public:
-    using UType = char16_t;
+    using UType = char32_t;
 
     CharType() : Type(TypeFlag::CHAR) {}
     explicit CharType(UType value) : Type(TypeFlag::CHAR | TypeFlag::CONSTANT), value_(value) {}
diff --git a/ets2panda/compiler/core/ETSGen.cpp b/ets2panda/compiler/core/ETSGen.cpp
index 8c4f4ceb4db1c091f1d5b0f10ff0b60abe2a22f7..340263e8a10a2b279e333160cc738fcba4752bbb 100644
--- a/ets2panda/compiler/core/ETSGen.cpp
+++ b/ets2panda/compiler/core/ETSGen.cpp
@@ -1079,22 +1079,18 @@ void ETSGen::CastToChar([[maybe_unused]] const ir::AstNode *node)
         case checker::TypeFlag::BYTE:
         case checker::TypeFlag::SHORT:
         case checker::TypeFlag::INT: {
-            Sa().Emit<I32tou16>(node);
             break;
         }
         case checker::TypeFlag::LONG: {
             Sa().Emit<I64toi32>(node);
-            Sa().Emit<I32tou16>(node);
             break;
         }
         case checker::TypeFlag::FLOAT: {
-            Sa().Emit<F32toi32>(node);
-            Sa().Emit<I32tou16>(node);
+            Sa().Emit<F32tou32>(node);
             break;
         }
         case checker::TypeFlag::DOUBLE: {
-            Sa().Emit<F64toi32>(node);
-            Sa().Emit<I32tou16>(node);
+            Sa().Emit<F64tou32>(node);
             break;
         }
         case checker::TypeFlag::ETS_OBJECT: {
@@ -2025,7 +2021,6 @@ void ETSGen::UpdateOperator(const ir::AstNode *node)
         }
         case checker::TypeFlag::CHAR: {
             Sa().Emit<IntOp>(node, 1);
-            Sa().Emit<I32tou16>(node);
             break;
         }
         case checker::TypeFlag::SHORT: {
@@ -2201,7 +2196,7 @@ void ETSGen::LoadAccumulatorNull([[maybe_unused]] const ir::AstNode *node)
 #endif  // PANDA_WITH_ETS
 }
 
-void ETSGen::LoadAccumulatorChar(const ir::AstNode *node, char16_t value)
+void ETSGen::LoadAccumulatorChar(const ir::AstNode *node, char32_t value)
 {
     Sa().Emit<Ldai>(node, value);
     SetAccumulatorType(Checker()->GlobalCharType());
@@ -2669,7 +2664,7 @@ void ETSGen::LoadArrayElement(const ir::AstNode *node, VReg objectReg)
             break;
         }
         case checker::TypeFlag::CHAR: {
-            Ra().Emit<Ldarru16>(node, objectReg);
+            Ra().Emit<Ldarr>(node, objectReg);
             break;
         }
         case checker::TypeFlag::SHORT: {
@@ -2714,7 +2709,10 @@ void ETSGen::StoreArrayElement(const ir::AstNode *node, VReg objectReg, VReg ind
             Ra().Emit<Starr8>(node, objectReg, index);
             break;
         }
-        case checker::TypeFlag::CHAR:
+        case checker::TypeFlag::CHAR: {
+            Ra().Emit<Starr>(node, objectReg, index);
+            break;
+        }
         case checker::TypeFlag::SHORT: {
             Ra().Emit<Starr16>(node, objectReg, index);
             break;
diff --git a/ets2panda/compiler/core/ETSGen.h b/ets2panda/compiler/core/ETSGen.h
index 79bc976050eafc98b2116210ae330ff20df3063b..b96be29a54f3c7adca6bbd468a0f2d1148a91735 100644
--- a/ets2panda/compiler/core/ETSGen.h
+++ b/ets2panda/compiler/core/ETSGen.h
@@ -225,7 +225,7 @@ public:
 
     void LoadAccumulatorPoison(const ir::AstNode *node, const checker::Type *type);
 
-    void LoadAccumulatorChar(const ir::AstNode *node, char16_t value);
+    void LoadAccumulatorChar(const ir::AstNode *node, char32_t value);
 
     void ApplyConversion(const ir::AstNode *node)
     {
diff --git a/ets2panda/compiler/core/ETSemitter.cpp b/ets2panda/compiler/core/ETSemitter.cpp
index ce5ba4ffed1a9ed42a0dbde04652c024c93b0a7b..28941d1090b29c8a2f8eee32eebca105bae105f5 100644
--- a/ets2panda/compiler/core/ETSemitter.cpp
+++ b/ets2panda/compiler/core/ETSemitter.cpp
@@ -507,7 +507,7 @@ static pandasm::ScalarValue CreateScalarValue(ir::Literal const *literal, checke
         }
         case checker::TypeFlag::CHAR: {
             ES2PANDA_ASSERT(literal->IsCharLiteral());
-            return pandasm::ScalarValue::Create<pandasm::Value::Type::U16>(literal->AsCharLiteral()->Char());
+            return pandasm::ScalarValue::Create<pandasm::Value::Type::U32>(literal->AsCharLiteral()->Char());
         }
         case checker::TypeFlag::ETS_OBJECT: {
             ES2PANDA_ASSERT(literal->IsStringLiteral());
diff --git a/ets2panda/compiler/scripts/signatures.yaml b/ets2panda/compiler/scripts/signatures.yaml
index 2e06978b5f8f1d2babe90f3bf4eae22d46b57199..39954e5742bc0615c38e6a9c66c47ed4e1d2d81c 100644
--- a/ets2panda/compiler/scripts/signatures.yaml
+++ b/ets2panda/compiler/scripts/signatures.yaml
@@ -32,7 +32,7 @@ defines:
     ref: SET_INDEX_METHOD
   - name: $_iterator
     ref: ITERATOR_METHOD
-  - name: Iterator 
+  - name: Iterator
     ref: ITERATOR_CLASS
   - name: 'ambient_indexer'
     ref: AMBIENT_INDEXER
@@ -276,7 +276,7 @@ primitives:
   - name: u1
     ref: PRIMITIVE_BOOLEAN
 
-  - name: u16
+  - name: u32
     ref: PRIMITIVE_CHAR
 
   - name: i8
@@ -320,7 +320,7 @@ typedescriptors:
     ref: TYPE_DESCRIPTOR_INT
 
   - name: 'U'
-    ref: TYPE_DESCRIPTOR_UINT
+    ref: TYPE_DESCRIPTOR_UINT16
 
   - name: 'F'
     ref: TYPE_DESCRIPTOR_FLOAT
diff --git a/ets2panda/evaluate/helpers.cpp b/ets2panda/evaluate/helpers.cpp
index 88a631b2f782a80548f9b7e16ad7cd09951a48f8..a8b81663519709f50248dab4d95b3613d7f95c31 100644
--- a/ets2panda/evaluate/helpers.cpp
+++ b/ets2panda/evaluate/helpers.cpp
@@ -47,7 +47,7 @@ ir::TypeNode *PrimitiveToTypeNode(panda_file::Type::TypeId typeId, checker::ETSC
         case panda_file::Type::TypeId::I8:
             irType = ir::PrimitiveType::BYTE;
             break;
-        case panda_file::Type::TypeId::U16:
+        case panda_file::Type::TypeId::U32:
             irType = ir::PrimitiveType::CHAR;
             break;
         case panda_file::Type::TypeId::I16:
diff --git a/ets2panda/evaluate/helpers.h b/ets2panda/evaluate/helpers.h
index 5038bcc9ac87d1dd69e2695c24ae86cff9107b1f..e9cd5a3593829a24ead2494cfc2482fd0e4e9b92 100644
--- a/ets2panda/evaluate/helpers.h
+++ b/ets2panda/evaluate/helpers.h
@@ -85,7 +85,7 @@ static inline constexpr std::string_view DEBUGGER_API_CLASS_NAME = "DebuggerAPI"
             case panda_file::Type::TypeId::I8:         \
                 /* CC-OFFNXT(G.PRE.05) function gen */ \
                 return #TYPE_NAME_BASE "Byte";         \
-            case panda_file::Type::TypeId::U16:        \
+            case panda_file::Type::TypeId::U32:        \
                 /* CC-OFFNXT(G.PRE.05) function gen */ \
                 return #TYPE_NAME_BASE "Char";         \
             case panda_file::Type::TypeId::I16:        \
diff --git a/ets2panda/ir/astDump.cpp b/ets2panda/ir/astDump.cpp
index cc850f7341bf43e337371670a4189b4359dbac3d..e1c131042daa9954050c74d78ed54672622fbf20 100644
--- a/ets2panda/ir/astDump.cpp
+++ b/ets2panda/ir/astDump.cpp
@@ -90,8 +90,8 @@ void AstDumper::Serialize(const AstDumper::Property &prop)
         SerializeBoolean(std::get<bool>(value));
     } else if (std::holds_alternative<lexer::Number>(value)) {
         SerializeNumber(std::get<lexer::Number>(value));
-    } else if (std::holds_alternative<char16_t>(value)) {
-        SerializeChar16(std::get<char16_t>(value));
+    } else if (std::holds_alternative<char32_t>(value)) {
+        SerializeChar32(std::get<char32_t>(value));
     } else if (std::holds_alternative<const ir::AstNode *>(value)) {
         SerializeObject(std::get<const ir::AstNode *>(value));
     } else if (std::holds_alternative<std::vector<const ir::AstNode *>>(value)) {
@@ -154,9 +154,9 @@ void AstDumper::SerializeNumber(lexer::Number number)
     }
 }
 
-void AstDumper::SerializeChar16(char16_t c16)
+void AstDumper::SerializeChar32(char32_t c32)
 {
-    SerializeString(util::Helpers::UTF16toUTF8(c16).c_str());
+    SerializeString(util::Helpers::UTF32toUTF8(c32).c_str());
 }
 
 void AstDumper::SerializeBoolean(bool boolean)
diff --git a/ets2panda/ir/astDump.h b/ets2panda/ir/astDump.h
index febaf9827013db6cf04b53c63a323ffb4bd72d9c..07abe7a7d77a247c9dec1b281e97c5d4e6681acb 100644
--- a/ets2panda/ir/astDump.h
+++ b/ets2panda/ir/astDump.h
@@ -84,13 +84,13 @@ public:
         };
 
         using Val = std::variant<const char *, lexer::TokenType, std::initializer_list<Property>, util::StringView,
-                                 bool, char16_t, lexer::Number, const ir::AstNode *, std::vector<const ir::AstNode *>,
+                                 bool, char32_t, lexer::Number, const ir::AstNode *, std::vector<const ir::AstNode *>,
                                  Constant, Nullish, Ignore>;
 
         Property(const char *key, const char *string) : key_(key), value_(string) {}
         Property(const char *key, util::StringView str) : key_(key), value_(str) {}
         Property(const char *key, bool boolean) : key_(key), value_(boolean) {}
-        Property(const char *key, char16_t c16) : key_(key), value_(c16) {}
+        Property(const char *key, char32_t c16) : key_(key), value_(c16) {}
         Property(const char *key, lexer::Number number) : key_(key), value_(number) {}
         Property(const char *key, lexer::TokenType token) : key_(key), value_(token) {}
         Property(const char *key, std::initializer_list<Property> props) : key_(key), value_(props) {}
@@ -229,7 +229,7 @@ private:
     void SerializeString(const util::StringView &str);
     void SerializeNumber(size_t number);
     void SerializeNumber(lexer::Number number);
-    void SerializeChar16(char16_t c16);
+    void SerializeChar32(char32_t c32);
     void SerializeBoolean(bool boolean);
     void SerializeObject(const ir::AstNode *object);
     void SerializeToken(lexer::TokenType token);
diff --git a/ets2panda/ir/expressions/literals/charLiteral.cpp b/ets2panda/ir/expressions/literals/charLiteral.cpp
index 3dcd401f22f96dc2f48f27692e4be373ba887452..4169f13b70bf3a883a61785b5951bdeab78dd152 100644
--- a/ets2panda/ir/expressions/literals/charLiteral.cpp
+++ b/ets2panda/ir/expressions/literals/charLiteral.cpp
@@ -73,7 +73,7 @@ CharLiteral *CharLiteral::Clone(ArenaAllocator *const allocator, AstNode *const
 
 std::string CharLiteral::ToString() const
 {
-    std::string utf8Str = util::Helpers::UTF16toUTF8(char_);
+    std::string utf8Str = util::Helpers::UTF32toUTF8(char_);
     if (UNLIKELY(utf8Str.empty())) {
         return std::to_string(char_);
     }
diff --git a/ets2panda/ir/expressions/literals/charLiteral.h b/ets2panda/ir/expressions/literals/charLiteral.h
index 4ffb2f2d0812005612b86d570c7de9970264d031..219d27d467f677cfcc2bf4df586d8061acb5f2e3 100644
--- a/ets2panda/ir/expressions/literals/charLiteral.h
+++ b/ets2panda/ir/expressions/literals/charLiteral.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -28,9 +28,9 @@ public:
     NO_MOVE_SEMANTIC(CharLiteral);
 
     explicit CharLiteral() : CharLiteral(u'\u0000') {}
-    explicit CharLiteral(char16_t const character) : Literal(AstNodeType::CHAR_LITERAL), char_(character) {}
+    explicit CharLiteral(char32_t const character) : Literal(AstNodeType::CHAR_LITERAL), char_(character) {}
 
-    [[nodiscard]] char16_t Char() const noexcept
+    [[nodiscard]] char32_t Char() const noexcept
     {
         return char_;
     }
@@ -58,7 +58,7 @@ public:
     }
 
 private:
-    char16_t const char_;
+    char32_t const char_;
 };
 }  // namespace ark::es2panda::ir
 
diff --git a/ets2panda/lexer/ETSLexer.cpp b/ets2panda/lexer/ETSLexer.cpp
index bc0330997c2783c43c23cc60011ef620b055369e..68abe5d06e56ee26f5cb7a624712b39565090906 100644
--- a/ets2panda/lexer/ETSLexer.cpp
+++ b/ets2panda/lexer/ETSLexer.cpp
@@ -65,9 +65,7 @@ bool ETSLexer::ScanCharLiteral()
         }
     }
 
-    if (CheckUtf16Compatible(cp)) {
-        GetToken().c16_ = cp;
-    }
+    GetToken().c32_ = cp;
 
     if (Iterator().Peek() != LEX_CHAR_SINGLE_QUOTE) {
         LogError(diagnostic::UNSUPPORTED_CHAR_LIT);
diff --git a/ets2panda/lexer/token/token.h b/ets2panda/lexer/token/token.h
index 35d27885f84e2623c2f2727f878b74b8fdde3ad2..4ed62c634b7d848f68f11d27c310fd97ef98e6da 100644
--- a/ets2panda/lexer/token/token.h
+++ b/ets2panda/lexer/token/token.h
@@ -64,9 +64,9 @@ public:
         return flags_;
     }
 
-    char16_t Utf16() const
+    char32_t Utf32() const
     {
-        return c16_;
+        return c32_;
     }
 
     void SetTokenType(TokenType type)
@@ -158,7 +158,7 @@ private:
     SourceRange loc_ {};
     Number number_ {};
     util::StringView src_ {};
-    char16_t c16_ {};
+    char32_t c32_ {};
 };
 }  // namespace ark::es2panda::lexer
 
diff --git a/ets2panda/parser/expressionParser.cpp b/ets2panda/parser/expressionParser.cpp
index 51e44be01938081443ecfc75fd313f0946a5020d..f09b82e9efae2f7002d12e7bd2005e56f31e1b8d 100644
--- a/ets2panda/parser/expressionParser.cpp
+++ b/ets2panda/parser/expressionParser.cpp
@@ -1094,7 +1094,7 @@ ir::CharLiteral *ParserImpl::ParseCharLiteral()
 {
     ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_CHAR);
 
-    auto *charNode = AllocNode<ir::CharLiteral>(lexer_->GetToken().Utf16());
+    auto *charNode = AllocNode<ir::CharLiteral>(lexer_->GetToken().Utf32());
     ES2PANDA_ASSERT(charNode != nullptr);
     charNode->SetRange(lexer_->GetToken().Loc());
 
diff --git a/ets2panda/public/README.md b/ets2panda/public/README.md
index 819296956a07ff4543543c580bc8cd0d8d012156..0736d0b7d3be4a2fd90eb0917272845283c24ef9 100644
--- a/ets2panda/public/README.md
+++ b/ets2panda/public/README.md
@@ -501,6 +501,7 @@ Other types/classes are represented in the same way as in C-API.
 - `uint8_t` => `u8`
 - `int16_t` => `i16`
 - `char16_t` => `i16`
+- `char32_t` => `i16`
 - `int32_t` => `i32`
 - `uint32_t` => `u32`
 - `int64_t` => `i64`
diff --git a/ets2panda/public/es2panda_lib.rb b/ets2panda/public/es2panda_lib.rb
index 9e922c7ba26fa13fc2b5a837cd06192456d494fb..422f670dcbd2c0b3e191b7591803f313c54eb916 100644
--- a/ets2panda/public/es2panda_lib.rb
+++ b/ets2panda/public/es2panda_lib.rb
@@ -567,6 +567,7 @@ module Es2pandaLibApi
         'uint8_t' => 'u8',
         'int16_t' => 'i16',
         'char16_t' => 'i16',
+        'char32_t' => 'i32',
         'int32_t' => 'i32',
         'uint32_t' => 'u32',
         'int64_t' => 'i64',
@@ -1346,6 +1347,7 @@ module Es2pandaLibApi
     %w[
       char
       char16_t
+      char32_t
       short
       int
       long
diff --git a/ets2panda/test/runtime/ets/CastPrimitive.ets b/ets2panda/test/runtime/ets/CastPrimitive.ets
index c568b206e9c750f5fbbd169de5bbc92e87d244bd..3dc2d5c8a2ce44874c7e96f90b247dfda4d9df5c 100644
--- a/ets2panda/test/runtime/ets/CastPrimitive.ets
+++ b/ets2panda/test/runtime/ets/CastPrimitive.ets
@@ -38,12 +38,12 @@ function main(): void {
   let c : long = 1193046;              // 1193046 == 0x123456
   arktest.assertEQ(Long.toInt(c), 1193046)
   arktest.assertEQ(Long.toShort(c), 13398)          // 13398 == 0x3456
-  arktest.assertEQ(Long.toChar(c), c'\u3456')
+  arktest.assertEQ(Long.toChar(c), 1193046) // 0x123456 is invalid Unicode sequence
   arktest.assertEQ(Long.toByte(c), 86)              // 86 == 0x56
 
   let d : int = 126977;                // 65537 == 0x1F001
   arktest.assertEQ(Int.toShort(d), -4095)          // -4095 == 0xF001
-  arktest.assertEQ(Int.toChar(d), c'\uF001')
+  arktest.assertEQ(Int.toChar(d), c'\u{1F001}')
   arktest.assertEQ(Int.toByte(d), 1)               // 1 == 0x01
 
   let e : short = -30875;              // -30875 == 0x8765
@@ -51,7 +51,7 @@ function main(): void {
   arktest.assertEQ(Short.toFloat(e), -30875.0)
   arktest.assertEQ(Short.toLong(e), -30875)          // -30875 == 0xFFFFFFFFFFFF8765
   arktest.assertEQ(Short.toInt(e), -30875)           // -30875 == 0xFFFF8765
-  arktest.assertEQ(Short.toChar(e), c'\u8765')
+  arktest.assertEQ(Short.toChar(e), 4294936421)
   arktest.assertEQ(Short.toByte(e), 101)             // 101 == 0x65
 
   let f : char = c'\uF001';
@@ -68,7 +68,7 @@ function main(): void {
   arktest.assertEQ(Byte.toLong(g), -128)
   arktest.assertEQ(Byte.toInt(g), -128)
   arktest.assertEQ(Byte.toShort(g), -128)
-  arktest.assertEQ(Byte.toChar(g), c'\uFF80')
+  arktest.assertEQ(Byte.toChar(g), 4294967168)
   arktest.assertEQ(Int.toByte(-128), -128)
   arktest.assertEQ(Int.toByte(-129), 127)
 
diff --git a/ets2panda/test/runtime/ets/UpdateExpression.ets b/ets2panda/test/runtime/ets/UpdateExpression.ets
index a1288b3278bca7a29eb81ea7990bf398d12fcd9f..a7e7162e386d98c8a3af3a85876182693e13befb 100644
--- a/ets2panda/test/runtime/ets/UpdateExpression.ets
+++ b/ets2panda/test/runtime/ets/UpdateExpression.ets
@@ -84,9 +84,9 @@ function main(): void {
     arktest.assertEQ(Byte.toInt(++b), -128)
     arktest.assertEQ(Byte.toInt(--b), 127)
 
-    let c: char = 65535;
-    arktest.assertEQ(Char.toInt(++c), 0)
-    arktest.assertEQ(Char.toInt(--c), 65535)
+    let c: char = 4294967295;
+    arktest.assertEQ(Char.toLong(++c), 0)
+    arktest.assertEQ(Char.toLong(--c), 4294967295)
 
     let s: short = 32767;
     arktest.assertEQ(Short.toInt(++s), -32768)
diff --git a/ets2panda/test/runtime/ets/stringChar32.ets b/ets2panda/test/runtime/ets/stringChar32.ets
new file mode 100644
index 0000000000000000000000000000000000000000..cdf00a02b8fe532676f4b7868b573d23be4cea78
--- /dev/null
+++ b/ets2panda/test/runtime/ets/stringChar32.ets
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+let a = new String("🚀world🌏")
+let array: FixedArray<char>  = [c'🚀', c'w', c'o', c'r', c'l', c'd', c'🌏']
+let stringFromArray = new String(array)
+arktest.assertEQ(a, stringFromArray)
+for(let i = 0; i < a.length; i++) {
+    arktest.assertEQ(a[i], stringFromArray[i])
+}
+let charArrayFromString = a.getChars()
+for(let i = 0; i < charArrayFromString.length; i++) {
+    arktest.assertEQ(charArrayFromString[i], array[i])
+}
+arktest.assertEQ(c'\u{1F680}', c'🚀')
+arktest.assertEQ(128640 as char, c'🚀')
\ No newline at end of file
diff --git a/ets2panda/test/test-lists/ets-runtime/ets-runtime-ignored.txt b/ets2panda/test/test-lists/ets-runtime/ets-runtime-ignored.txt
index 17bbb53278c63f0ee3b8b0665aca4f87c1265d68..bda54ae36026dbf121da1bc435d92fe37807b5dc 100644
--- a/ets2panda/test/test-lists/ets-runtime/ets-runtime-ignored.txt
+++ b/ets2panda/test/test-lists/ets-runtime/ets-runtime-ignored.txt
@@ -128,3 +128,6 @@ spreadExprInNewExpr.ets
 
 # Issue #28914
 non_null_number_as_index.ets
+
+# bytecode optimizer generate incorrect bytecode for some u32 instr
+fieldImplicitCasting.ets
diff --git a/ets2panda/util/ast-builders/charLiteralBuilder.h b/ets2panda/util/ast-builders/charLiteralBuilder.h
index 701ede6cf5a00b4db8668870352b02bf7a06ea94..66fc3e4375377d97eb474dee157dd7ac01040a68 100644
--- a/ets2panda/util/ast-builders/charLiteralBuilder.h
+++ b/ets2panda/util/ast-builders/charLiteralBuilder.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -26,7 +26,7 @@ class CharLiteralBuilder : public AstBuilder<ir::CharLiteral> {
 public:
     explicit CharLiteralBuilder(ark::ArenaAllocator *allocator) : AstBuilder(allocator) {}
 
-    CharLiteralBuilder &SetValue(char16_t val)
+    CharLiteralBuilder &SetValue(char32_t val)
     {
         value_ = val;
         return *this;
@@ -39,7 +39,7 @@ public:
     }
 
 private:
-    char16_t value_ = u'\u0000';
+    char32_t value_ = u'\u0000';
 };
 
 }  // namespace ark::es2panda::ir
diff --git a/ets2panda/util/helpers.cpp b/ets2panda/util/helpers.cpp
index d493f7b99b3874429018da1ca1959146049742df..63d52e1c074f6da27c54fe4c336f92e94d87d874 100644
--- a/ets2panda/util/helpers.cpp
+++ b/ets2panda/util/helpers.cpp
@@ -691,9 +691,10 @@ std::string Helpers::CreateEscapedString(std::string_view const str)
     return escapedStr;
 }
 
-std::string Helpers::UTF16toUTF8(const char16_t c)
+std::string Helpers::UTF32toUTF8(const char32_t c)
 {
-    const utf::Utf8Char utf8Ch = utf::ConvertUtf16ToUtf8(c, 0, false);
+    auto c16 = utf::ConvertUtf32ToUtf16(c);
+    const utf::Utf8Char utf8Ch = utf::ConvertUtf16ToUtf8(c16.ch[0], c16.ch[1], false);
     return std::string(reinterpret_cast<const char *>(utf8Ch.ch.data()), utf8Ch.n);
 }
 
diff --git a/ets2panda/util/helpers.h b/ets2panda/util/helpers.h
index 16de466560dab8dafee2115f31f9f69e42584b8d..82537422f435ca524ba8107bfff00a5125d926a3 100644
--- a/ets2panda/util/helpers.h
+++ b/ets2panda/util/helpers.h
@@ -195,7 +195,7 @@ public:
     static const uint32_t INVALID_INDEX = 4294967295L;
 
     static std::string CreateEscapedString(std::string_view str);
-    static std::string UTF16toUTF8(const char16_t c);
+    static std::string UTF32toUTF8(const char32_t c);
 
     template <typename... Elements>
     static std::string AppendAll(Elements &&...elems);