diff --git a/Cargo.toml b/Cargo.toml
index 539eb761..8943c39f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,9 @@ include = ["src/*", "LICENSE-MIT.md", "README.md"]
 arbitrary = { version = "1", features = ["derive"], optional = true }
 document-features = { version = "0.2", optional = true }
 encoding_rs = { version = "0.8", optional = true }
-serde = { version = ">=1.0.139", optional = true }
+# 1.0.180 is the first version that requires compiler with integer128 support (1.26)
+# Because serde_if_integer128 is deprecated since 1.0.221, we do not use it anymore
+serde = { version = ">=1.0.180", optional = true }
 tokio = { version = "1.10", optional = true, default-features = false, features = ["io-util"] }
 memchr = "2.1"
 
diff --git a/Changelog.md b/Changelog.md
index 96bc8f53..7c9cef04 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -20,6 +20,10 @@
 
 ### Misc Changes
 
+- [#908]: Increase minimal supported `serde` version from 1.0.139 to 1.0.180.
+
+[#908]: https://github.com/tafia/quick-xml/pull/908
+
 
 ## 0.38.4 -- 2025-11-??
 
diff --git a/src/de/key.rs b/src/de/key.rs
index bf5ba5fc..75b82239 100644
--- a/src/de/key.rs
+++ b/src/de/key.rs
@@ -5,7 +5,7 @@ use crate::events::BytesStart;
 use crate::name::QName;
 use crate::utils::CowRef;
 use serde::de::{DeserializeSeed, Deserializer, EnumAccess, Visitor};
-use serde::{forward_to_deserialize_any, serde_if_integer128};
+use serde::forward_to_deserialize_any;
 use std::borrow::Cow;
 
 macro_rules! deserialize_num {
@@ -155,10 +155,8 @@ impl<'de, 'd> Deserializer<'de> for QNameDeserializer<'de, 'd> {
     deserialize_num!(deserialize_u32, visit_u32);
     deserialize_num!(deserialize_u64, visit_u64);
 
-    serde_if_integer128! {
-        deserialize_num!(deserialize_i128, visit_i128);
-        deserialize_num!(deserialize_u128, visit_u128);
-    }
+    deserialize_num!(deserialize_i128, visit_i128);
+    deserialize_num!(deserialize_u128, visit_u128);
 
     deserialize_num!(deserialize_f32, visit_f32);
     deserialize_num!(deserialize_f64, visit_f64);
@@ -389,10 +387,8 @@ mod tests {
     deserialized_to!(u32_: u32 = "3" => 3);
     deserialized_to!(u64_: u64 = "3" => 3);
 
-    serde_if_integer128! {
-        deserialized_to!(i128_: i128 = "-2" => -2);
-        deserialized_to!(u128_: u128 = "2" => 2);
-    }
+    deserialized_to!(i128_: i128 = "-2" => -2);
+    deserialized_to!(u128_: u128 = "2" => 2);
 
     deserialized_to!(f32_: f32 = "1.23" => 1.23);
     deserialized_to!(f64_: f64 = "1.23" => 1.23);
diff --git a/src/de/map.rs b/src/de/map.rs
index 1b2879bf..cfa0bca8 100644
--- a/src/de/map.rs
+++ b/src/de/map.rs
@@ -14,7 +14,6 @@ use crate::{
 };
 use serde::de::value::BorrowedStrDeserializer;
 use serde::de::{self, DeserializeSeed, Deserializer as _, MapAccess, SeqAccess, Visitor};
-use serde::serde_if_integer128;
 use std::borrow::Cow;
 use std::ops::Range;
 
diff --git a/src/de/mod.rs b/src/de/mod.rs
index 35ba64c6..a8a8282a 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -1973,10 +1973,6 @@
 //! [quick-xml#586]: https://github.com/tafia/quick-xml/issues/586
 //! [`impl_deserialize_for_internally_tagged_enum!`]: crate::impl_deserialize_for_internally_tagged_enum
 
-// Macros should be defined before the modules that using them
-// Also, macros should be imported before using them
-use serde::serde_if_integer128;
-
 macro_rules! forward_to_simple_type {
     ($deserialize:ident, $($mut:tt)?) => {
         #[inline]
@@ -2003,10 +1999,8 @@ macro_rules! deserialize_primitives {
         forward_to_simple_type!(deserialize_u32, $($mut)?);
         forward_to_simple_type!(deserialize_u64, $($mut)?);
 
-        serde_if_integer128! {
-            forward_to_simple_type!(deserialize_i128, $($mut)?);
-            forward_to_simple_type!(deserialize_u128, $($mut)?);
-        }
+        forward_to_simple_type!(deserialize_i128, $($mut)?);
+        forward_to_simple_type!(deserialize_u128, $($mut)?);
 
         forward_to_simple_type!(deserialize_f32, $($mut)?);
         forward_to_simple_type!(deserialize_f64, $($mut)?);
diff --git a/src/de/simple_type.rs b/src/de/simple_type.rs
index db0ab04a..5e615f14 100644
--- a/src/de/simple_type.rs
+++ b/src/de/simple_type.rs
@@ -13,7 +13,6 @@ use serde::de::value::UnitDeserializer;
 use serde::de::{
     DeserializeSeed, Deserializer, EnumAccess, IntoDeserializer, SeqAccess, VariantAccess, Visitor,
 };
-use serde::serde_if_integer128;
 use std::borrow::Cow;
 use std::ops::Range;
 
@@ -172,10 +171,8 @@ impl<'de, 'a> Deserializer<'de> for AtomicDeserializer<'de, 'a> {
     deserialize_num!(deserialize_u32 => visit_u32);
     deserialize_num!(deserialize_u64 => visit_u64);
 
-    serde_if_integer128! {
-        deserialize_num!(deserialize_i128 => visit_i128);
-        deserialize_num!(deserialize_u128 => visit_u128);
-    }
+    deserialize_num!(deserialize_i128 => visit_i128);
+    deserialize_num!(deserialize_u128 => visit_u128);
 
     deserialize_num!(deserialize_f32 => visit_f32);
     deserialize_num!(deserialize_f64 => visit_f64);
@@ -633,10 +630,8 @@ impl<'de, 'a> Deserializer<'de> for SimpleTypeDeserializer<'de, 'a> {
     deserialize_primitive!(deserialize_u32);
     deserialize_primitive!(deserialize_u64);
 
-    serde_if_integer128! {
-        deserialize_primitive!(deserialize_i128);
-        deserialize_primitive!(deserialize_u128);
-    }
+    deserialize_primitive!(deserialize_i128);
+    deserialize_primitive!(deserialize_u128);
 
     deserialize_primitive!(deserialize_f32);
     deserialize_primitive!(deserialize_f64);
@@ -984,10 +979,8 @@ mod tests {
         deserialized_to!(u32_: u32 = "3" => 3);
         deserialized_to!(u64_: u64 = "3" => 3);
 
-        serde_if_integer128! {
-            deserialized_to!(i128_: i128 = "-2" => -2);
-            deserialized_to!(u128_: u128 = "2" => 2);
-        }
+        deserialized_to!(i128_: i128 = "-2" => -2);
+        deserialized_to!(u128_: u128 = "2" => 2);
 
         deserialized_to!(f32_: f32 = "1.23" => 1.23);
         deserialized_to!(f64_: f64 = "1.23" => 1.23);
@@ -1182,10 +1175,8 @@ mod tests {
         simple!(utf8, u32_: u32 = "3" => 3);
         simple!(utf8, u64_: u64 = "3" => 3);
 
-        serde_if_integer128! {
-            simple!(utf8, i128_: i128 = "-2" => -2);
-            simple!(utf8, u128_: u128 = "2" => 2);
-        }
+        simple!(utf8, i128_: i128 = "-2" => -2);
+        simple!(utf8, u128_: u128 = "2" => 2);
 
         simple!(utf8, f32_: f32 = "1.23" => 1.23);
         simple!(utf8, f64_: f64 = "1.23" => 1.23);
@@ -1272,10 +1263,8 @@ mod tests {
         utf16!(u32_: u32 = "3" => 3);
         utf16!(u64_: u64 = "3" => 3);
 
-        serde_if_integer128! {
-            utf16!(i128_: i128 = "-2" => -2);
-            utf16!(u128_: u128 = "2" => 2);
-        }
+        utf16!(i128_: i128 = "-2" => -2);
+        utf16!(u128_: u128 = "2" => 2);
 
         utf16!(f32_: f32 = "1.23" => 1.23);
         utf16!(f64_: f64 = "1.23" => 1.23);
diff --git a/src/de/text.rs b/src/de/text.rs
index e8a0ad51..5333f7a4 100644
--- a/src/de/text.rs
+++ b/src/de/text.rs
@@ -5,7 +5,6 @@ use crate::{
 };
 use serde::de::value::BorrowedStrDeserializer;
 use serde::de::{DeserializeSeed, Deserializer, EnumAccess, VariantAccess, Visitor};
-use serde::serde_if_integer128;
 use std::borrow::Cow;
 
 /// A deserializer for a single text node of a mixed sequence of tags and text.
diff --git a/src/se/content.rs b/src/se/content.rs
index 4ffaabd5..d2969b88 100644
--- a/src/se/content.rs
+++ b/src/se/content.rs
@@ -7,7 +7,6 @@ use crate::se::{Indent, QuoteLevel, SeError, TextFormat, WriteResult, XmlName};
 use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct, Serializer,
 };
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 macro_rules! write_primitive {
@@ -202,10 +201,8 @@ impl<'w, 'i, W: Write> Serializer for ContentSerializer<'w, 'i, W> {
     write_primitive!(serialize_u32(u32));
     write_primitive!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        write_primitive!(serialize_i128(i128));
-        write_primitive!(serialize_u128(u128));
-    }
+    write_primitive!(serialize_i128(i128));
+    write_primitive!(serialize_u128(u128));
 
     write_primitive!(serialize_f32(f32));
     write_primitive!(serialize_f64(f64));
@@ -665,10 +662,8 @@ pub(super) mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000", Text);
         serialize_as!(usize_: 42000000usize       => "42000000", Text);
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000", Text);
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000", Text);
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000", Text);
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000", Text);
 
         serialize_as!(f32_: 4.2f32 => "4.2", Text);
         serialize_as!(f64_: 4.2f64 => "4.2", Text);
@@ -800,10 +795,8 @@ pub(super) mod tests {
             text!(u64_:   42000000000000u64   => "42000000000000");
             text!(usize_: 42000000usize       => "42000000");
 
-            serde_if_integer128! {
-                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-            }
+            text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+            text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
             text!(f32_: 4.2f32 => "4.2");
             text!(f64_: 4.2f64 => "4.2");
@@ -925,10 +918,8 @@ pub(super) mod tests {
             value!(u64_:   42000000000000u64   => "42000000000000");
             value!(usize_: 42000000usize       => "42000000");
 
-            serde_if_integer128! {
-                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-            }
+            value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+            value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
             value!(f32_: 4.2f32 => "4.2");
             value!(f64_: 4.2f64 => "4.2");
@@ -1136,10 +1127,8 @@ pub(super) mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000", Text);
         serialize_as!(usize_: 42000000usize       => "42000000", Text);
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000", Text);
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000", Text);
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000", Text);
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000", Text);
 
         serialize_as!(f32_: 4.2f32 => "4.2", Text);
         serialize_as!(f64_: 4.2f64 => "4.2", Text);
@@ -1264,10 +1253,8 @@ pub(super) mod tests {
             text!(u64_:   42000000000000u64   => "42000000000000");
             text!(usize_: 42000000usize       => "42000000");
 
-            serde_if_integer128! {
-                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-            }
+            text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+            text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
             text!(f32_: 4.2f32 => "4.2");
             text!(f64_: 4.2f64 => "4.2");
@@ -1389,10 +1376,8 @@ pub(super) mod tests {
             value!(u64_:   42000000000000u64   => "42000000000000");
             value!(usize_: 42000000usize => "42000000");
 
-            serde_if_integer128! {
-                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-            }
+            value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+            value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
             value!(f32_: 4.2f32 => "4.2");
             value!(f64_: 4.2f64 => "4.2");
diff --git a/src/se/element.rs b/src/se/element.rs
index 3dea52aa..28dec26d 100644
--- a/src/se/element.rs
+++ b/src/se/element.rs
@@ -10,7 +10,6 @@ use serde::ser::{
     Impossible, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
     SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, Serializer,
 };
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 /// Writes simple type content between [`ElementSerializer::key`] tags.
@@ -88,10 +87,8 @@ impl<'w, 'k, W: Write> Serializer for ElementSerializer<'w, 'k, W> {
     write_primitive!(serialize_u32(u32));
     write_primitive!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        write_primitive!(serialize_i128(i128));
-        write_primitive!(serialize_u128(u128));
-    }
+    write_primitive!(serialize_i128(i128));
+    write_primitive!(serialize_u128(u128));
 
     write_primitive!(serialize_f32(f32));
     write_primitive!(serialize_f64(f64));
@@ -700,10 +697,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "<root>42000000000000</root>");
         serialize_as!(usize_: 42000000usize       => "<root>42000000</root>");
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
 
         serialize_as!(f32_: 4.2f32 => "<root>4.2</root>");
         serialize_as!(f64_: 4.2f64 => "<root>4.2</root>");
@@ -802,10 +797,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000usize       => "42000000");
 
-                serde_if_integer128! {
-                    text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 text!(f32_: 4.2f32 => "4.2");
                 text!(f64_: 4.2f64 => "4.2");
@@ -927,10 +920,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000usize       => "42000000");
 
-                serde_if_integer128! {
-                    text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 text!(f32_: 4.2f32 => "4.2");
                 text!(f64_: 4.2f64 => "4.2");
@@ -1056,10 +1047,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000usize       => "42000000");
 
-                serde_if_integer128! {
-                    value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 value!(f32_: 4.2f32 => "4.2");
                 value!(f64_: 4.2f64 => "4.2");
@@ -1167,10 +1156,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000usize       => "42000000");
 
-                serde_if_integer128! {
-                    value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 value!(f32_: 4.2f32 => "4.2");
                 value!(f64_: 4.2f64 => "4.2");
@@ -1423,10 +1410,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "<root>42000000000000</root>");
         serialize_as!(usize_: 42000000usize       => "<root>42000000</root>");
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
 
         serialize_as!(f32_: 4.2f32 => "<root>4.2</root>");
         serialize_as!(f64_: 4.2f64 => "<root>4.2</root>");
@@ -1528,10 +1513,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000usize       => "42000000");
 
-                serde_if_integer128! {
-                    text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 text!(f32_: 4.2f32 => "4.2");
                 text!(f64_: 4.2f64 => "4.2");
@@ -1654,10 +1637,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000usize       => "42000000");
 
-                serde_if_integer128! {
-                    text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 text!(f32_: 4.2f32 => "4.2");
                 text!(f64_: 4.2f64 => "4.2");
@@ -1785,10 +1766,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000usize       => "42000000");
 
-                serde_if_integer128! {
-                    value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 value!(f32_: 4.2f32 => "4.2");
                 value!(f64_: 4.2f64 => "4.2");
@@ -1899,10 +1878,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000usize       => "42000000");
 
-                serde_if_integer128! {
-                    value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 value!(f32_: 4.2f32 => "4.2");
                 value!(f64_: 4.2f64 => "4.2");
diff --git a/src/se/key.rs b/src/se/key.rs
index 28d56fcf..24aed68e 100644
--- a/src/se/key.rs
+++ b/src/se/key.rs
@@ -1,6 +1,5 @@
 use crate::se::SeError;
 use serde::ser::{Impossible, Serialize, Serializer};
-use serde::serde_if_integer128;
 use std::fmt::{self, Write};
 
 /// A serializer, that ensures, that only plain types can be serialized,
@@ -246,10 +245,8 @@ mod tests {
     serialize_as!(u64_:   42000000000000u64   => "42000000000000");
     serialize_as!(usize_: 42000000usize       => "42000000");
 
-    serde_if_integer128! {
-        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-    }
+    serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+    serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
     serialize_as!(f32_: 4.2f32 => "4.2");
     serialize_as!(f64_: 4.2f64 => "4.2");
diff --git a/src/se/mod.rs b/src/se/mod.rs
index 1ac3782b..d0ca0bb3 100644
--- a/src/se/mod.rs
+++ b/src/se/mod.rs
@@ -25,10 +25,8 @@ macro_rules! write_primitive {
         write_primitive!(serialize_u32(u32));
         write_primitive!(serialize_u64(u64));
 
-        serde_if_integer128! {
-            write_primitive!(serialize_i128(i128));
-            write_primitive!(serialize_u128(u128));
-        }
+        write_primitive!(serialize_i128(i128));
+        write_primitive!(serialize_u128(u128));
 
         write_primitive!(serialize_f32(f32));
         write_primitive!(serialize_f64(f64));
@@ -84,7 +82,6 @@ use self::element::{ElementSerializer, Map, Struct, Tuple};
 use crate::de::TEXT_KEY;
 use crate::writer::{Indentation, ToFmtWrite};
 use serde::ser::{self, Serialize};
-use serde::serde_if_integer128;
 use std::fmt::Write;
 use std::str::from_utf8;
 
@@ -781,10 +778,8 @@ impl<'w, 'r, W: Write> ser::Serializer for Serializer<'w, 'r, W> {
     forward!(serialize_u32(u32));
     forward!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        forward!(serialize_i128(i128));
-        forward!(serialize_u128(u128));
-    }
+    forward!(serialize_i128(i128));
+    forward!(serialize_u128(u128));
 
     forward!(serialize_f32(f32));
     forward!(serialize_f64(f64));
diff --git a/src/se/simple_type.rs b/src/se/simple_type.rs
index 4e07713b..68a93071 100644
--- a/src/se/simple_type.rs
+++ b/src/se/simple_type.rs
@@ -10,7 +10,6 @@ use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
     SerializeTupleVariant, Serializer,
 };
-use serde::serde_if_integer128;
 use std::fmt::{self, Write};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -281,10 +280,8 @@ impl<W: Write> Serializer for AtomicSerializer<W> {
     write_atomic!(serialize_u32(u32));
     write_atomic!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        write_atomic!(serialize_i128(i128));
-        write_atomic!(serialize_u128(u128));
-    }
+    write_atomic!(serialize_i128(i128));
+    write_atomic!(serialize_u128(u128));
 
     write_atomic!(serialize_f32(f32));
     write_atomic!(serialize_f64(f64));
@@ -1104,10 +1101,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000");
         serialize_as!(usize_: 42000000usize       => "42000000");
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
         serialize_as!(f32_: 4.2f32 => "4.2");
         serialize_as!(f64_: 4.2f64 => "4.2");
@@ -1220,10 +1215,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000");
         serialize_as!(usize_: 42000000usize       => "42000000");
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
         serialize_as!(f32_: 4.2f32 => "4.2");
         serialize_as!(f64_: 4.2f64 => "4.2");
diff --git a/src/se/text.rs b/src/se/text.rs
index 7094adba..600e521a 100644
--- a/src/se/text.rs
+++ b/src/se/text.rs
@@ -4,7 +4,6 @@ use crate::de::TEXT_KEY;
 use crate::se::simple_type::{SimpleSeq, SimpleTypeSerializer};
 use crate::se::SeError;
 use serde::ser::{Impossible, Serialize, Serializer};
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 macro_rules! write_primitive {
@@ -49,10 +48,8 @@ impl<W: Write> Serializer for TextSerializer<W> {
     write_primitive!(serialize_u32(u32));
     write_primitive!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        write_primitive!(serialize_i128(i128));
-        write_primitive!(serialize_u128(u128));
-    }
+    write_primitive!(serialize_i128(i128));
+    write_primitive!(serialize_u128(u128));
 
     write_primitive!(serialize_f32(f32));
     write_primitive!(serialize_f64(f64));
diff --git a/tests/serde-de.rs b/tests/serde-de.rs
index ff51ab11..98cbf2b3 100644
--- a/tests/serde-de.rs
+++ b/tests/serde-de.rs
@@ -5,7 +5,6 @@ use quick_xml::DeError;
 use pretty_assertions::assert_eq;
 
 use serde::de::IgnoredAny;
-use serde::serde_if_integer128;
 use serde::Deserialize;
 
 mod serde_helpers;
@@ -112,10 +111,8 @@ mod trivial {
             eof!(u64_:   u64   = $value);
             eof!(usize_: usize = $value);
 
-            serde_if_integer128! {
-                eof!(u128_: u128 = $value);
-                eof!(i128_: i128 = $value);
-            }
+            eof!(u128_: u128 = $value);
+            eof!(i128_: i128 = $value);
 
             eof!(f32_: f32 = $value);
             eof!(f64_: f64 = $value);
@@ -613,10 +610,8 @@ mod trivial {
         in_struct!(u64_:   u64   = "42000000000000", 42000000000000u64);
         in_struct!(usize_: usize = "42000000", 42000000usize);
 
-        serde_if_integer128! {
-            in_struct!(u128_: u128 = "420000000000000000000000000000", 420000000000000000000000000000u128);
-            in_struct!(i128_: i128 = "-420000000000000000000000000000", -420000000000000000000000000000i128);
-        }
+        in_struct!(u128_: u128 = "420000000000000000000000000000", 420000000000000000000000000000u128);
+        in_struct!(i128_: i128 = "-420000000000000000000000000000", -420000000000000000000000000000i128);
 
         in_struct!(f32_: f32 = "4.2", 4.2f32);
         in_struct!(f64_: f64 = "4.2", 4.2f64);
@@ -675,10 +670,8 @@ mod trivial {
         in_struct!(u64_:   u64   = "<![CDATA[42000000000000]]>", 42000000000000u64);
         in_struct!(usize_: usize = "<![CDATA[42000000]]>", 42000000usize);
 
-        serde_if_integer128! {
-            in_struct!(u128_: u128 = "<![CDATA[420000000000000000000000000000]]>", 420000000000000000000000000000u128);
-            in_struct!(i128_: i128 = "<![CDATA[-420000000000000000000000000000]]>", -420000000000000000000000000000i128);
-        }
+        in_struct!(u128_: u128 = "<![CDATA[420000000000000000000000000000]]>", 420000000000000000000000000000u128);
+        in_struct!(i128_: i128 = "<![CDATA[-420000000000000000000000000000]]>", -420000000000000000000000000000i128);
 
         in_struct!(f32_: f32 = "<![CDATA[4.2]]>", 4.2f32);
         in_struct!(f64_: f64 = "<![CDATA[4.2]]>", 4.2f64);
@@ -1558,10 +1551,8 @@ mod xml_schema_lists {
         list!(u32_: u32 = r#"<root list="1 2  3"/>"# => vec![1, 2, 3]);
         list!(u64_: u64 = r#"<root list="1 2  3"/>"# => vec![1, 2, 3]);
 
-        serde_if_integer128! {
-            list!(i128_: i128 = r#"<root list="1 -2  3"/>"# => vec![1, -2, 3]);
-            list!(u128_: u128 = r#"<root list="1 2  3"/>"# => vec![1, 2, 3]);
-        }
+        list!(i128_: i128 = r#"<root list="1 -2  3"/>"# => vec![1, -2, 3]);
+        list!(u128_: u128 = r#"<root list="1 2  3"/>"# => vec![1, 2, 3]);
 
         list!(f32_: f32 = r#"<root list="1.23 -4.56  7.89"/>"# => vec![1.23, -4.56, 7.89]);
         list!(f64_: f64 = r#"<root list="1.23 -4.56  7.89"/>"# => vec![1.23, -4.56, 7.89]);
@@ -1606,10 +1597,8 @@ mod xml_schema_lists {
             list!(u32_: u32 = "<root>1 2  3</root>" => vec![1, 2, 3]);
             list!(u64_: u64 = "<root>1 2  3</root>" => vec![1, 2, 3]);
 
-            serde_if_integer128! {
-                list!(i128_: i128 = "<root>1 -2  3</root>" => vec![1, -2, 3]);
-                list!(u128_: u128 = "<root>1 2  3</root>" => vec![1, 2, 3]);
-            }
+            list!(i128_: i128 = "<root>1 -2  3</root>" => vec![1, -2, 3]);
+            list!(u128_: u128 = "<root>1 2  3</root>" => vec![1, 2, 3]);
 
             list!(f32_: f32 = "<root>1.23 -4.56  7.89</root>" => vec![1.23, -4.56, 7.89]);
             list!(f64_: f64 = "<root>1.23 -4.56  7.89</root>" => vec![1.23, -4.56, 7.89]);
@@ -1645,10 +1634,8 @@ mod xml_schema_lists {
             list!(u32_: u32 = "<root><![CDATA[1 2  3]]></root>" => vec![1, 2, 3]);
             list!(u64_: u64 = "<root><![CDATA[1 2  3]]></root>" => vec![1, 2, 3]);
 
-            serde_if_integer128! {
-                list!(i128_: i128 = "<root><![CDATA[1 -2  3]]></root>" => vec![1, -2, 3]);
-                list!(u128_: u128 = "<root><![CDATA[1 2  3]]></root>" => vec![1, 2, 3]);
-            }
+            list!(i128_: i128 = "<root><![CDATA[1 -2  3]]></root>" => vec![1, -2, 3]);
+            list!(u128_: u128 = "<root><![CDATA[1 2  3]]></root>" => vec![1, 2, 3]);
 
             list!(f32_: f32 = "<root><![CDATA[1.23 -4.56  7.89]]></root>" => vec![1.23, -4.56, 7.89]);
             list!(f64_: f64 = "<root><![CDATA[1.23 -4.56  7.89]]></root>" => vec![1.23, -4.56, 7.89]);
diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index 92c255d1..0bd7cb2b 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -2,7 +2,7 @@ use quick_xml::de::from_str;
 use quick_xml::se::{SeError, Serializer};
 use quick_xml::utils::Bytes;
 
-use serde::{serde_if_integer128, Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 #[derive(Debug, PartialEq, Deserialize, Serialize)]
@@ -258,10 +258,8 @@ mod without_root {
     err!(u64_:   42000000000000u64   => Unsupported("cannot serialize `u64` without defined root tag"));
     err!(usize_: 42000000usize       => Unsupported("cannot serialize `u64` without defined root tag"));
 
-    serde_if_integer128! {
-        err!(i128_: -420000000000000000000000000000i128 => Unsupported("cannot serialize `i128` without defined root tag"));
-        err!(u128_:  420000000000000000000000000000u128 => Unsupported("cannot serialize `u128` without defined root tag"));
-    }
+    err!(i128_: -420000000000000000000000000000i128 => Unsupported("cannot serialize `i128` without defined root tag"));
+    err!(u128_:  420000000000000000000000000000u128 => Unsupported("cannot serialize `u128` without defined root tag"));
 
     err!(f32_: 4.2f32 => Unsupported("cannot serialize `f32` without defined root tag"));
     err!(f64_: 4.2f64 => Unsupported("cannot serialize `f64` without defined root tag"));
@@ -1304,10 +1302,8 @@ mod without_root {
         err!(u64_:   42000000000000u64   => Unsupported("cannot serialize `u64` without defined root tag"));
         err!(usize_: 42000000usize       => Unsupported("cannot serialize `u64` without defined root tag"));
 
-        serde_if_integer128! {
-            err!(i128_: -420000000000000000000000000000i128 => Unsupported("cannot serialize `i128` without defined root tag"));
-            err!(u128_:  420000000000000000000000000000u128 => Unsupported("cannot serialize `u128` without defined root tag"));
-        }
+        err!(i128_: -420000000000000000000000000000i128 => Unsupported("cannot serialize `i128` without defined root tag"));
+        err!(u128_:  420000000000000000000000000000u128 => Unsupported("cannot serialize `u128` without defined root tag"));
 
         err!(f32_: 4.2f32 => Unsupported("cannot serialize `f32` without defined root tag"));
         err!(f64_: 4.2f64 => Unsupported("cannot serialize `f64` without defined root tag"));
@@ -1854,10 +1850,8 @@ mod with_root {
     serialize_as!(u64_:   42000000000000u64   => "<root>42000000000000</root>");
     serialize_as!(usize_: 42000000usize       => "<root>42000000</root>");
 
-    serde_if_integer128! {
-        serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
-        serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
-    }
+    serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
+    serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
 
     serialize_as!(f32_: 4.2f32 => "<root>4.2</root>");
     serialize_as!(f64_: 4.2f64 => "<root>4.2</root>");