diff --git a/.gitignore b/.gitignore
index 6b500aa..0c8227b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 /target
 /ci
-Cargo.lock
\ No newline at end of file
+/.vscode
+Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
index b04a6f8..659c797 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,21 +5,22 @@ description = "small-string optimized string type with O(1) clone"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-analyzer/smol_str"
 authors = ["Aleksey Kladov <aleksey.kladov@gmail.com>"]
-edition = "2018"
+edition = "2021"
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--cfg", "docsrs"]
 all-features = true
 
 [dependencies]
-serde = { version = "1.0.136", optional = true, default-features = false }
-arbitrary = { version = "1.1.0", optional = true }
+serde = { version = "1.0", optional = true, default-features = false }
+arbitrary = { version = "1.3", optional = true }
 
 [dev-dependencies]
-proptest = "1.0.0"
-serde_json = "1.0.79"
-serde = { version = "1.0.136", features = ["derive"] }
+proptest = "1.5"
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
 
 [features]
 default = ["std"]
 std = ["serde?/std"]
+serde = ["dep:serde"]
diff --git a/src/lib.rs b/src/lib.rs
index f49cfbf..ca9944c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -769,101 +769,4 @@ where
 }
 
 #[cfg(feature = "serde")]
-mod serde {
-    use alloc::{string::String, vec::Vec};
-    use core::fmt;
-
-    use serde::de::{Deserializer, Error, Unexpected, Visitor};
-
-    use crate::SmolStr;
-
-    // https://github.com/serde-rs/serde/blob/629802f2abfd1a54a6072992888fea7ca5bc209f/serde/src/private/de.rs#L56-L125
-    fn smol_str<'de: 'a, 'a, D>(deserializer: D) -> Result<SmolStr, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct SmolStrVisitor;
-
-        impl<'a> Visitor<'a> for SmolStrVisitor {
-            type Value = SmolStr;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a string")
-            }
-
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                Ok(SmolStr::from(v))
-            }
-
-            fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                Ok(SmolStr::from(v))
-            }
-
-            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                Ok(SmolStr::from(v))
-            }
-
-            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                match core::str::from_utf8(v) {
-                    Ok(s) => Ok(SmolStr::from(s)),
-                    Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
-                }
-            }
-
-            fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                match core::str::from_utf8(v) {
-                    Ok(s) => Ok(SmolStr::from(s)),
-                    Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
-                }
-            }
-
-            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                match String::from_utf8(v) {
-                    Ok(s) => Ok(SmolStr::from(s)),
-                    Err(e) => Err(Error::invalid_value(
-                        Unexpected::Bytes(&e.into_bytes()),
-                        &self,
-                    )),
-                }
-            }
-        }
-
-        deserializer.deserialize_str(SmolStrVisitor)
-    }
-
-    impl serde::Serialize for SmolStr {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            self.as_str().serialize(serializer)
-        }
-    }
-
-    impl<'de> serde::Deserialize<'de> for SmolStr {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: serde::Deserializer<'de>,
-        {
-            smol_str(deserializer)
-        }
-    }
-}
+mod serde;
diff --git a/src/serde.rs b/src/serde.rs
new file mode 100644
index 0000000..05b8fec
--- /dev/null
+++ b/src/serde.rs
@@ -0,0 +1,96 @@
+use alloc::{string::String, vec::Vec};
+use core::fmt;
+
+use serde::de::{Deserializer, Error, Unexpected, Visitor};
+
+use crate::SmolStr;
+
+// https://github.com/serde-rs/serde/blob/629802f2abfd1a54a6072992888fea7ca5bc209f/serde/src/private/de.rs#L56-L125
+fn smol_str<'de: 'a, 'a, D>(deserializer: D) -> Result<SmolStr, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct SmolStrVisitor;
+
+    impl<'a> Visitor<'a> for SmolStrVisitor {
+        type Value = SmolStr;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a string")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(SmolStr::from(v))
+        }
+
+        fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(SmolStr::from(v))
+        }
+
+        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(SmolStr::from(v))
+        }
+
+        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            match core::str::from_utf8(v) {
+                Ok(s) => Ok(SmolStr::from(s)),
+                Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
+            }
+        }
+
+        fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            match core::str::from_utf8(v) {
+                Ok(s) => Ok(SmolStr::from(s)),
+                Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
+            }
+        }
+
+        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            match String::from_utf8(v) {
+                Ok(s) => Ok(SmolStr::from(s)),
+                Err(e) => Err(Error::invalid_value(
+                    Unexpected::Bytes(&e.into_bytes()),
+                    &self,
+                )),
+            }
+        }
+    }
+
+    deserializer.deserialize_str(SmolStrVisitor)
+}
+
+impl serde::Serialize for SmolStr {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.as_str().serialize(serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for SmolStr {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        smol_str(deserializer)
+    }
+}