diff --git a/Cargo.toml b/Cargo.toml
index 47780f98..4fe91ea6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ libc = "*"
 log = "*"
 time = "*"
 filetime = "*"
-walker = "^1.0.0"
+walkdir = "^0.1"
 
 [target.x86_64-unknown-linux-gnu.dependencies]
 inotify = "^0.1"
diff --git a/src/inotify/mod.rs b/src/inotify/mod.rs
index 1831bca6..83701e33 100644
--- a/src/inotify/mod.rs
+++ b/src/inotify/mod.rs
@@ -1,9 +1,9 @@
 extern crate inotify as inotify_sys;
 extern crate libc;
-extern crate walker;
+extern crate walkdir;
 
 use self::inotify_sys::wrapper::{self, INotify, Watch};
-use self::walker::Walker;
+use self::walkdir::WalkDir;
 use std::collections::HashMap;
 use std::fs::metadata;
 use std::path::{Path, PathBuf};
@@ -135,25 +135,15 @@ impl Watcher for INotifyWatcher {
       Ok(m)  => m.is_dir(),
       Err(e) => return Err(Error::Io(e)),
     };
-    if is_dir {
-      match Walker::new(path.as_ref()) {
-        Ok(dir) => {
-          for entry in dir {
-            match entry {
-              Ok(entry) => {
-                let path = entry.path();
-                try!(self.add_watch(&path));
-              },
-              Err(e) => return Err(Error::Io(e)),
-            }
-          }
-          self.add_watch(path.as_ref())
-        },
-        Err(e) => Err(Error::Io(e))
-      }
-    } else {
-      self.add_watch(&path.as_ref())
+
+    try!(self.add_watch(&path));
+    if !is_dir { return Ok(()); }
+
+    for entry in WalkDir::new(path).follow_links(true).into_iter().filter_map(|e| e.ok()) {
+      try!(self.add_watch(&entry.path()));
     }
+
+    Ok(())
   }
 
   fn unwatch<P: AsRef<Path>>(&mut self, path: P) -> Result<(), Error> {
diff --git a/src/poll.rs b/src/poll.rs
index a26c9ec5..499a3401 100644
--- a/src/poll.rs
+++ b/src/poll.rs
@@ -5,11 +5,11 @@ use std::fs;
 use std::thread;
 use super::{Error, Event, op, Watcher};
 use std::path::{Path, PathBuf};
-use self::walker::Walker;
+use self::walkdir::WalkDir;
 
 use filetime::FileTime;
 
-extern crate walker;
+extern crate walkdir;
 
 pub struct PollWatcher {
   tx: Sender<Event>,
@@ -90,54 +90,30 @@ impl PollWatcher {
           }
 
           // TODO: more efficient implementation where the dir tree is cached?
-          match Walker::new(watch) {
-            Err(e) => {
-              let _ = tx.send(Event {
-                path: Some(watch.clone()),
-                op: Err(Error::Io(e))
-              });
-              continue
-            },
-            Ok(iter) => {
-              for entry in iter {
-                match entry {
-                  Ok(entry) => {
-                    let path = entry.path();
-
-                    match fs::metadata(&path) {
-                      Err(e) => {
-                        let _ = tx.send(Event {
-                          path: Some(path.clone()),
-                          op: Err(Error::Io(e))
-                        });
-                        continue
-                      },
-                      Ok(stat) => {
-                        let modified =
-                          FileTime::from_last_modification_time(&stat)
-                          .seconds();
-
-                        match mtimes.insert(path.clone(), modified) {
-                          None => continue, // First run
-                          Some(old) => {
-                            if modified > old {
-                              let _ = tx.send(Event {
-                                path: Some(path.clone()),
-                                op: Ok(op::WRITE)
-                              });
-                              continue
-                            }
-                          }
-                        }
-                      }
+          for entry in WalkDir::new(watch).follow_links(true).into_iter().filter_map(|e| e.ok()) {
+            let path = entry.path();
+
+            match fs::metadata(&path) {
+              Err(e) => {
+                let _ = tx.send(Event {
+                  path: Some(path.to_path_buf()),
+                  op: Err(Error::Io(e))
+                });
+                continue
+              },
+              Ok(stat) => {
+                let modified = FileTime::from_last_modification_time(&stat).seconds();
+                match mtimes.insert(path.clone().to_path_buf(), modified) {
+                  None => continue, // First run
+                  Some(old) => {
+                    if modified > old {
+                      let _ = tx.send(Event {
+                        path: Some(path.to_path_buf()),
+                        op: Ok(op::WRITE)
+                      });
+                      continue
                     }
-                  },
-                  Err(e) => {
-                    let _ = tx.send(Event {
-                      path: Some(watch.clone()),
-                      op: Err(Error::Io(e))
-                    });
-                  },
+                  }
                 }
               }
             }