diff --git a/src/buf/buf.rs b/src/buf/buf.rs
index c064b517d9531ace0c1b147cb897cd9dddca5747..bd468d9dda42296d1b496ed0b79027d01794de6f 100644
--- a/src/buf/buf.rs
+++ b/src/buf/buf.rs
@@ -16,7 +16,7 @@ macro_rules! buf_get_impl {
             }
         };
         if let Some(ret) = ret {
-             // if the direct convertion was possible, advance and return
+             // if the direct conversion was possible, advance and return
             $this.advance($size);
             return ret;
         } else {
@@ -792,7 +792,7 @@ pub trait Buf {
     /// Transforms a `Buf` into a concrete buffer.
     ///
     /// `collect()` can operate on any value that implements `Buf`, and turn it
-    /// into the relevent concrete buffer type.
+    /// into the relevant concrete buffer type.
     ///
     /// # Examples
     ///
@@ -997,6 +997,6 @@ impl Buf for Option<[u8; 1]> {
     }
 }
 
-// The existance of this function makes the compiler catch if the Buf
+// The existence of this function makes the compiler catch if the Buf
 // trait is "object-safe" or not.
 fn _assert_trait_object(_b: &dyn Buf) {}
diff --git a/src/buf/buf_mut.rs b/src/buf/buf_mut.rs
index 63aece8069de80952b54dc0bed157eef45c96a25..e7935d9f1b32985d1ec07283007a45820603c6c9 100644
--- a/src/buf/buf_mut.rs
+++ b/src/buf/buf_mut.rs
@@ -942,7 +942,7 @@ pub trait BufMut {
     ///     // Adapt reference to `std::io::Write`.
     ///     let mut writer = reference.writer();
     ///
-    ///     // Use the buffer as a writter
+    ///     // Use the buffer as a writer
     ///     io::Write::write(&mut writer, &b"hello world"[..]).unwrap();
     /// } // drop our &mut reference so that we can use `buf` again
     ///
@@ -1069,6 +1069,6 @@ impl BufMut for Vec<u8> {
     }
 }
 
-// The existance of this function makes the compiler catch if the BufMut
+// The existence of this function makes the compiler catch if the BufMut
 // trait is "object-safe" or not.
 fn _assert_trait_object(_b: &dyn BufMut) {}
diff --git a/src/buf/chain.rs b/src/buf/chain.rs
index 4d46a5d0abd2e0dcb4afe7ede2e0805c3245b7de..b6f1c767029e60454b3d2d2a41a950b77b8ee0fb 100644
--- a/src/buf/chain.rs
+++ b/src/buf/chain.rs
@@ -5,7 +5,7 @@ use std::io::{IoSlice, IoSliceMut};
 /// A `Chain` sequences two buffers.
 ///
 /// `Chain` is an adapter that links two underlying buffers and provides a
-/// continous view across both buffers. It is able to sequence either immutable
+/// continuous view across both buffers. It is able to sequence either immutable
 /// buffers ([`Buf`] values) or mutable buffers ([`BufMut`] values).
 ///
 /// This struct is generally created by calling [`Buf::chain`]. Please see that
diff --git a/src/bytes.rs b/src/bytes.rs
index 0f03a3485f6ea322a561770b3ef49081befcba97..331237182ef55b31c000438898d2076d6da92e3f 100644
--- a/src/bytes.rs
+++ b/src/bytes.rs
@@ -722,7 +722,7 @@ impl Bytes {
     ///
     /// This will only succeed if there are no other outstanding references to
     /// the underlying chunk of memory. `Bytes` handles that contain inlined
-    /// bytes will always be convertable to `BytesMut`.
+    /// bytes will always be convertible to `BytesMut`.
     ///
     /// # Examples
     ///
@@ -2505,7 +2505,7 @@ impl Inner {
         // bits, so even without any explicit atomic operations, reading the
         // flag will be correct.
         //
-        // This is undefind behavior due to a data race, but experimental
+        // This is undefined behavior due to a data race, but experimental
         // evidence shows that it works in practice (discussion:
         // https://internals.rust-lang.org/t/bit-wise-reasoning-for-atomic-accesses/8853).
         //
diff --git a/src/lib.rs b/src/lib.rs
index d9a347cf1d319e807e24158eb35499edc587de63..9dd149205c07b60dce5e136d6af9781556583a77 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,7 +9,7 @@
 //!
 //! # `Bytes`
 //!
-//! `Bytes` is an efficient container for storing and operating on continguous
+//! `Bytes` is an efficient container for storing and operating on contiguous
 //! slices of memory. It is intended for use primarily in networking code, but
 //! could have applications elsewhere as well.
 //!
diff --git a/tests/test_buf_mut.rs b/tests/test_buf_mut.rs
index acc6af6f4cd72e8ed6cb741cc52fb99dc9e68dc8..b0af550328a4d942ec638755ce21ad2f65b7d43c 100644
--- a/tests/test_buf_mut.rs
+++ b/tests/test_buf_mut.rs
@@ -65,7 +65,7 @@ fn test_clone() {
     buf.write_str("this is a test").unwrap();
     let buf2 = buf.clone();
 
-    buf.write_str(" of our emergecy broadcast system").unwrap();
+    buf.write_str(" of our emergency broadcast system").unwrap();
     assert!(buf != buf2);
 }