diff --git a/Cargo.toml b/Cargo.toml
index 163e8266..66d81fb0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
-name = "fast-xml"
+name = "quick-xml"
 version = "0.23.0"
 description = "High performance xml reader and writer"
 edition = "2018"
 
-documentation = "https://docs.rs/fast-xml"
-repository = "/~https://github.com/Mingun/fast-xml"
+documentation = "https://docs.rs/quick-xml"
+repository = "/~https://github.com/tafia/quick-xml"
 
 keywords = ["xml", "serde", "parser", "writer", "html"]
 categories = ["encoding", "parsing", "parser-implementations"]
diff --git a/README.md b/README.md
index c92812ef..0c7099a3 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
-# fast-xml -- successor of [quick-xml]
+# quick-xml
 
-![status](/~https://github.com/Mingun/fast-xml/actions/workflows/rust.yml/badge.svg)
-[![Crate](https://img.shields.io/crates/v/fast-xml.svg)](https://crates.io/crates/fast-xml)
+![status](/~https://github.com/tafia/quick-xml/actions/workflows/rust.yml/badge.svg)
+[![Crate](https://img.shields.io/crates/v/quick-xml.svg)](https://crates.io/crates/quick-xml)
 
 High performance xml pull reader/writer.
 
@@ -10,27 +10,17 @@ The reader:
 - is easy on memory allocation (the API provides a way to reuse buffers)
 - support various encoding (with `encoding` feature), namespaces resolution, special characters.
 
-[docs.rs](https://docs.rs/fast-xml)
+[docs.rs](https://docs.rs/quick-xml)
 
 Syntax is inspired by [xml-rs](/~https://github.com/netvl/xml-rs).
 
-## Migration from [quick-xml]
-
-If you using quick-xml 0.22.0 or 0.23.0-alpha3, you can just replace `quick-xml`
-in your `Cargo.toml` with `fast-xml`. Replace each occurrence of `quick_xml`
-crate name to `fast_xml` in your code base.
-
-That two releases of fast-xml was specifically made for migration and contains
-the same code as original quick-xml, except updated cargo metadata and extern
-crate names in tests, benches and examples.
-
 ## Example
 
 ### Reader
 
 ```rust
-use fast_xml::Reader;
-use fast_xml::events::Event;
+use quick_xml::Reader;
+use quick_xml::events::Event;
 
 let xml = r#"<tag1 att1 = "test">
                 <tag2><!--Test comment-->Test</tag2>
@@ -74,9 +64,9 @@ loop {
 ### Writer
 
 ```rust
-use fast_xml::Writer;
-use fast_xml::Reader;
-use fast_xml::events::{Event, BytesEnd, BytesStart};
+use quick_xml::Writer;
+use quick_xml::Reader;
+use quick_xml::events::{Event, BytesEnd, BytesStart};
 use std::io::Cursor;
 use std::iter;
 
@@ -120,7 +110,7 @@ assert_eq!(result, expected.as_bytes());
 
 ## Serde
 
-When using the `serialize` feature, fast-xml can be used with serde's `Serialize`/`Deserialize` traits.
+When using the `serialize` feature, quick-xml can be used with serde's `Serialize`/`Deserialize` traits.
 
 Here is an example deserializing crates.io source:
 
@@ -128,9 +118,9 @@ Here is an example deserializing crates.io source:
 // Cargo.toml
 // [dependencies]
 // serde = { version = "1.0", features = [ "derive" ] }
-// fast-xml = { version = "0.22", features = [ "serialize" ] }
+// quick-xml = { version = "0.22", features = [ "serialize" ] }
 use serde::Deserialize;
-use fast_xml::de::{from_str, DeError};
+use quick_xml::de::{from_str, DeError};
 
 #[derive(Debug, Deserialize, PartialEq)]
 struct Link {
@@ -221,7 +211,7 @@ fn crates_io() -> Result<Html, DeError> {
 ### Credits
 
 This has largely been inspired by [serde-xml-rs](/~https://github.com/RReverser/serde-xml-rs).
-fast-xml follows its convention for deserialization, including the
+quick-xml follows its convention for deserialization, including the
 [`$value`](/~https://github.com/RReverser/serde-xml-rs#parsing-the-value-of-a-tag) special name.
 
 Original [quick-xml] was developed by @tafia and abandoned around end of 2021.
@@ -282,7 +272,7 @@ Note that despite not focusing on performance (there are several unnecessary cop
 
 Benchmarking is hard and the results depend on your input file and your machine.
 
-Here on my particular file, fast-xml is around **50 times faster** than [xml-rs](https://crates.io/crates/xml-rs) crate.
+Here on my particular file, quick-xml is around **50 times faster** than [xml-rs](https://crates.io/crates/xml-rs) crate.
 _(measurements was done while this crate named quick-xml)_
 
 ```
diff --git a/benches/bench.rs b/benches/bench.rs
index fdb4fc80..389af6f4 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -1,7 +1,7 @@
 use criterion::{self, criterion_group, criterion_main, Criterion};
-use fast_xml::events::Event;
-use fast_xml::Reader;
 use pretty_assertions::assert_eq;
+use quick_xml::events::Event;
+use quick_xml::Reader;
 
 static SAMPLE: &[u8] = include_bytes!("../tests/sample_rss.xml");
 static PLAYERS: &[u8] = include_bytes!("../tests/players.xml");
diff --git a/compare/Cargo.toml b/compare/Cargo.toml
index 95deaf79..50979fef 100644
--- a/compare/Cargo.toml
+++ b/compare/Cargo.toml
@@ -8,7 +8,7 @@ edition = "2018"
 
 [dev-dependencies]
 criterion = "0.3"
-fast-xml = { path = "..", features = ["serialize"] }
+quick-xml = { path = "..", features = ["serialize"] }
 xml-rs = "0.8"
 serde-xml-rs = "0.5"
 serde = { version = "1.0", features = [ "derive" ] }
diff --git a/compare/benches/bench.rs b/compare/benches/bench.rs
index f85827d6..476e4f45 100644
--- a/compare/benches/bench.rs
+++ b/compare/benches/bench.rs
@@ -1,6 +1,6 @@
 use criterion::{self, criterion_group, criterion_main, Criterion};
 use pretty_assertions::assert_eq;
-use fast_xml::{self, events::Event, Reader};
+use quick_xml::{self, events::Event, Reader};
 use serde::Deserialize;
 use serde_xml_rs;
 use xml::reader::{EventReader, XmlEvent};
@@ -11,7 +11,7 @@ static SOURCE: &str = include_str!("../../tests/sample_rss.xml");
 fn low_level_comparison(c: &mut Criterion) {
     let mut group = c.benchmark_group("low-level API");
 
-    group.bench_function("fast_xml", |b| {
+    group.bench_function("quick_xml", |b| {
         b.iter(|| {
             let mut r = Reader::from_reader(SOURCE.as_bytes());
             r.check_end_names(false).check_comments(false);
@@ -77,9 +77,9 @@ fn serde_comparison(c: &mut Criterion) {
         typ: String,
     }
 
-    group.bench_function("fast_xml", |b| {
+    group.bench_function("quick_xml", |b| {
         b.iter(|| {
-            let rss: Rss = fast_xml::de::from_str(SOURCE).unwrap();
+            let rss: Rss = quick_xml::de::from_str(SOURCE).unwrap();
             assert_eq!(rss.channel.items.len(), 99);
         })
     });
diff --git a/examples/custom_entities.rs b/examples/custom_entities.rs
index 6d3327bc..ddd0b577 100644
--- a/examples/custom_entities.rs
+++ b/examples/custom_entities.rs
@@ -7,8 +7,8 @@
 //! * the regex in this example is simple but brittle;
 //! * it does not support the use of entities in entity declaration.
 
-use fast_xml::events::Event;
-use fast_xml::Reader;
+use quick_xml::events::Event;
+use quick_xml::Reader;
 use regex::bytes::Regex;
 use std::collections::HashMap;
 
diff --git a/examples/issue68.rs b/examples/issue68.rs
index b4241457..f5c62e9e 100644
--- a/examples/issue68.rs
+++ b/examples/issue68.rs
@@ -1,7 +1,7 @@
 #![allow(unused)]
 
-use fast_xml::events::Event;
-use fast_xml::Reader;
+use quick_xml::events::Event;
+use quick_xml::Reader;
 use std::io::Read;
 
 struct Resource {
diff --git a/examples/nested_readers.rs b/examples/nested_readers.rs
index dedea4bb..95ac5f14 100644
--- a/examples/nested_readers.rs
+++ b/examples/nested_readers.rs
@@ -1,6 +1,6 @@
-use fast_xml::events::Event;
-use fast_xml::Reader;
 use pretty_assertions::assert_eq;
+use quick_xml::events::Event;
+use quick_xml::Reader;
 
 // a structure to capture the rows we've extracted
 // from a ECMA-376 table in document.xml
@@ -12,7 +12,7 @@ struct TableStat {
 // demonstrate how to nest readers
 // This is useful for when you need to traverse
 // a few levels of a document to extract things.
-fn main() -> Result<(), fast_xml::Error> {
+fn main() -> Result<(), quick_xml::Error> {
     let mut buf = Vec::new();
     // buffer for nested reader
     let mut skip_buf = Vec::new();
diff --git a/examples/read_texts.rs b/examples/read_texts.rs
index 173815b8..11535fb8 100644
--- a/examples/read_texts.rs
+++ b/examples/read_texts.rs
@@ -1,6 +1,6 @@
 fn main() {
-    use fast_xml::events::Event;
-    use fast_xml::Reader;
+    use quick_xml::events::Event;
+    use quick_xml::Reader;
 
     let xml = "<tag1>text1</tag1><tag1>text2</tag1>\
                <tag1>text3</tag1><tag1><tag2>text4</tag2></tag1>";
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 570eb7c6..b24211f8 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -1,6 +1,6 @@
 
 [package]
-name = "fast-xml-fuzz"
+name = "quick-xml-fuzz"
 version = "0.0.1"
 authors = ["Automatically generated"]
 publish = false
@@ -8,7 +8,7 @@ publish = false
 [package.metadata]
 cargo-fuzz = true
 
-[dependencies.fast-xml]
+[dependencies.quick-xml]
 path = ".."
 [dependencies.libfuzzer-sys]
 git = "/~https://github.com/rust-fuzz/libfuzzer-sys.git"
diff --git a/fuzz/fuzz_targets/fuzz_target_1.rs b/fuzz/fuzz_targets/fuzz_target_1.rs
index f47f73c7..c6265753 100644
--- a/fuzz/fuzz_targets/fuzz_target_1.rs
+++ b/fuzz/fuzz_targets/fuzz_target_1.rs
@@ -1,8 +1,8 @@
 #![no_main]
 #[macro_use] extern crate libfuzzer_sys;
 
-use fast_xml::Reader;
-use fast_xml::events::Event;
+use quick_xml::Reader;
+use quick_xml::events::Event;
 use std::io::Cursor;
 
 fuzz_target!(|data: &[u8]| {
diff --git a/src/de/mod.rs b/src/de/mod.rs
index 1aff658e..6f085b04 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -8,10 +8,10 @@
 //! // Cargo.toml
 //! // [dependencies]
 //! // serde = { version = "1.0", features = [ "derive" ] }
-//! // fast-xml = { version = "0.22", features = [ "serialize" ] }
+//! // quick-xml = { version = "0.22", features = [ "serialize" ] }
 //! # use pretty_assertions::assert_eq;
 //! use serde::Deserialize;
-//! use fast_xml::de::{from_str, DeError};
+//! use quick_xml::de::{from_str, DeError};
 //!
 //! #[derive(Debug, Deserialize, PartialEq)]
 //! struct Link {
diff --git a/src/events/attributes.rs b/src/events/attributes.rs
index 77842c3e..b9780a8f 100644
--- a/src/events/attributes.rs
+++ b/src/events/attributes.rs
@@ -244,7 +244,7 @@ impl<'a> From<(&'a [u8], &'a [u8])> for Attribute<'a> {
     ///
     /// ```
     /// # use pretty_assertions::assert_eq;
-    /// use fast_xml::events::attributes::Attribute;
+    /// use quick_xml::events::attributes::Attribute;
     ///
     /// let features = Attribute::from(("features".as_bytes(), "Bells &amp; whistles".as_bytes()));
     /// assert_eq!(features.value, "Bells &amp; whistles".as_bytes());
@@ -265,7 +265,7 @@ impl<'a> From<(&'a str, &'a str)> for Attribute<'a> {
     ///
     /// ```
     /// # use pretty_assertions::assert_eq;
-    /// use fast_xml::events::attributes::Attribute;
+    /// use quick_xml::events::attributes::Attribute;
     ///
     /// let features = Attribute::from(("features", "Bells & whistles"));
     /// assert_eq!(features.value, "Bells &amp; whistles".as_bytes());
diff --git a/src/events/mod.rs b/src/events/mod.rs
index 86662413..0098dab3 100644
--- a/src/events/mod.rs
+++ b/src/events/mod.rs
@@ -131,8 +131,8 @@ impl<'a> BytesStart<'a> {
     /// # Example
     ///
     /// ```rust
-    /// # use fast_xml::{Error, Writer};
-    /// use fast_xml::events::{BytesStart, Event};
+    /// # use quick_xml::{Error, Writer};
+    /// use quick_xml::events::{BytesStart, Event};
     ///
     /// struct SomeStruct<'a> {
     ///     attrs: BytesStart<'a>,
@@ -406,8 +406,8 @@ impl<'a> BytesDecl<'a> {
     ///
     /// ```
     /// use std::borrow::Cow;
-    /// use fast_xml::Error;
-    /// use fast_xml::events::{BytesDecl, BytesStart};
+    /// use quick_xml::Error;
+    /// use quick_xml::events::{BytesDecl, BytesStart};
     ///
     /// // <?xml version='1.1'?>
     /// let decl = BytesDecl::from_start(BytesStart::borrowed(b" version='1.1'", 0));
@@ -474,8 +474,8 @@ impl<'a> BytesDecl<'a> {
     ///
     /// ```
     /// use std::borrow::Cow;
-    /// use fast_xml::Error;
-    /// use fast_xml::events::{BytesDecl, BytesStart};
+    /// use quick_xml::Error;
+    /// use quick_xml::events::{BytesDecl, BytesStart};
     ///
     /// // <?xml version='1.1'?>
     /// let decl = BytesDecl::from_start(BytesStart::borrowed(b" version='1.1'", 0));
@@ -516,8 +516,8 @@ impl<'a> BytesDecl<'a> {
     ///
     /// ```
     /// use std::borrow::Cow;
-    /// use fast_xml::Error;
-    /// use fast_xml::events::{BytesDecl, BytesStart};
+    /// use quick_xml::Error;
+    /// use quick_xml::events::{BytesDecl, BytesStart};
     ///
     /// // <?xml version='1.1'?>
     /// let decl = BytesDecl::from_start(BytesStart::borrowed(b" version='1.1'", 0));
diff --git a/src/lib.rs b/src/lib.rs
index aa08299b..23e45d43 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,7 +2,7 @@
 //!
 //! ## Description
 //!
-//! fast-xml contains two modes of operation:
+//! quick-xml contains two modes of operation:
 //!
 //! A streaming API based on the [StAX] model. This is suited for larger XML documents which
 //! cannot completely read into memory at once.
@@ -17,7 +17,7 @@
 //! Especially for nested XML elements, the user must keep track _where_ (how deep) in the XML document
 //! the current event is located. This is needed as the
 //!
-//! Furthermore, fast-xml also contains optional [Serde] support to directly serialize and deserialize from
+//! Furthermore, quick-xml also contains optional [Serde] support to directly serialize and deserialize from
 //! structs, without having to deal with the XML events.
 //!
 //! ## Examples
@@ -25,8 +25,8 @@
 //! ### Reader
 //!
 //! ```rust
-//! use fast_xml::Reader;
-//! use fast_xml::events::Event;
+//! use quick_xml::Reader;
+//! use quick_xml::events::Event;
 //!
 //! let xml = r#"<tag1 att1 = "test">
 //!                 <tag2><!--Test comment-->Test</tag2>
@@ -74,9 +74,9 @@
 //!
 //! ```rust
 //! # use pretty_assertions::assert_eq;
-//! use fast_xml::Writer;
-//! use fast_xml::events::{Event, BytesEnd, BytesStart};
-//! use fast_xml::Reader;
+//! use quick_xml::Writer;
+//! use quick_xml::events::{Event, BytesEnd, BytesStart};
+//! use quick_xml::Reader;
 //! use std::io::Cursor;
 //! use std::iter;
 //!
@@ -121,7 +121,7 @@
 //!
 //! # Features
 //!
-//! fast-xml supports 2 additional features, non activated by default:
+//! quick-xml supports 2 additional features, non activated by default:
 //! - `encoding`: support non utf8 XMLs
 //! - `serialize`: support serde `Serialize`/`Deserialize`
 //!
diff --git a/src/reader.rs b/src/reader.rs
index e9c2a208..17b4f344 100644
--- a/src/reader.rs
+++ b/src/reader.rs
@@ -30,8 +30,8 @@ enum TagState {
 /// # Examples
 ///
 /// ```
-/// use fast_xml::Reader;
-/// use fast_xml::events::Event;
+/// use quick_xml::Reader;
+/// use quick_xml::events::Event;
 ///
 /// let xml = r#"<tag1 att1 = "test">
 ///                 <tag2><!--Test comment-->Test</tag2>
@@ -478,8 +478,8 @@ impl<R: BufRead> Reader<R> {
     /// # Examples
     ///
     /// ```
-    /// use fast_xml::Reader;
-    /// use fast_xml::events::Event;
+    /// use quick_xml::Reader;
+    /// use quick_xml::events::Event;
     ///
     /// let xml = r#"<tag1 att1 = "test">
     ///                 <tag2><!--Test comment-->Test</tag2>
@@ -566,8 +566,8 @@ impl<R: BufRead> Reader<R> {
     ///
     /// ```
     /// use std::str::from_utf8;
-    /// use fast_xml::Reader;
-    /// use fast_xml::events::Event;
+    /// use quick_xml::Reader;
+    /// use quick_xml::events::Event;
     ///
     /// let xml = r#"<x:tag1 xmlns:x="www.xxxx" xmlns:y="www.yyyy" att1 = "test">
     ///                 <y:tag2><!--Test comment-->Test</y:tag2>
@@ -781,8 +781,8 @@ impl<R: BufRead> Reader<R> {
     ///
     /// ```
     /// # use pretty_assertions::assert_eq;
-    /// use fast_xml::Reader;
-    /// use fast_xml::events::Event;
+    /// use quick_xml::Reader;
+    /// use quick_xml::events::Event;
     ///
     /// let mut xml = Reader::from_reader(b"
     ///     <a>&lt;b&gt;</a>
@@ -824,8 +824,8 @@ impl<R: BufRead> Reader<R> {
     /// ```
     /// # use pretty_assertions::assert_eq;
     /// use std::{str, io::Cursor};
-    /// use fast_xml::Reader;
-    /// use fast_xml::events::Event;
+    /// use quick_xml::Reader;
+    /// use quick_xml::events::Event;
     ///
     /// let xml = r#"<tag1 att1 = "test">
     ///                 <tag2><!--Test comment-->Test</tag2>
diff --git a/src/se/mod.rs b/src/se/mod.rs
index b6e1e9f6..92a97c40 100644
--- a/src/se/mod.rs
+++ b/src/se/mod.rs
@@ -53,8 +53,8 @@ impl<'r, W: Write> Serializer<'r, W> {
     /// ```edition2018
     /// # use pretty_assertions::assert_eq;
     /// # use serde::Serialize;
-    /// use fast_xml::Writer;
-    /// # use fast_xml::se::Serializer;
+    /// use quick_xml::Writer;
+    /// # use quick_xml::se::Serializer;
     ///
     /// let mut buffer = Vec::new();
     /// let mut writer = Writer::new_with_indent(&mut buffer, b' ', 2);
@@ -70,8 +70,8 @@ impl<'r, W: Write> Serializer<'r, W> {
     /// ```edition2018
     /// # use pretty_assertions::assert_eq;
     /// # use serde::Serialize;
-    /// use fast_xml::Writer;
-    /// use fast_xml::se::Serializer;
+    /// use quick_xml::Writer;
+    /// use quick_xml::se::Serializer;
     ///
     /// #[derive(Debug, PartialEq, Serialize)]
     /// struct Struct {
diff --git a/src/writer.rs b/src/writer.rs
index f9edf865..0ccea960 100644
--- a/src/writer.rs
+++ b/src/writer.rs
@@ -12,8 +12,8 @@ use std::io::Write;
 ///
 /// ```rust
 /// # use pretty_assertions::assert_eq;
-/// use fast_xml::{Reader, Writer};
-/// use fast_xml::events::{Event, BytesEnd, BytesStart};
+/// use quick_xml::{Reader, Writer};
+/// use quick_xml::events::{Event, BytesEnd, BytesStart};
 /// use std::io::Cursor;
 ///
 /// let xml = r#"<this_tag k1="v1" k2="v2"><child>text</child></this_tag>"#;
@@ -175,10 +175,10 @@ impl<W: Write> Writer<W> {
     /// # Example
     ///
     /// ```rust
-    /// # use fast_xml::Result;
+    /// # use quick_xml::Result;
     /// # fn main() -> Result<()> {
-    /// use fast_xml::{Error, Writer};
-    /// use fast_xml::events::{BytesStart, BytesText, Event};
+    /// use quick_xml::{Error, Writer};
+    /// use quick_xml::events::{BytesStart, BytesText, Event};
     /// use std::io::Cursor;
     ///
     /// let mut writer = Writer::new(Cursor::new(Vec::new()));
diff --git a/tests/namespaces.rs b/tests/namespaces.rs
index 4668d069..76548e27 100644
--- a/tests/namespaces.rs
+++ b/tests/namespaces.rs
@@ -1,7 +1,7 @@
-use fast_xml::events::attributes::Attribute;
-use fast_xml::events::Event::*;
-use fast_xml::Reader;
 use pretty_assertions::assert_eq;
+use quick_xml::events::attributes::Attribute;
+use quick_xml::events::Event::*;
+use quick_xml::Reader;
 use std::borrow::Cow;
 
 #[test]
diff --git a/tests/serde-de.rs b/tests/serde-de.rs
index 3dd5a7f2..62f30af6 100644
--- a/tests/serde-de.rs
+++ b/tests/serde-de.rs
@@ -1,6 +1,6 @@
-use fast_xml::de::Deserializer;
-use fast_xml::utils::ByteBuf;
-use fast_xml::DeError;
+use quick_xml::de::Deserializer;
+use quick_xml::utils::ByteBuf;
+use quick_xml::DeError;
 
 use pretty_assertions::assert_eq;
 
@@ -541,7 +541,7 @@ macro_rules! maplike_errors {
 
         mod mismatched_end {
             use super::*;
-            use fast_xml::Error::EndEventMismatch;
+            use quick_xml::Error::EndEventMismatch;
 
             #[test]
             fn attributes() {
diff --git a/tests/serde-migrated.rs b/tests/serde-migrated.rs
index 298921ac..cd07fcb2 100644
--- a/tests/serde-migrated.rs
+++ b/tests/serde-migrated.rs
@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use fast_xml::de::from_str;
+use quick_xml::de::from_str;
 use serde::{de, ser};
 use serde::{Deserialize, Serialize};
 
@@ -140,7 +140,7 @@ fn test_doctype() {
     ]);
 }
 
-// pass in fast-xml because there is no proper doctype support
+// pass in quick-xml because there is no proper doctype support
 //
 //
 // #[test]
diff --git a/tests/serde_attrs.rs b/tests/serde_attrs.rs
index e51fb83e..416cb12c 100644
--- a/tests/serde_attrs.rs
+++ b/tests/serde_attrs.rs
@@ -1,4 +1,4 @@
-use fast_xml::se::to_string;
+use quick_xml::se::to_string;
 use regex::Regex;
 use serde::Serialize;
 use std::borrow::Cow;
@@ -50,7 +50,7 @@ fn test_nested() {
         number: "3-1".to_string(),
         adviser: t,
     };
-    let xml = fast_xml::se::to_string(&doc).unwrap();
+    let xml = quick_xml::se::to_string(&doc).unwrap();
 
     let str = r#"<classroom number="3-1">
                    <students>
diff --git a/tests/serde_roundtrip.rs b/tests/serde_roundtrip.rs
index 25fad16e..6cf20948 100644
--- a/tests/serde_roundtrip.rs
+++ b/tests/serde_roundtrip.rs
@@ -1,4 +1,4 @@
-use fast_xml::{de::from_str, se::to_string};
+use quick_xml::{de::from_str, se::to_string};
 use serde::{Deserialize, Serialize};
 
 use pretty_assertions::assert_eq;
@@ -98,7 +98,7 @@ fn no_contiguous_fields() {
 </Xml>
 "#;
 
-    let xml: Xml = ::fast_xml::de::from_str(source).unwrap();
+    let xml: Xml = ::quick_xml::de::from_str(source).unwrap();
     assert_eq!(
         xml,
         Xml {
@@ -134,7 +134,7 @@ fn test_parse_unflatten_field() {
         field: "Foo".to_string(),
     };
 
-    let parsed: Unflatten = ::fast_xml::de::from_str(source).unwrap();
+    let parsed: Unflatten = ::quick_xml::de::from_str(source).unwrap();
     assert_eq!(&parsed, &expected);
 
     let stringified = to_string(&parsed).unwrap();
diff --git a/tests/test.rs b/tests/test.rs
index 327d5771..36d28272 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,4 +1,4 @@
-use fast_xml::{events::attributes::Attribute, events::Event::*, Error, Reader};
+use quick_xml::{events::attributes::Attribute, events::Event::*, Error, Reader};
 use std::{borrow::Cow, io::Cursor};
 
 #[cfg(feature = "serialize")]
@@ -121,7 +121,7 @@ fn fuzz_53() {
     let mut buf = vec![];
     loop {
         match reader.read_event(&mut buf) {
-            Ok(fast_xml::events::Event::Eof) | Err(..) => break,
+            Ok(quick_xml::events::Event::Eof) | Err(..) => break,
             _ => buf.clear(),
         }
     }
@@ -137,7 +137,7 @@ fn test_issue94() {
     let mut buf = vec![];
     loop {
         match reader.read_event(&mut buf) {
-            Ok(fast_xml::events::Event::Eof) | Err(..) => break,
+            Ok(quick_xml::events::Event::Eof) | Err(..) => break,
             _ => buf.clear(),
         }
         buf.clear();
@@ -260,7 +260,7 @@ fn line_score() {
         inning: String,
     }
 
-    let res: LineScoreData = fast_xml::de::from_str(include_str!("linescore.xml")).unwrap();
+    let res: LineScoreData = quick_xml::de::from_str(include_str!("linescore.xml")).unwrap();
 
     let expected = LineScoreData {
         game_pk: 239575,
@@ -372,7 +372,7 @@ fn players() {
         id: u32,
     }
 
-    let res: Game = fast_xml::de::from_str(include_str!("players.xml")).unwrap();
+    let res: Game = quick_xml::de::from_str(include_str!("players.xml")).unwrap();
 
     let expected = Game {
         teams: vec![
@@ -944,8 +944,8 @@ fn test_issue299() -> Result<(), Error> {
 
 #[cfg(feature = "serialize")]
 #[test]
-fn test_issue305_unflatten_namespace() -> Result<(), fast_xml::DeError> {
-    use fast_xml::de::from_str;
+fn test_issue305_unflatten_namespace() -> Result<(), quick_xml::DeError> {
+    use quick_xml::de::from_str;
 
     #[derive(Deserialize, Debug, PartialEq)]
     struct NamespaceBug {
@@ -973,8 +973,8 @@ fn test_issue305_unflatten_namespace() -> Result<(), fast_xml::DeError> {
 
 #[cfg(feature = "serialize")]
 #[test]
-fn test_issue305_unflatten_nesting() -> Result<(), fast_xml::DeError> {
-    use fast_xml::de::from_str;
+fn test_issue305_unflatten_nesting() -> Result<(), quick_xml::DeError> {
+    use quick_xml::de::from_str;
 
     #[derive(Deserialize, Debug, PartialEq)]
     struct InnerNestingBug {}
diff --git a/tests/unit_tests.rs b/tests/unit_tests.rs
index 99c7e057..2278da59 100644
--- a/tests/unit_tests.rs
+++ b/tests/unit_tests.rs
@@ -2,9 +2,9 @@ use std::borrow::Cow;
 use std::io::Cursor;
 use std::str::from_utf8;
 
-use fast_xml::events::attributes::{AttrError, Attribute};
-use fast_xml::events::{BytesDecl, BytesEnd, BytesStart, BytesText, Event};
-use fast_xml::{events::Event::*, Reader, Result, Writer};
+use quick_xml::events::attributes::{AttrError, Attribute};
+use quick_xml::events::{BytesDecl, BytesEnd, BytesStart, BytesText, Event};
+use quick_xml::{events::Event::*, Reader, Result, Writer};
 
 use pretty_assertions::assert_eq;
 
diff --git a/tests/xmlrs_reader_tests.rs b/tests/xmlrs_reader_tests.rs
index 801782f7..175de081 100644
--- a/tests/xmlrs_reader_tests.rs
+++ b/tests/xmlrs_reader_tests.rs
@@ -1,5 +1,5 @@
-use fast_xml::events::{BytesStart, Event};
-use fast_xml::{Reader, Result};
+use quick_xml::events::{BytesStart, Event};
+use quick_xml::{Reader, Result};
 use std::borrow::Cow;
 use std::str::from_utf8;