diff --git a/src/range_bounds_map.rs b/src/range_bounds_map.rs
index a5deab5..f21f386 100644
--- a/src/range_bounds_map.rs
+++ b/src/range_bounds_map.rs
@@ -1511,8 +1511,7 @@ where
 
 // Trait Impls ==========================
 
-impl<I, K, V> IntoIterator for RangeBoundsMap<I, K, V>
-{
+impl<I, K, V> IntoIterator for RangeBoundsMap<I, K, V> {
 	type Item = (K, V);
 	type IntoIter = IntoIter<I, K, V>;
 	fn into_iter(self) -> Self::IntoIter {
@@ -1541,6 +1540,82 @@ impl<I, K, V> Iterator for IntoIter<I, K, V> {
 	}
 }
 
+impl<I, K, V> Default for RangeBoundsMap<I, K, V> {
+	fn default() -> Self {
+		RangeBoundsMap {
+			inner: BTreeMap::default(),
+			phantom: PhantomData,
+		}
+	}
+}
+
+impl<I, K, V> Serialize for RangeBoundsMap<I, K, V>
+where
+	I: Ord + Copy,
+	K: NiceRange<I> + Serialize,
+	V: Serialize,
+{
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		let mut map = serializer.serialize_map(Some(self.len()))?;
+		for (range_bounds, value) in self.iter() {
+			map.serialize_entry(range_bounds, value)?;
+		}
+		map.end()
+	}
+}
+
+impl<'de, I, K, V> Deserialize<'de> for RangeBoundsMap<I, K, V>
+where
+	I: Ord + Copy,
+	K: NiceRange<I> + Deserialize<'de>,
+	V: Deserialize<'de>,
+{
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		deserializer.deserialize_map(RangeBoundsMapVisitor {
+			i: PhantomData,
+			k: PhantomData,
+			v: PhantomData,
+		})
+	}
+}
+
+struct RangeBoundsMapVisitor<I, K, V> {
+	i: PhantomData<I>,
+	k: PhantomData<K>,
+	v: PhantomData<V>,
+}
+
+impl<'de, I, K, V> Visitor<'de> for RangeBoundsMapVisitor<I, K, V>
+where
+	I: Ord + Copy,
+	K: NiceRange<I> + Deserialize<'de>,
+	V: Deserialize<'de>,
+{
+	type Value = RangeBoundsMap<I, K, V>;
+
+	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		formatter.write_str("a RangeBoundsMap")
+	}
+
+	fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+	where
+		A: MapAccess<'de>,
+	{
+		let mut map = RangeBoundsMap::new();
+		while let Some((range_bounds, value)) = access.next_entry()? {
+			map.insert_strict(range_bounds, value)
+				.map_err(|_| serde::de::Error::custom("RangeBounds overlap"))?;
+		}
+		Ok(map)
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use std::ops::Bound;
diff --git a/src/range_bounds_set.rs b/src/range_bounds_set.rs
index 2c25e2d..7fa8229 100644
--- a/src/range_bounds_set.rs
+++ b/src/range_bounds_set.rs
@@ -1,5 +1,11 @@
+use std::fmt;
+use std::marker::PhantomData;
 use std::ops::Bound;
 
+use serde::de::{SeqAccess, Visitor};
+use serde::ser::SerializeSeq;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
 use crate::range_bounds_map::{IntoIter as RangeBoundsMapIntoIter, NiceRange};
 use crate::{
 	OverlapError, OverlapOrTryFromBoundsError, RangeBoundsMap, TryFromBounds,
@@ -204,3 +210,76 @@ impl<I, K> Iterator for IntoIter<I, K> {
 		self.inner.next().map(first)
 	}
 }
+
+impl<I, K> Default for RangeBoundsSet<I, K>
+where
+	I: PartialOrd,
+{
+	fn default() -> Self {
+		RangeBoundsSet {
+			inner: RangeBoundsMap::default(),
+		}
+	}
+}
+
+impl<I, K> Serialize for RangeBoundsSet<I, K>
+where
+    I: Ord + Copy,
+	K: NiceRange<I> + Serialize,
+{
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		let mut seq = serializer.serialize_seq(Some(self.len()))?;
+		for range_bounds in self.iter() {
+			seq.serialize_element(&range_bounds)?;
+		}
+		seq.end()
+	}
+}
+
+impl<'de, I, K> Deserialize<'de> for RangeBoundsSet<I, K>
+where
+    I: Ord + Copy,
+	K: NiceRange<I> + Deserialize<'de>,
+{
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		deserializer.deserialize_seq(RangeBoundsSetVisitor {
+			i: PhantomData,
+			k: PhantomData,
+		})
+	}
+}
+
+struct RangeBoundsSetVisitor<I, K> {
+	i: PhantomData<I>,
+	k: PhantomData<K>,
+}
+
+impl<'de, I, K> Visitor<'de> for RangeBoundsSetVisitor<I, K>
+where
+	I: Ord + Copy,
+	K: NiceRange<I> + Deserialize<'de>,
+{
+	type Value = RangeBoundsSet<I, K>;
+
+	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		formatter.write_str("a RangeBoundsSet")
+	}
+
+	fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+	where
+		A: SeqAccess<'de>,
+	{
+		let mut set = RangeBoundsSet::new();
+		while let Some(range_bounds) = access.next_element()? {
+			set.insert_strict(range_bounds)
+				.map_err(|_| serde::de::Error::custom("RangeBounds overlap"))?;
+		}
+		Ok(set)
+	}
+}