diff --git a/Cargo.toml b/Cargo.toml
index 37895c4d..263b7ec4 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/src/de/key.rs b/src/de/key.rs
index aa190297..699800f2 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 2c1e8953..3588f190 100644
--- a/src/de/map.rs
+++ b/src/de/map.rs
@@ -15,7 +15,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 7671985b..a859700d 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! deserialize_num {
     ($deserialize:ident => $visit:ident, $($mut:tt)?) => {
         fn $deserialize<V>($($mut)? self, visitor: V) -> Result<V::Value, DeError>
@@ -2010,10 +2006,8 @@ macro_rules! deserialize_primitives {
         deserialize_num!(deserialize_u32 => visit_u32, $($mut)?);
         deserialize_num!(deserialize_u64 => visit_u64, $($mut)?);
 
-        serde_if_integer128! {
-            deserialize_num!(deserialize_i128 => visit_i128, $($mut)?);
-            deserialize_num!(deserialize_u128 => visit_u128, $($mut)?);
-        }
+        deserialize_num!(deserialize_i128 => visit_i128, $($mut)?);
+        deserialize_num!(deserialize_u128 => visit_u128, $($mut)?);
 
         deserialize_num!(deserialize_f32 => visit_f32, $($mut)?);
         deserialize_num!(deserialize_f64 => visit_f64, $($mut)?);
diff --git a/src/de/simple_type.rs b/src/de/simple_type.rs
index 41db1273..824286fa 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;
 
@@ -159,10 +158,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);
@@ -603,10 +600,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);
@@ -986,10 +981,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);
@@ -1184,10 +1177,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);
@@ -1274,10 +1265,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 a72f3147..50d38401 100644
--- a/src/de/text.rs
+++ b/src/de/text.rs
@@ -6,7 +6,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 f27579a2..0192ae7d 100644
--- a/src/se/content.rs
+++ b/src/se/content.rs
@@ -7,7 +7,6 @@ use crate::se::{Indent, QuoteLevel, SeError, WriteResult, XmlName};
 use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct, Serializer,
 };
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 macro_rules! write_primitive {
@@ -197,10 +196,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));
@@ -658,10 +655,8 @@ pub(super) mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000", Text);
         serialize_as!(usize_: 42000000000000usize => "42000000000000", 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);
@@ -793,10 +788,8 @@ pub(super) mod tests {
             text!(u64_:   42000000000000u64   => "42000000000000");
             text!(usize_: 42000000000000usize => "42000000000000");
 
-            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");
@@ -918,10 +911,8 @@ pub(super) mod tests {
             value!(u64_:   42000000000000u64   => "42000000000000");
             value!(usize_: 42000000000000usize => "42000000000000");
 
-            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");
@@ -1127,10 +1118,8 @@ pub(super) mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000", Text);
         serialize_as!(usize_: 42000000000000usize => "42000000000000", 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);
@@ -1255,10 +1244,8 @@ pub(super) mod tests {
             text!(u64_:   42000000000000u64   => "42000000000000");
             text!(usize_: 42000000000000usize => "42000000000000");
 
-            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");
@@ -1380,10 +1367,8 @@ pub(super) mod tests {
             value!(u64_:   42000000000000u64   => "42000000000000");
             value!(usize_: 42000000000000usize => "42000000000000");
 
-            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 f9c43093..6b7c2b75 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));
@@ -697,10 +694,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "<root>42000000000000</root>");
         serialize_as!(usize_: 42000000000000usize => "<root>42000000000000</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>");
@@ -799,10 +794,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000000000usize => "42000000000000");
 
-                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");
@@ -924,10 +917,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000000000usize => "42000000000000");
 
-                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");
@@ -1053,10 +1044,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000000000usize => "42000000000000");
 
-                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");
@@ -1164,10 +1153,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000000000usize => "42000000000000");
 
-                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");
@@ -1418,10 +1405,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "<root>42000000000000</root>");
         serialize_as!(usize_: 42000000000000usize => "<root>42000000000000</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>");
@@ -1523,10 +1508,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000000000usize => "42000000000000");
 
-                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");
@@ -1649,10 +1632,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000000000usize => "42000000000000");
 
-                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");
@@ -1780,10 +1761,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000000000usize => "42000000000000");
 
-                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");
@@ -1894,10 +1873,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000000000usize => "42000000000000");
 
-                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 1d193ee1..46f53315 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::Write;
 
 /// A serializer, that ensures, that only plain types can be serialized,
@@ -242,10 +241,8 @@ mod tests {
     serialize_as!(u64_:   42000000000000u64   => "42000000000000");
     serialize_as!(usize_: 42000000000000usize => "42000000000000");
 
-    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 7649fe27..ffdbdb0c 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;
 
@@ -733,10 +730,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 7ca621b8..12dddb4b 100644
--- a/src/se/simple_type.rs
+++ b/src/se/simple_type.rs
@@ -9,7 +9,6 @@ use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
     SerializeTupleVariant, Serializer,
 };
-use serde::serde_if_integer128;
 use std::borrow::Cow;
 use std::fmt::Write;
 
@@ -225,10 +224,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));
@@ -965,10 +962,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000");
         serialize_as!(usize_: 42000000000000usize => "42000000000000");
 
-        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");
@@ -1081,10 +1076,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000");
         serialize_as!(usize_: 42000000000000usize => "42000000000000");
 
-        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 cc82d5f6..cf05e93f 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);
@@ -330,10 +327,8 @@ mod trivial {
         in_struct!(u64_:   u64   = "42000000000000", 42000000000000u64);
         in_struct!(usize_: usize = "42000000000000", 42000000000000usize);
 
-        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);
@@ -392,10 +387,8 @@ mod trivial {
         in_struct!(u64_:   u64   = "<![CDATA[42000000000000]]>", 42000000000000u64);
         in_struct!(usize_: usize = "<![CDATA[42000000000000]]>", 42000000000000usize);
 
-        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);
@@ -1216,10 +1209,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]);
@@ -1264,10 +1255,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]);
@@ -1303,10 +1292,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 051e47c9..67124fac 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_: 42000000000000usize => 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_: 42000000000000usize => 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_: 42000000000000usize => "<root>42000000000000</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>");