diff --git a/ash/src/entry.rs b/ash/src/entry.rs
index 547530a..b0b18df 100644
--- a/ash/src/entry.rs
+++ b/ash/src/entry.rs
@@ -5,7 +5,9 @@ use vk;
 use instance::Instance;
 use shared_library::dynamic_library::DynamicLibrary;
 use std::path::Path;
-use ::RawPtr;
+use std::error::Error;
+use std::fmt;
+use RawPtr;
 use version::{FunctionPointers, V1_0, InstanceLoader, EntryLoader};
 
 #[cfg(windows)]
@@ -46,6 +48,25 @@ pub enum InstanceError {
     VkError(vk::Result),
 }
 
+impl fmt::Display for InstanceError{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
+        write!(f, "InstanceError::{:?}", self)
+    }
+}
+
+impl Error for InstanceError {
+    fn description(&self) -> &str {
+        "InstanceError"
+    }
+
+    fn cause(&self) -> Option<&Error>{
+        if let &InstanceError::VkError(ref err) = self{
+            return err.cause();
+        }
+        None
+    }
+}
+
 #[allow(non_camel_case_types)]
 pub trait EntryV1_0 {
     type Fp: FunctionPointers;
@@ -58,13 +79,17 @@ pub trait EntryV1_0 {
                        -> Result<Instance<Self::Fp>, InstanceError> {
         unsafe {
             let mut instance: vk::Instance = mem::uninitialized();
-            let err_code = self.fp_v1_0().create_instance(create_info,
-                                                          allocation_callbacks.as_raw_ptr(),
-                                                          &mut instance);
+            let err_code = self.fp_v1_0()
+                .create_instance(create_info,
+                                 allocation_callbacks.as_raw_ptr(),
+                                 &mut instance);
             if err_code != vk::Result::Success {
                 return Err(InstanceError::VkError(err_code));
             }
-            let instance_fp = <<Self as EntryV1_0>::Fp as FunctionPointers>::InstanceFp::load(&self.static_fn(), instance).map_err(|err| InstanceError::LoadError(err))?;
+            let instance_fp =
+                <<Self as EntryV1_0>::Fp as FunctionPointers>::InstanceFp::load(&self.static_fn(),
+                                                                                instance)
+                        .map_err(|err| InstanceError::LoadError(err))?;
             Ok(Instance::from_raw(instance, instance_fp))
         }
     }
@@ -72,7 +97,8 @@ pub trait EntryV1_0 {
     fn enumerate_instance_layer_properties(&self) -> VkResult<Vec<vk::LayerProperties>> {
         unsafe {
             let mut num = 0;
-            self.fp_v1_0().enumerate_instance_layer_properties(&mut num, ptr::null_mut());
+            self.fp_v1_0()
+                .enumerate_instance_layer_properties(&mut num, ptr::null_mut());
 
             let mut v = Vec::with_capacity(num as usize);
             let err_code = self.fp_v1_0()
@@ -91,8 +117,11 @@ pub trait EntryV1_0 {
             self.fp_v1_0()
                 .enumerate_instance_extension_properties(ptr::null(), &mut num, ptr::null_mut());
             let mut data = Vec::with_capacity(num as usize);
-            let err_code = self.fp_v1_0()
-                .enumerate_instance_extension_properties(ptr::null(), &mut num, data.as_mut_ptr());
+            let err_code =
+                self.fp_v1_0()
+                    .enumerate_instance_extension_properties(ptr::null(),
+                                                             &mut num,
+                                                             data.as_mut_ptr());
             data.set_len(num as usize);
             match err_code {
                 vk::Result::Success => Ok(data),
@@ -124,23 +153,25 @@ impl<V: FunctionPointers> Entry<V> {
         let static_fn = match *VK_LIB {
             Ok(ref lib) => {
                 let static_fn = vk::StaticFn::load(|name| unsafe {
-                        let name = name.to_str().unwrap();
-                        let f = match lib.symbol(name) {
-                            Ok(s) => s,
-                            Err(_) => ptr::null(),
-                        };
-                        f
-                    }).map_err(|err| LoadingError::StaticLoadError(err))?;
+                                                       let name = name.to_str().unwrap();
+                                                       let f = match lib.symbol(name) {
+                                                           Ok(s) => s,
+                                                           Err(_) => ptr::null(),
+                                                       };
+                                                       f
+                                                   })
+                        .map_err(|err| LoadingError::StaticLoadError(err))?;
                 Ok(static_fn)
             }
             Err(ref err) => Err(LoadingError::LibraryLoadError(err.clone())),
         }?;
         let entry_fn = unsafe {
-            V::EntryFp::load(&static_fn).map_err(|err| LoadingError::EntryLoadError(err))?
+            V::EntryFp::load(&static_fn)
+                .map_err(|err| LoadingError::EntryLoadError(err))?
         };
         Ok(Entry {
-            static_fn: static_fn,
-            entry_fn: entry_fn,
-        })
+               static_fn: static_fn,
+               entry_fn: entry_fn,
+           })
     }
 }