diff --git a/src/binding.rs b/src/binding.rs
index fc57200c39..1e60e01d73 100644
--- a/src/binding.rs
+++ b/src/binding.rs
@@ -10,45 +10,45 @@ use libc::uint32_t;
 
 #[repr(C)]
 pub struct DenoC {
-    _unused: [u8; 0],
+  _unused: [u8; 0],
 }
 
 #[repr(C)]
 pub struct deno_buf {
-    alloc_ptr: *mut u8,
-    alloc_len: usize,
-    data_ptr: *mut u8,
-    data_len: usize,
+  alloc_ptr: *mut u8,
+  alloc_len: usize,
+  data_ptr: *mut u8,
+  data_len: usize,
 }
 
 type DenoRecvCb = unsafe extern "C" fn(d: *const DenoC, buf: deno_buf);
 
 extern "C" {
-    pub fn deno_init();
-    pub fn deno_v8_version() -> *const c_char;
-    pub fn deno_set_flags(argc: *mut c_int, argv: *mut *mut c_char);
-    pub fn deno_new(data: *const c_void, cb: DenoRecvCb) -> *const DenoC;
-    pub fn deno_delete(d: *const DenoC);
-    pub fn deno_last_exception(d: *const DenoC) -> *const c_char;
-    pub fn deno_set_response(d: *const DenoC, buf: deno_buf);
-    pub fn deno_execute(
-        d: *const DenoC,
-        js_filename: *const c_char,
-        js_source: *const c_char,
-    ) -> c_int;
-    pub fn deno_handle_msg_from_js(d: *const DenoC, buf: deno_buf);
-    pub fn deno_reply_error(
-        d: *const DenoC,
-        cmd_id: uint32_t,
-        msg: *const c_char,
-    );
-    pub fn deno_reply_null(d: *const DenoC, cmd_id: uint32_t);
-    pub fn deno_reply_code_fetch(
-        d: *const DenoC,
-        cmd_id: uint32_t,
-        module_name: *const c_char,
-        filename: *const c_char,
-        source_code: *const c_char,
-        output_code: *const c_char,
-    );
+  pub fn deno_init();
+  pub fn deno_v8_version() -> *const c_char;
+  pub fn deno_set_flags(argc: *mut c_int, argv: *mut *mut c_char);
+  pub fn deno_new(data: *const c_void, cb: DenoRecvCb) -> *const DenoC;
+  pub fn deno_delete(d: *const DenoC);
+  pub fn deno_last_exception(d: *const DenoC) -> *const c_char;
+  pub fn deno_set_response(d: *const DenoC, buf: deno_buf);
+  pub fn deno_execute(
+    d: *const DenoC,
+    js_filename: *const c_char,
+    js_source: *const c_char,
+  ) -> c_int;
+  pub fn deno_handle_msg_from_js(d: *const DenoC, buf: deno_buf);
+  pub fn deno_reply_error(
+    d: *const DenoC,
+    cmd_id: uint32_t,
+    msg: *const c_char,
+  );
+  pub fn deno_reply_null(d: *const DenoC, cmd_id: uint32_t);
+  pub fn deno_reply_code_fetch(
+    d: *const DenoC,
+    cmd_id: uint32_t,
+    module_name: *const c_char,
+    filename: *const c_char,
+    source_code: *const c_char,
+    output_code: *const c_char,
+  );
 }
diff --git a/src/handlers.rs b/src/handlers.rs
index e8cf62a5b8..ff2e8a6b2c 100644
--- a/src/handlers.rs
+++ b/src/handlers.rs
@@ -22,125 +22,131 @@ const ASSET_PREFIX: &str = "/$asset$/";
 
 #[test]
 fn test_url() {
-    let issue_list_url = Url::parse("https://github.com/rust-lang").unwrap();
-    assert!(issue_list_url.scheme() == "https");
+  let issue_list_url = Url::parse("https://github.com/rust-lang").unwrap();
+  assert!(issue_list_url.scheme() == "https");
 }
 
 fn string_from_ptr(ptr: *const c_char) -> String {
-    let cstr = unsafe { CStr::from_ptr(ptr as *const i8) };
-    String::from(cstr.to_str().unwrap())
+  let cstr = unsafe { CStr::from_ptr(ptr as *const i8) };
+  String::from(cstr.to_str().unwrap())
 }
 
 fn as_cstring(s: &String) -> CString {
-    CString::new(s.as_str()).unwrap()
+  CString::new(s.as_str()).unwrap()
 }
 
 // Prototype: https://github.com/ry/deno/blob/golang/os.go#L56-L68
 #[allow(dead_code)]
 fn src_file_to_url<P: AsRef<Path>>(filename: P) -> String {
-    assert!(SRC_DIR.len() > 0, "SRC_DIR shouldn't be empty");
+  assert!(SRC_DIR.len() > 0, "SRC_DIR shouldn't be empty");
 
-    let filename = filename.as_ref().to_path_buf();
-    let src = (SRC_DIR.as_ref() as &Path).to_path_buf();
+  let filename = filename.as_ref().to_path_buf();
+  let src = (SRC_DIR.as_ref() as &Path).to_path_buf();
 
-    if filename.starts_with(&src) {
-        let rest = filename.strip_prefix(&src).unwrap();
-        "http://".to_string() + rest.to_str().unwrap()
-    } else {
-        String::from(filename.to_str().unwrap())
-    }
+  if filename.starts_with(&src) {
+    let rest = filename.strip_prefix(&src).unwrap();
+    "http://".to_string() + rest.to_str().unwrap()
+  } else {
+    String::from(filename.to_str().unwrap())
+  }
 }
 
 #[test]
 fn test_src_file_to_url() {
-    assert_eq!("hello", src_file_to_url("hello"));
-    assert_eq!("/hello", src_file_to_url("/hello"));
-    let x = SRC_DIR.to_string() + "hello";
-    assert_eq!("http://hello", src_file_to_url(&x));
-    let x = SRC_DIR.to_string() + "/hello";
-    assert_eq!("http://hello", src_file_to_url(&x));
+  assert_eq!("hello", src_file_to_url("hello"));
+  assert_eq!("/hello", src_file_to_url("/hello"));
+  let x = SRC_DIR.to_string() + "hello";
+  assert_eq!("http://hello", src_file_to_url(&x));
+  let x = SRC_DIR.to_string() + "/hello";
+  assert_eq!("http://hello", src_file_to_url(&x));
 }
 
 // Prototype: https://github.com/ry/deno/blob/golang/os.go#L70-L98
 // Returns (module name, local filename)
 fn resolve_module(
-    module_specifier: &String,
-    containing_file: &String,
+  module_specifier: &String,
+  containing_file: &String,
 ) -> Result<(String, String), url::ParseError> {
-    info!(
-        "resolve_module before module_specifier {} containing_file {}",
-        module_specifier, containing_file
-    );
+  info!(
+    "resolve_module before module_specifier {} containing_file {}",
+    module_specifier, containing_file
+  );
 
-    //let module_specifier = src_file_to_url(module_specifier);
-    //let containing_file = src_file_to_url(containing_file);
-    //let base_url = Url::parse(&containing_file)?;
+  //let module_specifier = src_file_to_url(module_specifier);
+  //let containing_file = src_file_to_url(containing_file);
+  //let base_url = Url::parse(&containing_file)?;
 
-    let j: Url = if containing_file.as_str().ends_with("/") {
-        let base = Url::from_directory_path(&containing_file).unwrap();
-        base.join(module_specifier)?
-    } else if containing_file == "." {
-        Url::from_file_path(module_specifier).unwrap()
-    } else {
-        let base = Url::from_file_path(&containing_file).unwrap();
-        base.join(module_specifier)?
-    };
+  let j: Url = if containing_file.as_str().ends_with("/") {
+    let base = Url::from_directory_path(&containing_file).unwrap();
+    base.join(module_specifier)?
+  } else if containing_file == "." {
+    Url::from_file_path(module_specifier).unwrap()
+  } else {
+    let base = Url::from_file_path(&containing_file).unwrap();
+    base.join(module_specifier)?
+  };
 
-    let mut p = j.to_file_path()
-        .unwrap()
-        .into_os_string()
-        .into_string()
-        .unwrap();
+  let mut p = j.to_file_path()
+    .unwrap()
+    .into_os_string()
+    .into_string()
+    .unwrap();
 
-    if cfg!(target_os = "windows") {
-        // On windows, replace backward slashes to forward slashes.
-        // TODO(piscisaureus): This may not me be right, I just did it to make
-        // the tests pass.
-        p = p.replace("\\", "/");
-    }
+  if cfg!(target_os = "windows") {
+    // On windows, replace backward slashes to forward slashes.
+    // TODO(piscisaureus): This may not me be right, I just did it to make
+    // the tests pass.
+    p = p.replace("\\", "/");
+  }
 
-    let module_name = p.to_string();
-    let filename = p.to_string();
+  let module_name = p.to_string();
+  let filename = p.to_string();
 
-    Ok((module_name, filename))
+  Ok((module_name, filename))
 }
 
 // https://github.com/ry/deno/blob/golang/os_test.go#L16-L87
 #[test]
 fn test_resolve_module() {
-    // The `add_root` macro prepends "C:" to a string if on windows; on posix
-    // systems it returns the input string untouched. This is necessary because
-    // `Url::from_file_path()` fails if the input path isn't an absolute path.
-    macro_rules! add_root {
-        ($path:expr) => {
-            if cfg!(target_os = "windows") {
-                concat!("C:", $path)
-            } else {
-                $path
-            }
-        };
-    }
+  // The `add_root` macro prepends "C:" to a string if on windows; on posix
+  // systems it returns the input string untouched. This is necessary because
+  // `Url::from_file_path()` fails if the input path isn't an absolute path.
+  macro_rules! add_root {
+    ($path:expr) => {
+      if cfg!(target_os = "windows") {
+        concat!("C:", $path)
+      } else {
+        $path
+      }
+    };
+  }
 
-    let test_cases = [
-        (
-            "./subdir/print_hello.ts",
-            add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/006_url_imports.ts"),
-            add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/subdir/print_hello.ts"),
-            add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/subdir/print_hello.ts"),
-        ),
-        (
-            "testdata/001_hello.js",
-            add_root!("/Users/rld/go/src/github.com/ry/deno/"),
-            add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/001_hello.js"),
-            add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/001_hello.js"),
-        ),
-        (
-            add_root!("/Users/rld/src/deno/hello.js"),
-            ".",
-            add_root!("/Users/rld/src/deno/hello.js"),
-            add_root!("/Users/rld/src/deno/hello.js"),
-        ),
-        /*
+  let test_cases = [
+    (
+      "./subdir/print_hello.ts",
+      add_root!(
+        "/Users/rld/go/src/github.com/ry/deno/testdata/006_url_imports.ts"
+      ),
+      add_root!(
+        "/Users/rld/go/src/github.com/ry/deno/testdata/subdir/print_hello.ts"
+      ),
+      add_root!(
+        "/Users/rld/go/src/github.com/ry/deno/testdata/subdir/print_hello.ts"
+      ),
+    ),
+    (
+      "testdata/001_hello.js",
+      add_root!("/Users/rld/go/src/github.com/ry/deno/"),
+      add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/001_hello.js"),
+      add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/001_hello.js"),
+    ),
+    (
+      add_root!("/Users/rld/src/deno/hello.js"),
+      ".",
+      add_root!("/Users/rld/src/deno/hello.js"),
+      add_root!("/Users/rld/src/deno/hello.js"),
+    ),
+    /*
         (
             "http://localhost:4545/testdata/subdir/print_hello.ts",
             add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/006_url_imports.ts"),
@@ -160,88 +166,87 @@ fn test_resolve_module() {
             path.Join(SrcDir, "unpkg.com/liltest@0.0.5/util"),
         ),
         */
-    ];
-    for &test in test_cases.iter() {
-        let module_specifier = String::from(test.0);
-        let containing_file = String::from(test.1);
-        let (module_name, filename) =
-            resolve_module(&module_specifier, &containing_file).unwrap();
-        assert_eq!(module_name, test.2);
-        assert_eq!(filename, test.3);
-    }
+  ];
+  for &test in test_cases.iter() {
+    let module_specifier = String::from(test.0);
+    let containing_file = String::from(test.1);
+    let (module_name, filename) =
+      resolve_module(&module_specifier, &containing_file).unwrap();
+    assert_eq!(module_name, test.2);
+    assert_eq!(filename, test.3);
+  }
 }
 
 // https://github.com/ry/deno/blob/golang/os.go#L100-L154
 #[no_mangle]
 pub extern "C" fn handle_code_fetch(
-    d: *const DenoC,
-    cmd_id: u32,
-    module_specifier_: *const c_char,
-    containing_file_: *const c_char,
+  d: *const DenoC,
+  cmd_id: u32,
+  module_specifier_: *const c_char,
+  containing_file_: *const c_char,
 ) {
-    let module_specifier = string_from_ptr(module_specifier_);
-    let containing_file = string_from_ptr(containing_file_);
+  let module_specifier = string_from_ptr(module_specifier_);
+  let containing_file = string_from_ptr(containing_file_);
 
-    let result = resolve_module(&module_specifier, &containing_file);
-    if result.is_err() {
-        let err = result.unwrap_err();
-        let errmsg =
-            format!("{} {} {}", err, module_specifier, containing_file);
-        let errmsg_c = as_cstring(&errmsg);
-        unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
-        return;
-    }
-    let (module_name, filename) = result.unwrap();
+  let result = resolve_module(&module_specifier, &containing_file);
+  if result.is_err() {
+    let err = result.unwrap_err();
+    let errmsg = format!("{} {} {}", err, module_specifier, containing_file);
+    let errmsg_c = as_cstring(&errmsg);
+    unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
+    return;
+  }
+  let (module_name, filename) = result.unwrap();
 
-    let mut source_code = String::new();
+  let mut source_code = String::new();
 
-    debug!(
+  debug!(
         "code_fetch. module_name = {} module_specifier = {} containing_file = {} filename = {}",
         module_name, module_specifier, containing_file, filename
     );
 
-    if is_remote(&module_name) {
-        unimplemented!();
-    } else if module_name.starts_with(ASSET_PREFIX) {
-        assert!(false, "Asset resolution should be done in JS, not Rust.");
-    } else {
-        assert!(
-            module_name == filename,
-            "if a module isn't remote, it should have the same filename"
-        );
-        let result = File::open(&filename);
-        if result.is_err() {
-            let err = result.unwrap_err();
-            let errmsg = format!("{} {}", err, filename);
-            let errmsg_c = as_cstring(&errmsg);
-            unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
-            return;
-        }
-        let mut f = result.unwrap();
-        let result = f.read_to_string(&mut source_code);
-        if result.is_err() {
-            let err = result.unwrap_err();
-            let errmsg = format!("{} {}", err, filename);
-            let errmsg_c = as_cstring(&errmsg);
-            unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
-            return;
-        }
+  if is_remote(&module_name) {
+    unimplemented!();
+  } else if module_name.starts_with(ASSET_PREFIX) {
+    assert!(false, "Asset resolution should be done in JS, not Rust.");
+  } else {
+    assert!(
+      module_name == filename,
+      "if a module isn't remote, it should have the same filename"
+    );
+    let result = File::open(&filename);
+    if result.is_err() {
+      let err = result.unwrap_err();
+      let errmsg = format!("{} {}", err, filename);
+      let errmsg_c = as_cstring(&errmsg);
+      unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
+      return;
     }
-
-    let output_code = String::new(); //load_output_code_cache(filename, source_code);
-
-    unsafe {
-        deno_reply_code_fetch(
-            d,
-            cmd_id,
-            as_cstring(&module_name).as_ptr(),
-            as_cstring(&filename).as_ptr(),
-            as_cstring(&source_code).as_ptr(),
-            as_cstring(&output_code).as_ptr(),
-        )
+    let mut f = result.unwrap();
+    let result = f.read_to_string(&mut source_code);
+    if result.is_err() {
+      let err = result.unwrap_err();
+      let errmsg = format!("{} {}", err, filename);
+      let errmsg_c = as_cstring(&errmsg);
+      unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
+      return;
     }
+  }
+
+  let output_code = String::new(); //load_output_code_cache(filename, source_code);
+
+  unsafe {
+    deno_reply_code_fetch(
+      d,
+      cmd_id,
+      as_cstring(&module_name).as_ptr(),
+      as_cstring(&filename).as_ptr(),
+      as_cstring(&source_code).as_ptr(),
+      as_cstring(&output_code).as_ptr(),
+    )
+  }
 }
 
 fn is_remote(_module_name: &String) -> bool {
-    false
+  false
 }
diff --git a/src/main.rs b/src/main.rs
index efe7d86c08..2b0a72c917 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -9,101 +9,101 @@ use std::ptr;
 
 mod binding;
 use binding::{
-    deno_delete, deno_execute, deno_handle_msg_from_js, deno_init,
-    deno_last_exception, deno_new, deno_set_flags, DenoC,
+  deno_delete, deno_execute, deno_handle_msg_from_js, deno_init,
+  deno_last_exception, deno_new, deno_set_flags, DenoC,
 };
 
 // Pass the command line arguments to v8.
 // Returns a vector of command line arguments that v8 did not understand.
 fn set_flags() -> Vec<String> {
-    // deno_set_flags(int* argc, char** argv) mutates argc and argv to remove
-    // flags that v8 understands.
-    // Convert command line arguments to a vector of C strings.
-    let mut argv = std::env::args()
-        .map(|arg| CString::new(arg).unwrap().into_bytes_with_nul())
-        .collect::<Vec<_>>();
-    // Make a new array, that can be modified by V8::SetFlagsFromCommandLine(),
-    // containing mutable raw pointers to the individual command line args.
-    let mut c_argv = argv.iter_mut()
-        .map(|arg| arg.as_mut_ptr() as *mut i8)
-        .collect::<Vec<_>>();
-    // Store the length of the argv array in a local variable. We'll pass a
-    // pointer to this local variable to deno_set_flags(), which then
-    // updates its value.
-    let mut c_argc = argv.len() as c_int;
-    // Let v8 parse the arguments it recognizes and remove them from c_argv.
-    unsafe {
-        deno_set_flags(&mut c_argc, c_argv.as_mut_ptr());
-    };
-    // If c_argc was updated we have to change the length of c_argv to match.
-    c_argv.truncate(c_argc as usize);
-    // Copy the modified arguments list into a proper rust vec and return it.
-    c_argv
-        .iter()
-        .map(|ptr| unsafe {
-            let cstr = CStr::from_ptr(*ptr as *const i8);
-            let slice = cstr.to_str().unwrap();
-            slice.to_string()
-        })
-        .collect::<Vec<_>>()
+  // deno_set_flags(int* argc, char** argv) mutates argc and argv to remove
+  // flags that v8 understands.
+  // Convert command line arguments to a vector of C strings.
+  let mut argv = std::env::args()
+    .map(|arg| CString::new(arg).unwrap().into_bytes_with_nul())
+    .collect::<Vec<_>>();
+  // Make a new array, that can be modified by V8::SetFlagsFromCommandLine(),
+  // containing mutable raw pointers to the individual command line args.
+  let mut c_argv = argv
+    .iter_mut()
+    .map(|arg| arg.as_mut_ptr() as *mut i8)
+    .collect::<Vec<_>>();
+  // Store the length of the argv array in a local variable. We'll pass a
+  // pointer to this local variable to deno_set_flags(), which then
+  // updates its value.
+  let mut c_argc = argv.len() as c_int;
+  // Let v8 parse the arguments it recognizes and remove them from c_argv.
+  unsafe {
+    deno_set_flags(&mut c_argc, c_argv.as_mut_ptr());
+  };
+  // If c_argc was updated we have to change the length of c_argv to match.
+  c_argv.truncate(c_argc as usize);
+  // Copy the modified arguments list into a proper rust vec and return it.
+  c_argv
+    .iter()
+    .map(|ptr| unsafe {
+      let cstr = CStr::from_ptr(*ptr as *const i8);
+      let slice = cstr.to_str().unwrap();
+      slice.to_string()
+    })
+    .collect::<Vec<_>>()
 }
 
 type DenoException<'a> = &'a str;
 
 struct Deno {
-    ptr: *const DenoC,
+  ptr: *const DenoC,
 }
 
 impl Deno {
-    fn new() -> Deno {
-        let ptr = unsafe { deno_new(ptr::null(), deno_handle_msg_from_js) };
-        Deno { ptr: ptr }
-    }
+  fn new() -> Deno {
+    let ptr = unsafe { deno_new(ptr::null(), deno_handle_msg_from_js) };
+    Deno { ptr: ptr }
+  }
 
-    fn execute(
-        &mut self,
-        js_filename: &str,
-        js_source: &str,
-    ) -> Result<(), DenoException> {
-        let filename = CString::new(js_filename).unwrap();
-        let source = CString::new(js_source).unwrap();
-        let r = unsafe {
-            deno_execute(self.ptr, filename.as_ptr(), source.as_ptr())
-        };
-        if r == 0 {
-            let ptr = unsafe { deno_last_exception(self.ptr) };
-            let cstr = unsafe { CStr::from_ptr(ptr) };
-            return Err(cstr.to_str().unwrap());
-        }
-        Ok(())
+  fn execute(
+    &mut self,
+    js_filename: &str,
+    js_source: &str,
+  ) -> Result<(), DenoException> {
+    let filename = CString::new(js_filename).unwrap();
+    let source = CString::new(js_source).unwrap();
+    let r =
+      unsafe { deno_execute(self.ptr, filename.as_ptr(), source.as_ptr()) };
+    if r == 0 {
+      let ptr = unsafe { deno_last_exception(self.ptr) };
+      let cstr = unsafe { CStr::from_ptr(ptr) };
+      return Err(cstr.to_str().unwrap());
     }
+    Ok(())
+  }
 }
 
 impl Drop for Deno {
-    fn drop(&mut self) {
-        unsafe { deno_delete(self.ptr) }
-    }
+  fn drop(&mut self) {
+    unsafe { deno_delete(self.ptr) }
+  }
 }
 
 fn main() {
-    log::set_max_level(log::LevelFilter::Debug);
+  log::set_max_level(log::LevelFilter::Debug);
 
-    unsafe { deno_init() };
+  unsafe { deno_init() };
 
-    set_flags();
+  set_flags();
 
-    /*
+  /*
     let v = unsafe { deno_v8_version() };
     let c_str = unsafe { CStr::from_ptr(v) };
     let version = c_str.to_str().unwrap();
     println!("version: {}", version);
     */
 
-    let mut d = Deno::new();
+  let mut d = Deno::new();
 
-    d.execute("deno_main.js", "denoMain();")
-        .unwrap_or_else(|err| {
-            error!("{}", err);
-            std::process::exit(1);
-        });
+  d.execute("deno_main.js", "denoMain();")
+    .unwrap_or_else(|err| {
+      error!("{}", err);
+      std::process::exit(1);
+    });
 }
diff --git a/tools/rustfmt.toml b/tools/rustfmt.toml
index df99c69198..4c1eefaed5 100644
--- a/tools/rustfmt.toml
+++ b/tools/rustfmt.toml
@@ -1 +1,2 @@
 max_width = 80
+tab_spaces = 2