diff --git a/Cargo.toml b/Cargo.toml
index 6f84275..89de831 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,15 +21,15 @@ edition = "2018"
 blake2-rfc = "0.2.18"
 byteorder = "1.3.4"
 ed25519-dalek = "1.0.0-pre.3"
-failure = "0.1.6"
+anyhow = "1.0.26"
 flat-tree = "5.0.0"
 lazy_static = "1.4.0"
 memory-pager = "0.9.0"
 merkle-tree-stream =  "0.12.0"
 pretty-hash = "0.4.1"
 rand = "0.7.3"
-random-access-disk = "~1.0.0"
-random-access-memory = "~1.1.0"
+random-access-disk = "1.1.0"
+random-access-memory = "1.2.0"
 random-access-storage = "3.0.0"
 sha2 = "0.8.1"
 sleep-parser = "0.8.0"
diff --git a/benches/bench.rs b/benches/bench.rs
index 4b87916..74d396b 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -1,15 +1,11 @@
 #![feature(test)]
-
-extern crate failure;
-extern crate hypercore;
-extern crate random_access_memory as ram;
-
 extern crate test;
 
-use self::test::Bencher;
-use failure::Error;
+use anyhow::Error;
+use random_access_memory::RandomAccessMemory;
+use test::Bencher;
+
 use hypercore::{Feed, Storage, Store};
-use ram::RandomAccessMemory;
 
 fn create_feed(page_size: usize) -> Result<Feed<RandomAccessMemory>, Error> {
     let create = |_store: Store| Ok(RandomAccessMemory::new(page_size));
diff --git a/examples/async.rs b/examples/async.rs
index 9fa767d..0b854fe 100644
--- a/examples/async.rs
+++ b/examples/async.rs
@@ -1,30 +1,29 @@
-use async_std::task;
-use failure::Error;
-use hypercore::Feed;
-use random_access_storage::RandomAccess;
-use std::fmt::Debug;
-
-async fn append<T>(feed: &mut Feed<T>, content: &[u8])
-where
-    T: RandomAccess<Error = Error> + Debug,
-{
-    feed.append(content).unwrap();
-}
-
-async fn print<T>(feed: &mut Feed<T>)
-where
-    T: RandomAccess<Error = Error> + Debug,
-{
-    println!("{:?}", feed.get(0));
-    println!("{:?}", feed.get(1));
-}
-
-fn main() {
-    task::block_on(task::spawn(async {
-        let mut feed = Feed::default();
-
-        append(&mut feed, b"hello").await;
-        append(&mut feed, b"world").await;
-        print(&mut feed).await;
-    }));
-}
+use async_std::task;
+use hypercore::Feed;
+use random_access_storage::RandomAccess;
+use std::fmt::Debug;
+
+async fn append<T>(feed: &mut Feed<T>, content: &[u8])
+where
+    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug,
+{
+    feed.append(content).unwrap();
+}
+
+async fn print<T>(feed: &mut Feed<T>)
+where
+    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug,
+{
+    println!("{:?}", feed.get(0));
+    println!("{:?}", feed.get(1));
+}
+
+fn main() {
+    task::block_on(task::spawn(async {
+        let mut feed = Feed::default();
+
+        append(&mut feed, b"hello").await;
+        append(&mut feed, b"world").await;
+        print(&mut feed).await;
+    }));
+}
diff --git a/examples/iter.rs b/examples/iter.rs
index d3353c5..f31e0f6 100644
--- a/examples/iter.rs
+++ b/examples/iter.rs
@@ -20,7 +20,7 @@ struct BookShelfIterator<'b> {
 
 impl BookShelf {
     /// Return an iterator over all values.
-    pub fn iter(&self) -> BookShelfIterator {
+    pub fn iter(&self) -> BookShelfIterator<'_> {
         BookShelfIterator {
             inner: self,
             cursor: 0,
diff --git a/examples/main.rs b/examples/main.rs
index c1b47e6..5073d14 100644
--- a/examples/main.rs
+++ b/examples/main.rs
@@ -1,5 +1,3 @@
-extern crate hypercore;
-
 use hypercore::Feed;
 
 fn main() {
diff --git a/src/crypto/key_pair.rs b/src/crypto/key_pair.rs
index 6a41ed5..ad34665 100644
--- a/src/crypto/key_pair.rs
+++ b/src/crypto/key_pair.rs
@@ -2,7 +2,7 @@
 
 pub use ed25519_dalek::{ExpandedSecretKey, Keypair, PublicKey, SecretKey, Signature};
 
-use crate::Result;
+use anyhow::{bail, ensure, Result};
 use rand::rngs::{OsRng, StdRng};
 use rand::SeedableRng;
 
diff --git a/src/feed.rs b/src/feed.rs
index 34a4232..7f62857 100644
--- a/src/feed.rs
+++ b/src/feed.rs
@@ -8,9 +8,8 @@ use crate::audit::Audit;
 use crate::bitfield::Bitfield;
 use crate::crypto::{generate_keypair, sign, verify, Hash, Merkle};
 use crate::proof::Proof;
-use crate::Result;
+use anyhow::{bail, ensure, Result};
 use ed25519_dalek::{PublicKey, SecretKey, Signature};
-use failure::Error;
 use flat_tree as flat;
 use pretty_hash::fmt as pretty_fmt;
 use random_access_disk::RandomAccessDisk;
@@ -29,7 +28,7 @@ use std::sync::Arc;
 #[derive(Debug)]
 pub struct Feed<T>
 where
-    T: RandomAccess<Error = Error> + Debug,
+    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug,
 {
     /// Merkle tree instance.
     pub(crate) merkle: Merkle,
@@ -48,7 +47,7 @@ where
 
 impl<T> Feed<T>
 where
-    T: RandomAccess<Error = Error> + Debug,
+    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug,
 {
     /// Create a new instance with a custom storage backend.
     pub fn with_storage(mut storage: crate::storage::Storage<T>) -> Result<Self> {
@@ -581,7 +580,9 @@ impl Default for Feed<RandomAccessMemory> {
     }
 }
 
-impl<T: RandomAccess<Error = Error> + Debug> Display for Feed<T> {
+impl<T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug> Display
+    for Feed<T>
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // TODO: yay, we should find a way to convert this .unwrap() to an error
         // type that's accepted by `fmt::Result<(), fmt::Error>`.
diff --git a/src/feed_builder.rs b/src/feed_builder.rs
index e0a30b5..26ed91a 100644
--- a/src/feed_builder.rs
+++ b/src/feed_builder.rs
@@ -3,13 +3,12 @@ use ed25519_dalek::{PublicKey, SecretKey};
 use crate::bitfield::Bitfield;
 use crate::crypto::Merkle;
 use crate::storage::Storage;
-use failure::Error;
 use random_access_storage::RandomAccess;
 use std::fmt::Debug;
 use tree_index::TreeIndex;
 
 use crate::Feed;
-use crate::Result;
+use anyhow::Result;
 
 /// Construct a new `Feed` instance.
 // TODO: make this an actual builder pattern.
@@ -26,7 +25,7 @@ where
 
 impl<T> FeedBuilder<T>
 where
-    T: RandomAccess<Error = Error> + Debug,
+    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug,
 {
     /// Create a new instance.
     #[inline]
diff --git a/src/lib.rs b/src/lib.rs
index 4a9d7de..d5d9a35 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,7 +12,7 @@
 //!
 //! ## Example
 //! ```rust
-//! # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+//! # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 //! let mut feed = hypercore::open("./feed.db")?;
 //!
 //! feed.append(b"hello")?;
@@ -27,9 +27,6 @@
 //! [Dat]: https://github.com/datrs
 //! [Feed]: crate::feed::Feed
 
-#[macro_use]
-extern crate failure;
-
 pub mod bitfield;
 pub mod prelude;
 
@@ -53,12 +50,7 @@ pub use ed25519_dalek::{PublicKey, SecretKey};
 
 use std::path::Path;
 
-use failure::Error;
-
-/// A specialized `Result` type for Hypercore operations.
-pub type Result<T> = std::result::Result<T, Error>;
-
 /// Create a new Hypercore `Feed`.
-pub fn open<P: AsRef<Path>>(path: P) -> Result<Feed<random_access_disk::RandomAccessDisk>> {
+pub fn open<P: AsRef<Path>>(path: P) -> anyhow::Result<Feed<random_access_disk::RandomAccessDisk>> {
     Feed::open(path)
 }
diff --git a/src/storage/mod.rs b/src/storage/mod.rs
index 4959611..736b7ab 100644
--- a/src/storage/mod.rs
+++ b/src/storage/mod.rs
@@ -7,9 +7,8 @@ pub use self::node::Node;
 pub use self::persist::Persist;
 pub use merkle_tree_stream::Node as NodeTrait;
 
-use crate::Result;
+use anyhow::{anyhow, ensure, Result};
 use ed25519_dalek::{PublicKey, SecretKey, Signature, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH};
-use failure::Error;
 use flat_tree as flat;
 use random_access_disk::RandomAccessDisk;
 use random_access_memory::RandomAccessMemory;
@@ -58,7 +57,7 @@ where
 
 impl<T> Storage<T>
 where
-    T: RandomAccess<Error = Error> + Debug,
+    T: RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug,
 {
     /// Create a new instance. Takes a keypair and a callback to create new
     /// storage instances.
@@ -77,13 +76,22 @@ where
         };
 
         let header = create_bitfield();
-        instance.bitfield.write(0, &header.to_vec())?;
+        instance
+            .bitfield
+            .write(0, &header.to_vec())
+            .map_err(|e| anyhow!(e))?;
 
         let header = create_signatures();
-        instance.signatures.write(0, &header.to_vec())?;
+        instance
+            .signatures
+            .write(0, &header.to_vec())
+            .map_err(|e| anyhow!(e))?;
 
         let header = create_tree();
-        instance.tree.write(0, &header.to_vec())?;
+        instance
+            .tree
+            .write(0, &header.to_vec())
+            .map_err(|e| anyhow!(e))?;
 
         Ok(instance)
     }
@@ -91,7 +99,7 @@ where
     /// Write data to the feed.
     #[inline]
     pub fn write_data(&mut self, offset: u64, data: &[u8]) -> Result<()> {
-        self.data.write(offset, &data)
+        self.data.write(offset, &data).map_err(|e| anyhow!(e))
     }
 
     /// Write a byte vector to a data storage (random-access instance) at the
@@ -114,7 +122,7 @@ where
             format!("length  `{:?} != {:?}`", range.count(), data.len())
         );
 
-        self.data.write(range.start, data)
+        self.data.write(range.start, data).map_err(|e| anyhow!(e))
     }
 
     /// Get data from disk that the user has written to it. This is stored
@@ -124,12 +132,18 @@ where
     pub fn get_data(&mut self, index: u64) -> Result<Vec<u8>> {
         let cached_nodes = Vec::new(); // TODO: reuse allocation.
         let range = self.data_offset(index, &cached_nodes)?;
-        self.data.read(range.start, range.count() as u64)
+        self.data
+            .read(range.start, range.count() as u64)
+            .map_err(|e| anyhow!(e))
     }
 
     /// Search the signature stores for a `Signature`, starting at `index`.
     pub fn next_signature(&mut self, index: u64) -> Result<Signature> {
-        let bytes = self.signatures.read(HEADER_OFFSET + 64 * index, 64)?;
+        let bytes = self
+            .signatures
+            .read(HEADER_OFFSET + 64 * index, 64)
+            .map_err(|e| anyhow!(e))?;
+
         if not_zeroes(&bytes) {
             Ok(Signature::from_bytes(&bytes)?)
         } else {
@@ -140,7 +154,10 @@ where
     /// Get a `Signature` from the store.
     #[inline]
     pub fn get_signature(&mut self, index: u64) -> Result<Signature> {
-        let bytes = self.signatures.read(HEADER_OFFSET + 64 * index, 64)?;
+        let bytes = self
+            .signatures
+            .read(HEADER_OFFSET + 64 * index, 64)
+            .map_err(|e| anyhow!(e))?;
         ensure!(not_zeroes(&bytes), "No signature found");
         Ok(Signature::from_bytes(&bytes)?)
     }
@@ -153,6 +170,7 @@ where
         let signature = signature.borrow();
         self.signatures
             .write(HEADER_OFFSET + 64 * index, &signature.to_bytes())
+            .map_err(|e| anyhow!(e))
     }
 
     /// TODO(yw) docs
@@ -208,7 +226,10 @@ where
     /// Get a `Node` from the `tree` storage.
     #[inline]
     pub fn get_node(&mut self, index: u64) -> Result<Node> {
-        let buf = self.tree.read(HEADER_OFFSET + 40 * index, 40)?;
+        let buf = self
+            .tree
+            .read(HEADER_OFFSET + 40 * index, 40)
+            .map_err(|e| anyhow!(e))?;
         let node = Node::from_bytes(index, &buf)?;
         Ok(node)
     }
@@ -220,7 +241,9 @@ where
     pub fn put_node(&mut self, node: &Node) -> Result<()> {
         let index = node.index();
         let buf = node.to_bytes()?;
-        self.tree.write(HEADER_OFFSET + 40 * index, &buf)
+        self.tree
+            .write(HEADER_OFFSET + 40 * index, &buf)
+            .map_err(|e| anyhow!(e))
     }
 
     /// Write data to the internal bitfield module.
@@ -228,12 +251,17 @@ where
     /// NOTE: Should we create a bitfield entry type?
     #[inline]
     pub fn put_bitfield(&mut self, offset: u64, data: &[u8]) -> Result<()> {
-        self.bitfield.write(HEADER_OFFSET + offset, data)
+        self.bitfield
+            .write(HEADER_OFFSET + offset, data)
+            .map_err(|e| anyhow!(e))
     }
 
     /// Read a public key from storage
     pub fn read_public_key(&mut self) -> Result<PublicKey> {
-        let buf = self.keypair.read(0, PUBLIC_KEY_LENGTH as u64)?;
+        let buf = self
+            .keypair
+            .read(0, PUBLIC_KEY_LENGTH as u64)
+            .map_err(|e| anyhow!(e))?;
         let public_key = PublicKey::from_bytes(&buf)?;
         Ok(public_key)
     }
@@ -242,7 +270,8 @@ where
     pub fn read_secret_key(&mut self) -> Result<SecretKey> {
         let buf = self
             .keypair
-            .read(PUBLIC_KEY_LENGTH as u64, SECRET_KEY_LENGTH as u64)?;
+            .read(PUBLIC_KEY_LENGTH as u64, SECRET_KEY_LENGTH as u64)
+            .map_err(|e| anyhow!(e))?;
         let secret_key = SecretKey::from_bytes(&buf)?;
         Ok(secret_key)
     }
@@ -250,13 +279,15 @@ where
     /// Write a public key to the storage
     pub fn write_public_key(&mut self, public_key: &PublicKey) -> Result<()> {
         let buf: [u8; PUBLIC_KEY_LENGTH] = public_key.to_bytes();
-        self.keypair.write(0, &buf)
+        self.keypair.write(0, &buf).map_err(|e| anyhow!(e))
     }
 
     /// Write a secret key to the storage
     pub fn write_secret_key(&mut self, secret_key: &SecretKey) -> Result<()> {
         let buf: [u8; SECRET_KEY_LENGTH] = secret_key.to_bytes();
-        self.keypair.write(PUBLIC_KEY_LENGTH as u64, &buf)
+        self.keypair
+            .write(PUBLIC_KEY_LENGTH as u64, &buf)
+            .map_err(|e| anyhow!(e))
     }
 
     /// Tries to read a partial keypair (ie: with an optional secret_key) from the storage
diff --git a/src/storage/node.rs b/src/storage/node.rs
index c774688..ba1fc41 100644
--- a/src/storage/node.rs
+++ b/src/storage/node.rs
@@ -1,4 +1,5 @@
-use crate::Result;
+use anyhow::ensure;
+use anyhow::Result;
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use merkle_tree_stream::Node as NodeTrait;
 use merkle_tree_stream::{NodeKind, NodeParts};
diff --git a/src/storage/persist.rs b/src/storage/persist.rs
index 55e5c9a..70a3ec0 100644
--- a/src/storage/persist.rs
+++ b/src/storage/persist.rs
@@ -1,5 +1,5 @@
 use super::Storage;
-use crate::Result;
+use anyhow::Result;
 use random_access_storage::RandomAccess;
 use std::fmt::Debug;
 
diff --git a/tests/bitfield.rs b/tests/bitfield.rs
index b90ee7d..2eddd56 100644
--- a/tests/bitfield.rs
+++ b/tests/bitfield.rs
@@ -1,5 +1,4 @@
-extern crate hypercore;
-extern crate rand;
+use rand;
 
 use hypercore::bitfield::{Bitfield, Change::*};
 use rand::Rng;
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index bf821ca..cffb176 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -1,9 +1,7 @@
-extern crate failure;
-extern crate hypercore;
+use hypercore;
 extern crate random_access_memory as ram;
-extern crate random_access_storage;
 
-use self::failure::Error;
+use anyhow::Error;
 use hypercore::{Feed, Storage, Store};
 
 pub fn create_feed(page_size: usize) -> Result<Feed<ram::RandomAccessMemory>, Error> {
diff --git a/tests/compat.rs b/tests/compat.rs
index 8bc9102..3766d4e 100644
--- a/tests/compat.rs
+++ b/tests/compat.rs
@@ -1,12 +1,8 @@
 //! Based on https://github.com/mafintosh/hypercore/blob/cf08d8c907e302cf4b699738f229b050eba41b59/test/compat.js
 
-extern crate data_encoding;
-extern crate ed25519_dalek;
-extern crate hypercore;
-extern crate random_access_disk;
-extern crate random_access_storage;
-extern crate remove_dir_all;
-extern crate tempfile;
+use ed25519_dalek;
+
+use tempfile;
 
 use std::fs::File;
 use std::io::Read;
diff --git a/tests/feed.rs b/tests/feed.rs
index 6c37b30..54e2375 100644
--- a/tests/feed.rs
+++ b/tests/feed.rs
@@ -1,11 +1,8 @@
-extern crate failure;
-extern crate hypercore;
 extern crate random_access_memory as ram;
-extern crate random_access_storage;
+use random_access_storage;
 
 mod common;
 
-use self::failure::Error;
 use self::random_access_storage::RandomAccess;
 use common::create_feed;
 use hypercore::{generate_keypair, Feed, NodeTrait, PublicKey, SecretKey, Storage};
@@ -168,7 +165,9 @@ fn create_with_stored_keys() {
     );
 }
 
-fn copy_keys(feed: &Feed<impl RandomAccess<Error = Error> + Debug>) -> (PublicKey, SecretKey) {
+fn copy_keys(
+    feed: &Feed<impl RandomAccess<Error = Box<dyn std::error::Error + Send + Sync>> + Debug>,
+) -> (PublicKey, SecretKey) {
     match &feed.secret_key() {
         Some(secret) => {
             let secret = secret.to_bytes();
diff --git a/tests/regression.rs b/tests/regression.rs
index 0b6ff2d..4969320 100644
--- a/tests/regression.rs
+++ b/tests/regression.rs
@@ -1,5 +1,3 @@
-extern crate hypercore;
-
 mod common;
 
 use common::create_feed;
diff --git a/tests/storage.rs b/tests/storage.rs
index 8b64679..e0258c5 100644
--- a/tests/storage.rs
+++ b/tests/storage.rs
@@ -1,6 +1,3 @@
-extern crate ed25519_dalek;
-extern crate hypercore;
-
 use ed25519_dalek::PublicKey;
 use hypercore::{generate_keypair, sign, verify, Signature, Storage};