diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownSetSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownSetSerializer.java
index 91477a35..8b23f004 100644
--- a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownSetSerializer.java
+++ b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownSetSerializer.java
@@ -50,6 +50,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("{}.writeBoolSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("buffer.writeBoolSet(&{});", objectStr)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("buffer.writeBoolArray({})", objectStr)).append(LS);
                         break;
@@ -80,6 +83,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("{}.writeByteSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("buffer.writeByteSet(&{});", objectStr)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("buffer.writeByteArray({})", objectStr)).append(LS);
                         break;
@@ -110,6 +116,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("{}.writeShortSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("buffer.writeShortSet(&{});", objectStr)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("buffer.writeShortArray({})", objectStr)).append(LS);
                         break;
@@ -140,6 +149,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("{}.writeIntSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("buffer.writeIntSet(&{});", objectStr)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("buffer.writeIntArray({})", objectStr)).append(LS);
                         break;
@@ -170,6 +182,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("{}.writeLongSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("buffer.writeLongSet(&{});", objectStr)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("buffer.writeLongArray({})", objectStr)).append(LS);
                         break;
@@ -221,6 +236,7 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Cpp, Java, JavaScript, EcmaScript, TypeScript:
                         builder.append(StringUtils.format("buffer.writeFloatSet({});", objectStr)).append(LS);
                         break;
+                    case Rust, Protobuf:
                     default:
                         flag = false;
                 }
@@ -251,6 +267,7 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Cpp, Java, JavaScript, EcmaScript, TypeScript:
                         builder.append(StringUtils.format("buffer.writeDoubleSet({});", objectStr)).append(LS);
                         break;
+                    case Rust, Protobuf:
                     default:
                         flag = false;
                 }
@@ -260,6 +277,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("{}.writeStringSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("buffer.writeStringSet(&{});", objectStr)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("buffer.writeStringArray({})", objectStr)).append(LS);
                         break;
@@ -314,7 +334,7 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                         case Java:
                             builder.append(StringUtils.format("buffer.writePacketSet({}, (short) {});", objectStr, protocolId)).append(LS);
                             break;
-                        case Golang, Protobuf:
+                        case Rust, Golang, Protobuf:
                         default:
                             flag = false;
                     }
@@ -339,6 +359,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("Set {} = {}.readBoolSet($1);", set, EnhanceUtils.byteBufUtils));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("let {} = buffer.readBoolSet();", set)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("var {} = buffer.readBoolArray()", set)).append(LS);
                         break;
@@ -382,6 +405,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("Set {} = {}.readByteSet($1);", set, EnhanceUtils.byteBufUtils));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("let {} = buffer.readByteSet();", set)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("var {} = buffer.readByteArray()", set)).append(LS);
                         break;
@@ -425,6 +451,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("Set {} = {}.readShortSet($1);", set, EnhanceUtils.byteBufUtils));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("let {} = buffer.readShortSet();", set)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("var {} = buffer.readShortArray()", set)).append(LS);
                         break;
@@ -468,6 +497,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("Set {} = {}.readIntSet($1);", set, EnhanceUtils.byteBufUtils));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("let {} = buffer.readIntSet();", set)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("var {} = buffer.readIntArray()", set)).append(LS);
                         break;
@@ -511,6 +543,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("Set {} = {}.readLongSet($1);", set, EnhanceUtils.byteBufUtils));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("let {} = buffer.readLongSet();", set)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("var {} = buffer.readLongArray()", set)).append(LS);
                         break;
@@ -588,6 +623,7 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case JavaScript, EcmaScript, TypeScript:
                         builder.append(StringUtils.format("const {} = buffer.readFloatSet();", set)).append(LS);
                         break;
+                    case Rust, Protobuf:
                     default:
                         flag = false;
                 }
@@ -631,6 +667,7 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case JavaScript, EcmaScript, TypeScript:
                         builder.append(StringUtils.format("const {} = buffer.readDoubleSet();", set)).append(LS);
                         break;
+                    case Rust, Protobuf:
                     default:
                         flag = false;
                 }
@@ -640,6 +677,9 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                     case Enhance:
                         builder.append(StringUtils.format("Set {} = {}.readStringSet($1);", set, EnhanceUtils.byteBufUtils));
                         break;
+                    case Rust:
+                        builder.append(StringUtils.format("let {} = buffer.readStringSet();", set)).append(LS);
+                        break;
                     case GdScript:
                         builder.append(StringUtils.format("var {} = buffer.readStringArray()", set)).append(LS);
                         break;
@@ -717,7 +757,7 @@ public class CutDownSetSerializer implements ICutDownSerializer {
                         case JavaScript, EcmaScript, TypeScript:
                             builder.append(StringUtils.format("const {} = buffer.readPacketSet({});", set, protocolId)).append(LS);
                             break;
-                        case Golang, Protobuf:
+                        case Rust, Golang, Protobuf:
                         default:
                             flag = false;
                     }
diff --git a/protocol/src/main/resources/rust/byte_buffer.rs b/protocol/src/main/resources/rust/byte_buffer.rs
index 2478a7c6..81110844 100644
--- a/protocol/src/main/resources/rust/byte_buffer.rs
+++ b/protocol/src/main/resources/rust/byte_buffer.rs
@@ -3,6 +3,8 @@
 #![allow(non_snake_case)]
 #![allow(non_camel_case_types)]
 use std::any::Any;
+use std::collections::HashMap;
+use std::collections::HashSet;
 use crate::${protocol_root_path}::i_byte_buffer::IByteBuffer;
 use crate::${protocol_root_path}::protocol_manager::writeNoProtocolId;
 use crate::${protocol_root_path}::protocol_manager::readNoProtocolId;
@@ -625,4 +627,136 @@ impl IByteBuffer for ByteBuffer {
         }
         return array;
     }
+
+    fn writeBoolSet(&mut self, set: &HashSet<bool>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeBool(*ele);
+            }
+        }
+    }
+
+    fn readBoolSet(&mut self) -> HashSet<bool> {
+        let mut set: HashSet<bool> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readBool());
+            }
+        }
+        return set;
+    }
+
+    fn writeByteSet(&mut self, set: &HashSet<i8>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeByte(*ele);
+            }
+        }
+    }
+
+    fn readByteSet(&mut self) -> HashSet<i8> {
+        let mut set: HashSet<i8> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readByte());
+            }
+        }
+        return set;
+    }
+
+    fn writeShortSet(&mut self, set: &HashSet<i16>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeShort(*ele);
+            }
+        }
+    }
+
+    fn readShortSet(&mut self) -> HashSet<i16> {
+        let mut set: HashSet<i16> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readShort());
+            }
+        }
+        return set;
+    }
+
+    fn writeIntSet(&mut self, set: &HashSet<i32>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeInt(*ele);
+            }
+        }
+    }
+
+    fn readIntSet(&mut self) -> HashSet<i32> {
+        let mut set: HashSet<i32> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readInt());
+            }
+        }
+        return set;
+    }
+
+    fn writeLongSet(&mut self, set: &HashSet<i64>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeLong(*ele);
+            }
+        }
+    }
+
+    fn readLongSet(&mut self) -> HashSet<i64> {
+        let mut set: HashSet<i64> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readLong());
+            }
+        }
+        return set;
+    }
+
+    fn writeStringSet(&mut self, set: &HashSet<String>) {
+        if set.is_empty() {
+            self.writeInt(0);
+        } else {
+            self.writeInt(set.len() as i32);
+            for ele in set {
+                self.writeString(String::from(ele));
+            }
+        }
+    }
+
+    fn readStringSet(&mut self) -> HashSet<String> {
+        let mut set: HashSet<String> = HashSet::new();
+        let length = self.readInt();
+        if length > 0 {
+            for _index in 0..length {
+                set.insert(self.readString());
+            }
+        }
+        return set;
+    }
 }
\ No newline at end of file
diff --git a/protocol/src/main/resources/rust/i_byte_buffer.rs b/protocol/src/main/resources/rust/i_byte_buffer.rs
index 45b80c60..446c002d 100644
--- a/protocol/src/main/resources/rust/i_byte_buffer.rs
+++ b/protocol/src/main/resources/rust/i_byte_buffer.rs
@@ -2,6 +2,8 @@
 #![allow(dead_code)]
 #![allow(non_snake_case)]
 #![allow(non_camel_case_types)]
+use std::collections::HashMap;
+use std::collections::HashSet;
 use std::any::Any;
 
 pub trait IPacket {
@@ -68,4 +70,16 @@ pub trait IByteBuffer {
     fn readDoubleArray(&mut self) -> Vec<f64>;
     fn writeStringArray(&mut self, array: &Vec<String>);
     fn readStringArray(&mut self) -> Vec<String>;
+    fn writeBoolSet(&mut self, set: &HashSet<bool>);
+    fn readBoolSet(&mut self) -> HashSet<bool>;
+    fn writeByteSet(&mut self, set: &HashSet<i8>);
+    fn readByteSet(&mut self) -> HashSet<i8>;
+    fn writeShortSet(&mut self, set: &HashSet<i16>);
+    fn readShortSet(&mut self) -> HashSet<i16>;
+    fn writeIntSet(&mut self, set: &HashSet<i32>);
+    fn readIntSet(&mut self) -> HashSet<i32>;
+    fn writeLongSet(&mut self, set: &HashSet<i64>);
+    fn readLongSet(&mut self) -> HashSet<i64>;
+    fn writeStringSet(&mut self, set: &HashSet<String>);
+    fn readStringSet(&mut self) -> HashSet<String>;
 }
\ No newline at end of file