diff --git a/CHANGELOG.md b/CHANGELOG.md
index 54447a23e5..28ab54a0cd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,7 +45,7 @@ This is a relatively large release of the `futures` crate, although much of it
 is from reworking internals rather than new APIs. The banner feature of this
 release is that the `futures::{task, executor}` modules are now available in
 `no_std` contexts! A large refactoring of the task system was performed in
-PR #436 to accomodate custom memory allocation schemes and otherwise remove
+PR #436 to accommodate custom memory allocation schemes and otherwise remove
 all dependencies on `std` for the task module. More details about this change
 can be found on the PR itself.
 
diff --git a/futures-cpupool/src/lib.rs b/futures-cpupool/src/lib.rs
index 5a85b4ba0f..e8ba31c1c4 100644
--- a/futures-cpupool/src/lib.rs
+++ b/futures-cpupool/src/lib.rs
@@ -204,7 +204,7 @@ impl CpuPool {
     {
         let (tx, rx) = channel();
         let keep_running_flag = Arc::new(AtomicBool::new(false));
-        // AssertUnwindSafe is used here becuase `Send + 'static` is basically
+        // AssertUnwindSafe is used here because `Send + 'static` is basically
         // an alias for an implementation of the `UnwindSafe` trait but we can't
         // express that in the standard library right now.
         let sender = MySender {
diff --git a/src/stream/futures_unordered.rs b/src/stream/futures_unordered.rs
index 88827857ad..845c21ab94 100644
--- a/src/stream/futures_unordered.rs
+++ b/src/stream/futures_unordered.rs
@@ -28,7 +28,7 @@ use task_impl::{self, AtomicTask};
 /// Calling `poll` in this state will result in `Ok(Async::Ready(None))` to be
 /// returned. Futures are submitted to the set using `push`; however, the
 /// future will **not** be polled at this point. `FuturesUnordered` will only
-/// poll managged futures when `FuturesUnordered::poll` is called. As such, it
+/// poll managed futures when `FuturesUnordered::poll` is called. As such, it
 /// is important to call `poll` after pushing new futures.
 ///
 /// If `FuturesUnordered::poll` returns `Ok(Async::Ready(None))` this means that
@@ -90,7 +90,7 @@ pub fn futures_unordered<I>(futures: I) -> FuturesUnordered<<I::Item as IntoFutu
 // `FuturesUnordered`. When a notification is received, the node is scheduled
 // for polling by being inserted into the concurrent linked list.
 //
-// Each node uses an `AtomicUisze` to track it's state. The node state is the
+// Each node uses an `AtomicUsize` to track it's state. The node state is the
 // reference count (the number of outstanding handles to the node) as well as a
 // flag tracking if the node is currently inserted in the atomic queue. When the
 // future is notified, it will only insert itself into the linked list if it
diff --git a/src/stream/iter.rs b/src/stream/iter.rs
index 68af96bf6b..e0b9379353 100644
--- a/src/stream/iter.rs
+++ b/src/stream/iter.rs
@@ -1,4 +1,4 @@
-#![deprecated(note = "implemention moved to `iter_ok` and `iter_result`")]
+#![deprecated(note = "implementation moved to `iter_ok` and `iter_result`")]
 #![allow(deprecated)]
 
 use Poll;
diff --git a/src/sync/mpsc/queue.rs b/src/sync/mpsc/queue.rs
index 7a2334f574..9ff6bcf873 100644
--- a/src/sync/mpsc/queue.rs
+++ b/src/sync/mpsc/queue.rs
@@ -114,7 +114,7 @@ impl<T> Queue<T> {
     /// return `Option<T>`. It is possible for this queue to be in an
     /// inconsistent state where many pushes have succeeded and completely
     /// finished, but pops cannot return `Some(t)`. This inconsistent state
-    /// happens when a pusher is pre-empted at an inopportune moment.
+    /// happens when a pusher is preempted at an inopportune moment.
     ///
     /// This inconsistent state means that this queue does indeed have data, but
     /// it does not currently have access to it at this time.
diff --git a/src/sync/oneshot.rs b/src/sync/oneshot.rs
index 53658ef9d3..073372f89c 100644
--- a/src/sync/oneshot.rs
+++ b/src/sync/oneshot.rs
@@ -35,7 +35,7 @@ pub struct Sender<T> {
 #[derive(Debug)]
 struct Inner<T> {
     /// Indicates whether this oneshot is complete yet. This is filled in both
-    /// by `Sender::drop` and by `Receiver::drop`, and both sides iterperet it
+    /// by `Sender::drop` and by `Receiver::drop`, and both sides interpret it
     /// appropriately.
     ///
     /// For `Receiver`, if this is `true`, then it's guaranteed that `data` is
diff --git a/src/task_impl/std/mod.rs b/src/task_impl/std/mod.rs
index d95e3a9053..af9fee1008 100644
--- a/src/task_impl/std/mod.rs
+++ b/src/task_impl/std/mod.rs
@@ -588,7 +588,7 @@ impl fmt::Debug for UnparkEvent {
 /// A concurrent set which allows for the insertion of `usize` values.
 ///
 /// `EventSet`s are used to communicate precise information about the event(s)
-/// that trigged a task notification. See `task::with_unpark_event` for details.
+/// that triggered a task notification. See `task::with_unpark_event` for details.
 pub trait EventSet: Send + Sync + 'static {
     /// Insert the given ID into the set
     fn insert(&self, id: usize);
diff --git a/src/task_impl/std/unpark_mutex.rs b/src/task_impl/std/unpark_mutex.rs
index 13918accc5..246def2753 100644
--- a/src/task_impl/std/unpark_mutex.rs
+++ b/src/task_impl/std/unpark_mutex.rs
@@ -16,7 +16,7 @@ pub struct UnparkMutex<D> {
 }
 
 // `UnparkMutex<D>` functions in many ways like a `Mutex<D>`, except that on
-// acquisition failure, the current lockholder performs the desired work --
+// acquisition failure, the current lock holder performs the desired work --
 // re-polling.
 //
 // As such, these impls mirror those for `Mutex<D>`. In particular, a reference
diff --git a/tests/mpsc.rs b/tests/mpsc.rs
index d944e28d9b..a5f7e55e39 100644
--- a/tests/mpsc.rs
+++ b/tests/mpsc.rs
@@ -358,7 +358,7 @@ fn stress_close_receiver() {
 /// Tests that after `poll_ready` indicates capacity a channel can always send without waiting.
 #[test]
 fn stress_poll_ready() {
-    // A task which checks channel capcity using poll_ready, and pushes items onto the channel when
+    // A task which checks channel capacity using poll_ready, and pushes items onto the channel when
     // ready.
     struct SenderTask {
         sender: mpsc::Sender<u32>,
diff --git a/tests/sink.rs b/tests/sink.rs
index a5c1fa2727..6d94093457 100644
--- a/tests/sink.rs
+++ b/tests/sink.rs
@@ -232,7 +232,7 @@ impl<T> ManualFlush<T> {
 
 #[test]
 // test that the `with` sink doesn't require the underlying sink to flush,
-// but doesn't claim to be flushed until the underlyig sink is
+// but doesn't claim to be flushed until the underlying sink is
 fn with_flush_propagate() {
     let mut sink = ManualFlush::new().with(|x| -> Result<Option<i32>, ()> { Ok(x) });
     assert_eq!(sink.start_send(Some(0)).unwrap(), AsyncSink::Ready);
diff --git a/tests/slot.rs b/tests/slot.rs
index 6951d2993d..eaf10a0a02 100644
--- a/tests/slot.rs
+++ b/tests/slot.rs
@@ -171,7 +171,7 @@ fn stress_shared_bounded_hard() {
     t.join().ok().unwrap();
 }
 
-/// Stress test that receiver properly receivesl last message
+/// Stress test that receiver properly receives last message
 /// after sender dropped.
 #[test]
 fn stress_drop_sender() {
diff --git a/tests/support/local_executor.rs b/tests/support/local_executor.rs
index 9f516ff6a1..615efc1f70 100644
--- a/tests/support/local_executor.rs
+++ b/tests/support/local_executor.rs
@@ -95,7 +95,7 @@ impl Core {
     /// "Turns" this event loop one tick.
     ///
     /// This'll block the current thread until something happens, and once an
-    /// event happens this will acto on that event.
+    /// event happens this will act on that event.
     ///
     /// # Return value
     ///