diff --git a/Cargo.toml b/Cargo.toml
index cd3bc2a..43dd9ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,11 +8,9 @@ edition = "2021"
 repository = "https://github.com/pykeio/ssml"
 
 [dependencies]
-dyn-clone = "1.0"
 serde = { version = "1.0", optional = true, default-features = false, features = [ "alloc", "derive" ] }
-erased-serde = { version = "0.4", optional = true, default-features = false, features = [ "alloc" ] }
 
 [features]
 default = [ "std" ]
 std = []
-serde = [ "dep:serde", "dep:erased-serde" ]
+serde = [ "dep:serde" ]
diff --git a/src/element.rs b/src/element.rs
index 7be5d4e..f75d04f 100644
--- a/src/element.rs
+++ b/src/element.rs
@@ -1,9 +1,7 @@
-use alloc::{borrow::Cow, boxed::Box, vec::Vec};
+use alloc::{borrow::Cow, string::ToString, vec::Vec};
 use core::fmt::{Debug, Write};
 
-use dyn_clone::DynClone;
-
-use crate::{Audio, Break, Emphasis, Mark, Meta, Serialize, SerializeOptions, Text, Voice, XmlWriter};
+use crate::{Audio, Break, Emphasis, Mark, Meta, Serialize, SerializeOptions, Text, Voice, XmlWriter, util};
 
 macro_rules! el {
 	(
@@ -43,7 +41,7 @@ pub(crate) use el;
 el! {
 	/// Represents all SSML elements.
 	#[derive(Clone, Debug)]
-	#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 	#[non_exhaustive]
 	pub enum Element<'s> {
 		Text(Text<'s>),
@@ -54,9 +52,7 @@ el! {
 		Emphasis(Emphasis<'s>),
 		Mark(Mark<'s>),
 		FlavorMSTTS(crate::mstts::Element<'s>),
-		/// A dyn element can be used to implement your own custom elements outside of the `ssml` crate. See
-		/// [`DynElement`] for more information and examples.
-		Dyn(Box<dyn DynElement>)
+		Custom(CustomElement<'s>)
 		// Lang(LangElement),
 		// Paragraph(ParagraphElement),
 		// Phoneme(PhonemeElement),
@@ -82,254 +78,88 @@ impl<'s> Element<'s> {
 			Self::Break(el) => Element::Break(el),
 			Self::Emphasis(el) => Element::Emphasis(el.into_owned()),
 			Self::Mark(el) => Element::Mark(el.into_owned()),
+			Self::Custom(el) => Element::Custom(el.into_owned()),
 			_ => panic!()
 		}
 	}
 }
 
-#[cfg(feature = "serde")]
-impl<'s, 'a> serde::Deserialize<'a> for Element<'s> {
-	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-	where
-		D: serde::Deserializer<'a>
-	{
-		use alloc::string::String;
-		use core::{fmt, marker::PhantomData};
-
-		#[allow(non_camel_case_types)]
-		enum ElementField {
-			Text,
-			Audio,
-			Voice,
-			Meta,
-			Break,
-			Emphasis,
-			Mark
-		}
-
-		struct ElementFieldVisitor;
-
-		impl<'de> serde::de::Visitor<'de> for ElementFieldVisitor {
-			type Value = ElementField;
-
-			fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
-				f.write_str("variant identifier")
-			}
-
-			fn visit_u64<__E>(self, val: u64) -> serde::__private::Result<Self::Value, __E>
-			where
-				__E: serde::de::Error
-			{
-				match val {
-					0u64 => Ok(ElementField::Text),
-					1u64 => Ok(ElementField::Audio),
-					2u64 => Ok(ElementField::Voice),
-					3u64 => Ok(ElementField::Meta),
-					4u64 => Ok(ElementField::Break),
-					5u64 => Ok(ElementField::Emphasis),
-					6u64 => Ok(ElementField::Mark),
-					7u64 => Err(serde::de::Error::custom("DynElements cannot be deserialized")),
-					_ => Err(serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(val), &"variant index 0 <= i < 8"))
-				}
-			}
-
-			fn visit_str<E>(self, val: &str) -> Result<Self::Value, E>
-			where
-				E: serde::de::Error
-			{
-				match val {
-					"Text" => Ok(ElementField::Text),
-					"Audio" => Ok(ElementField::Audio),
-					"Voice" => Ok(ElementField::Voice),
-					"Meta" => Ok(ElementField::Meta),
-					"Break" => Ok(ElementField::Break),
-					"Emphasis" => Ok(ElementField::Emphasis),
-					"Mark" => Ok(ElementField::Mark),
-					"Dyn" => Err(serde::de::Error::custom("DynElements cannot be deserialized")),
-					_ => Err(serde::de::Error::unknown_variant(val, VARIANTS))
-				}
-			}
-
-			fn visit_bytes<E>(self, val: &[u8]) -> serde::__private::Result<Self::Value, E>
-			where
-				E: serde::de::Error
-			{
-				match val {
-					b"Text" => Ok(ElementField::Text),
-					b"Audio" => Ok(ElementField::Audio),
-					b"Voice" => Ok(ElementField::Voice),
-					b"Meta" => Ok(ElementField::Meta),
-					b"Break" => Ok(ElementField::Break),
-					b"Emphasis" => Ok(ElementField::Emphasis),
-					b"Mark" => Ok(ElementField::Mark),
-					b"Dyn" => Err(serde::de::Error::custom("DynElements cannot be deserialized")),
-					_ => {
-						let __value = &String::from_utf8_lossy(val);
-						Err(serde::de::Error::unknown_variant(__value, VARIANTS))
-					}
-				}
-			}
-		}
-
-		impl<'de> serde::Deserialize<'de> for ElementField {
-			#[inline]
-			fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-			where
-				D: serde::Deserializer<'de>
-			{
-				serde::Deserializer::deserialize_identifier(deserializer, ElementFieldVisitor)
-			}
-		}
-
-		#[doc(hidden)]
-		struct Visitor<'s, 'de> {
-			marker: PhantomData<Element<'s>>,
-			lifetime: PhantomData<&'de ()>
-		}
-		impl<'s, 'de> serde::de::Visitor<'de> for Visitor<'s, 'de> {
-			type Value = Element<'s>;
-
-			fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
-				f.write_str("enum Element")
-			}
-
-			fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-			where
-				A: serde::de::EnumAccess<'de>
-			{
-				match serde::de::EnumAccess::variant(data)? {
-					(ElementField::Text, variant) => serde::de::VariantAccess::newtype_variant::<Text>(variant).map(Element::Text),
-					(ElementField::Audio, variant) => serde::de::VariantAccess::newtype_variant::<Audio>(variant).map(Element::Audio),
-					(ElementField::Voice, variant) => serde::de::VariantAccess::newtype_variant::<Voice>(variant).map(Element::Voice),
-					(ElementField::Meta, variant) => serde::de::VariantAccess::newtype_variant::<Meta>(variant).map(Element::Meta),
-					(ElementField::Break, variant) => serde::de::VariantAccess::newtype_variant::<Break>(variant).map(Element::Break),
-					(ElementField::Emphasis, variant) => serde::de::VariantAccess::newtype_variant::<Emphasis>(variant).map(Element::Emphasis),
-					(ElementField::Mark, variant) => serde::de::VariantAccess::newtype_variant::<Mark>(variant).map(Element::Mark)
-				}
-			}
-		}
-
-		#[doc(hidden)]
-		const VARIANTS: &[&str] = &["Text", "Audio", "Voice", "Meta", "Break", "Emphasis", "Mark"];
-		serde::Deserializer::deserialize_enum(deserializer, "Element", VARIANTS, Visitor {
-			marker: serde::__private::PhantomData::<Element>,
-			lifetime: serde::__private::PhantomData
-		})
-	}
-}
-
 impl<'s, T: Into<Cow<'s, str>>> From<T> for Element<'s> {
 	fn from(value: T) -> Self {
 		Element::Text(Text::from(value))
 	}
 }
 
-/// A dynamic element which can be used to implement non-standard SSML elements outside of the `ssml` crate.
-///
-/// ```
-/// use std::fmt;
-///
-/// use ssml::{DynElement, Element, Serialize, SerializeOptions, XmlWriter};
-///
-/// #[derive(Debug, Clone)]
-/// #[cfg_attr(feature = "serde", derive(serde::Serialize))]
-/// pub struct TomfooleryElement {
-/// 	value: f32,
-/// 	children: Vec<Element<'static>>
-/// }
-///
-/// impl TomfooleryElement {
-/// 	// Increase the tomfoolery level of a section of elements.
-/// 	// ...
-/// 	pub fn new<'s, S: Into<Element<'s>>, I: IntoIterator<Item = S>>(value: f32, elements: I) -> Self {
-/// 		Self {
-/// 			value,
-/// 			children: elements.into_iter().map(|f| f.into().into_owned()).collect()
-/// 		}
-/// 	}
-///
-/// 	// not required, but makes your code much cleaner!
-/// 	pub fn into_dyn(self) -> Element<'static> {
-/// 		Element::Dyn(Box::new(self))
-/// 	}
-/// }
-///
-/// impl DynElement for TomfooleryElement {
-/// 	fn serialize_xml(
-/// 		&self,
-/// 		writer: &mut XmlWriter<&mut dyn fmt::Write>,
-/// 		options: &SerializeOptions
-/// 	) -> ssml::Result<()> {
-/// 		writer.element("tomfoolery", |writer| {
-/// 			writer.attr("influence", self.value)?;
-/// 			ssml::util::serialize_elements(writer, &self.children, options)
-/// 		})
-/// 	}
-/// }
-///
-/// # fn main() -> ssml::Result<()> {
-/// let doc = ssml::speak(Some("en-US"), [TomfooleryElement::new(2.0, [
-/// 	"Approaching dangerous levels of tomfoolery!"
-/// ])
-/// .into_dyn()]);
-/// let str = doc.serialize_to_string(&ssml::SerializeOptions::default().pretty())?;
-/// assert_eq!(
-/// 	str,
-/// 	r#"<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="en-US">
-/// 	<tomfoolery influence="2">
-/// 		Approaching dangerous levels of tomfoolery!
-/// 	</tomfoolery>
-/// </speak>"#
-/// );
-/// # Ok(())
-/// # }
-/// ```
-#[allow(private_bounds)]
-pub trait DynElement: Debug + DynClone + Send + OptionalErasedSerialize {
-	/// Serialize this dynamic element into an [`XmlWriter`].
-	///
-	/// See [`Serialize::serialize_xml`] for more information.
-	fn serialize_xml(&self, writer: &mut XmlWriter<&mut dyn Write>, options: &SerializeOptions) -> crate::Result<()>;
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct CustomElement<'s> {
+	tag: Cow<'s, str>,
+	attrs: Vec<(Cow<'s, str>, Cow<'s, str>)>,
+	children: Vec<Element<'s>>
+}
 
-	/// An optional tag representing this dynamic element.
-	fn tag_name(&self) -> Option<&str> {
-		None
+impl<'s> CustomElement<'s> {
+	pub fn new(tag: impl Into<Cow<'s, str>>) -> Self {
+		Self {
+			tag: tag.into(),
+			attrs: Vec::new(),
+			children: Vec::new()
+		}
 	}
 
-	/// If this element has children, returns a reference to the vector containing the element's children.
-	fn children(&self) -> Option<&Vec<Element>> {
-		None
+	pub fn with_attr(mut self, name: impl Into<Cow<'s, str>>, value: impl Into<Cow<'s, str>>) -> Self {
+		self.attrs.push((name.into(), value.into()));
+		self
 	}
 
-	/// If this element has children, returns a mutable reference to the vector containing the element's children.
-	fn children_mut(&mut self) -> Option<&mut Vec<Element>> {
-		None
+	pub fn with_child(mut self, element: impl Into<Element<'s>>) -> Self {
+		self.children.push(element.into());
+		self
 	}
-}
-
-#[cfg(feature = "serde")]
-erased_serde::serialize_trait_object!(DynElement);
 
-#[cfg(feature = "serde")]
-trait OptionalErasedSerialize: erased_serde::Serialize {}
-#[cfg(feature = "serde")]
-impl<T: serde::Serialize> OptionalErasedSerialize for T {}
+	pub fn with_children<S: Into<Element<'s>>, I: IntoIterator<Item = S>>(mut self, elements: I) -> Self {
+		self.children.extend(elements.into_iter().map(|f| f.into()));
+		self
+	}
 
-#[cfg(not(feature = "serde"))]
-trait OptionalErasedSerialize {}
-#[cfg(not(feature = "serde"))]
-impl<T> OptionalErasedSerialize for T {}
+	pub fn to_owned(&self) -> CustomElement<'static> {
+		self.clone().into_owned()
+	}
 
-dyn_clone::clone_trait_object!(DynElement);
+	pub fn into_owned(self) -> CustomElement<'static> {
+		CustomElement {
+			tag: match self.tag {
+				Cow::Borrowed(b) => Cow::Owned(b.to_string()),
+				Cow::Owned(b) => Cow::Owned(b)
+			},
+			attrs: self
+				.attrs
+				.into_iter()
+				.map(|(k, v)| {
+					(
+						match k {
+							Cow::Borrowed(b) => Cow::Owned(b.to_string()),
+							Cow::Owned(b) => Cow::Owned(b)
+						},
+						match v {
+							Cow::Borrowed(b) => Cow::Owned(b.to_string()),
+							Cow::Owned(b) => Cow::Owned(b)
+						}
+					)
+				})
+				.collect(),
+			children: self.children.into_iter().map(Element::into_owned).collect()
+		}
+	}
+}
 
-impl Serialize for Box<dyn DynElement> {
+impl<'s> Serialize for CustomElement<'s> {
 	fn serialize_xml<W: Write>(&self, writer: &mut XmlWriter<W>, options: &SerializeOptions) -> crate::Result<()> {
-		let state = {
-			let mut as_dyn = writer.to_dyn();
-			DynElement::serialize_xml(self.as_ref(), &mut as_dyn, options)?;
-			as_dyn.into_state()
-		};
-		writer.synchronize_state(state);
-		Ok(())
+		writer.element(&self.tag, |writer| {
+			for (name, value) in &self.attrs {
+				writer.attr(name, value.as_ref())?;
+			}
+			util::serialize_elements(writer, &self.children, options)
+		})
 	}
 }
diff --git a/src/lib.rs b/src/lib.rs
index 1fb25a0..5a09dea 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -58,7 +58,7 @@ pub(crate) use self::error::error;
 pub use self::{
 	audio::{Audio, AudioRepeat, audio},
 	r#break::{Break, BreakStrength, breaks},
-	element::{DynElement, Element},
+	element::{CustomElement, Element},
 	emphasis::{Emphasis, EmphasisLevel, emphasis},
 	error::{Error, Result},
 	mark::{Mark, mark},
diff --git a/src/visit.rs b/src/visit.rs
index 441c481..4a47324 100644
--- a/src/visit.rs
+++ b/src/visit.rs
@@ -32,7 +32,7 @@
 //! # }
 //! ```
 
-use crate::{Audio, Break, DynElement, Element, Emphasis, Mark, Meta, Speak, Text, Voice, mstts};
+use crate::{Audio, Break, CustomElement, Element, Emphasis, Mark, Meta, Speak, Text, Voice, mstts};
 
 pub trait Visit<'s> {
 	fn visit_speak(&mut self, node: &'s Speak) {
@@ -67,8 +67,8 @@ pub trait Visit<'s> {
 		self::visit_mark(self, node)
 	}
 
-	fn visit_dyn(&mut self, node: &'s dyn DynElement) {
-		self::visit_dyn(self, node)
+	fn visit_custom(&mut self, node: &'s CustomElement) {
+		self::visit_custom(self, node)
 	}
 
 	fn visit_mstts_element(&mut self, node: &'s mstts::Element) {
@@ -110,7 +110,7 @@ pub fn visit_emphasis<'s, V: Visit<'s> + ?Sized>(v: &mut V, node: &'s Emphasis)
 
 pub fn visit_mark<'s, V: Visit<'s> + ?Sized>(_v: &mut V, _node: &'s Mark) {}
 
-pub fn visit_dyn<'s, V: Visit<'s> + ?Sized>(_v: &mut V, _node: &'s dyn DynElement) {}
+pub fn visit_custom<'s, V: Visit<'s> + ?Sized>(_v: &mut V, _node: &'s CustomElement) {}
 
 pub fn visit_mstts_element<'s, V: Visit<'s> + ?Sized>(v: &mut V, node: &'s mstts::Element) {
 	match node {
@@ -134,7 +134,7 @@ pub fn visit_element<'s, V: Visit<'s> + ?Sized>(v: &mut V, node: &'s Element) {
 		Element::Emphasis(node) => visit_emphasis(v, node),
 		Element::Mark(node) => visit_mark(v, node),
 		Element::FlavorMSTTS(node) => visit_mstts_element(v, node),
-		Element::Dyn(node) => visit_dyn(v, node.as_ref())
+		Element::Custom(node) => visit_custom(v, node)
 	}
 }
 
diff --git a/src/visit_mut.rs b/src/visit_mut.rs
index c949b89..f23f957 100644
--- a/src/visit_mut.rs
+++ b/src/visit_mut.rs
@@ -1,4 +1,4 @@
-use crate::{Audio, Break, DynElement, Element, Emphasis, Mark, Meta, Speak, Text, Voice, mstts};
+use crate::{Audio, Break, CustomElement, Element, Emphasis, Mark, Meta, Speak, Text, Voice, mstts};
 
 pub trait VisitMut<'s> {
 	fn visit_speak_mut(&mut self, node: &'s mut Speak) {
@@ -33,8 +33,8 @@ pub trait VisitMut<'s> {
 		self::visit_mark_mut(self, node)
 	}
 
-	fn visit_dyn_mut(&mut self, node: &'s mut dyn DynElement) {
-		self::visit_dyn_mut(self, node)
+	fn visit_custom_mut(&mut self, node: &'s mut CustomElement) {
+		self::visit_custom_mut(self, node)
 	}
 
 	fn visit_mstts_element_mut(&mut self, node: &'s mut mstts::Element) {
@@ -76,7 +76,7 @@ pub fn visit_emphasis_mut<'s, V: VisitMut<'s> + ?Sized>(v: &mut V, node: &'s mut
 
 pub fn visit_mark_mut<'s, V: VisitMut<'s> + ?Sized>(_v: &mut V, _node: &'s mut Mark) {}
 
-pub fn visit_dyn_mut<'s, V: VisitMut<'s> + ?Sized>(_v: &mut V, _node: &'s mut dyn DynElement) {}
+pub fn visit_custom_mut<'s, V: VisitMut<'s> + ?Sized>(_v: &mut V, _node: &'s mut CustomElement) {}
 
 pub fn visit_mstts_element_mut<'s, V: VisitMut<'s> + ?Sized>(v: &mut V, node: &'s mut mstts::Element) {
 	match node {
@@ -100,7 +100,7 @@ pub fn visit_element_mut<'s, V: VisitMut<'s> + ?Sized>(v: &mut V, node: &'s mut
 		Element::Emphasis(node) => visit_emphasis_mut(v, node),
 		Element::Mark(node) => visit_mark_mut(v, node),
 		Element::FlavorMSTTS(node) => visit_mstts_element_mut(v, node),
-		Element::Dyn(node) => visit_dyn_mut(v, node.as_mut())
+		Element::Custom(node) => visit_custom_mut(v, node)
 	}
 }
 
diff --git a/src/xml/writer.rs b/src/xml/writer.rs
index 452114b..3d6da41 100644
--- a/src/xml/writer.rs
+++ b/src/xml/writer.rs
@@ -58,20 +58,6 @@ impl<W: Write> XmlWriter<W> {
 		}
 	}
 
-	pub(crate) fn to_dyn(&mut self) -> XmlWriter<&'_ mut dyn Write> {
-		XmlWriter {
-			write: &mut self.write as &mut dyn Write,
-			indent_level: self.indent_level,
-			pretty: self.pretty,
-			state: self.state
-		}
-	}
-
-	pub(crate) fn synchronize_state(&mut self, state: (u8, XmlState)) {
-		self.indent_level = state.0;
-		self.state = state.1;
-	}
-
 	fn pretty_break(&mut self) -> crate::Result<()> {
 		if self.pretty {
 			self.write.write_char('\n')?;
@@ -179,9 +165,3 @@ impl<W: Write> XmlWriter<W> {
 		Ok(())
 	}
 }
-
-impl XmlWriter<&mut dyn Write> {
-	pub(crate) fn into_state(self) -> (u8, XmlState) {
-		(self.indent_level, self.state)
-	}
-}