diff --git a/src/format.rs b/src/format.rs
index 9eb6ceb..88dba9c 100644
--- a/src/format.rs
+++ b/src/format.rs
@@ -147,10 +147,10 @@ impl TextComponent {
 
 impl fmt::Display for TextComponent {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "{}", self.text));
+        write!(f, "{}", self.text)?;
         if let Some(ref extra) = self.modifier.extra {
             for c in extra {
-                try!(write!(f, "{}", c));
+                write!(f, "{}", c)?;
             }
         }
         Result::Ok(())
diff --git a/src/item.rs b/src/item.rs
index 45e4017..dfea1c6 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -39,26 +39,26 @@ impl Default for Stack {
 
 impl Serializable for Option<Stack> {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<Stack>, protocol::Error> {
-        let id = try!(buf.read_i16::<BigEndian>());
+        let id = buf.read_i16::<BigEndian>()?;
         if id == -1 {
             return Ok(None);
         }
         Ok(Some(Stack {
             id: id as isize,
-            count: try!(buf.read_u8()) as isize,
-            damage: try!(buf.read_i16::<BigEndian>()) as isize,
-            tag: try!(Serializable::read_from(buf)),
+            count: buf.read_u8()? as isize,
+            damage: buf.read_i16::<BigEndian>()? as isize,
+            tag: Serializable::read_from(buf)?,
         }))
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
         match *self {
             Some(ref val) => {
-                try!(buf.write_i16::<BigEndian>(val.id as i16));
-                try!(buf.write_u8(val.count as u8));
-                try!(buf.write_i16::<BigEndian>(val.damage as i16));
-                try!(val.tag.write_to(buf));
+                buf.write_i16::<BigEndian>(val.id as i16)?;
+                buf.write_u8(val.count as u8)?;
+                buf.write_i16::<BigEndian>(val.damage as i16)?;
+                val.tag.write_to(buf)?;
             }
-            None => try!(buf.write_i16::<BigEndian>(-1)),
+            None => buf.write_i16::<BigEndian>(-1)?,
         }
         Result::Ok(())
     }
diff --git a/src/nbt/mod.rs b/src/nbt/mod.rs
index db4d302..3e79578 100644
--- a/src/nbt/mod.rs
+++ b/src/nbt/mod.rs
@@ -175,45 +175,45 @@ impl Tag {
     fn read_type<R: io::Read>(id: u8, buf: &mut R) -> Result<Tag, protocol::Error> {
         match id {
             0 => unreachable!(),
-            1 => Ok(Tag::Byte(try!(buf.read_i8()))),
-            2 => Ok(Tag::Short(try!(buf.read_i16::<BigEndian>()))),
-            3 => Ok(Tag::Int(try!(buf.read_i32::<BigEndian>()))),
-            4 => Ok(Tag::Long(try!(buf.read_i64::<BigEndian>()))),
-            5 => Ok(Tag::Float(try!(buf.read_f32::<BigEndian>()))),
-            6 => Ok(Tag::Double(try!(buf.read_f64::<BigEndian>()))),
+            1 => Ok(Tag::Byte(buf.read_i8()?)),
+            2 => Ok(Tag::Short(buf.read_i16::<BigEndian>()?)),
+            3 => Ok(Tag::Int(buf.read_i32::<BigEndian>()?)),
+            4 => Ok(Tag::Long(buf.read_i64::<BigEndian>()?)),
+            5 => Ok(Tag::Float(buf.read_f32::<BigEndian>()?)),
+            6 => Ok(Tag::Double(buf.read_f64::<BigEndian>()?)),
             7 => Ok(Tag::ByteArray({
-                let len: i32 = try!(Serializable::read_from(buf));
+                let len: i32 = Serializable::read_from(buf)?;
                 let mut data = Vec::with_capacity(len as usize);
-                try!(buf.take(len as u64).read_to_end(&mut data));
+                buf.take(len as u64).read_to_end(&mut data)?;
                 data
             })),
-            8 => Ok(Tag::String(try!(read_string(buf)))),
+            8 => Ok(Tag::String(read_string(buf)?)),
             9 => {
                 let mut l = Vec::new();
-                let ty = try!(buf.read_u8());
-                let len: i32 = try!(Serializable::read_from(buf));
+                let ty = buf.read_u8()?;
+                let len: i32 = Serializable::read_from(buf)?;
                 for _ in 0..len {
-                    l.push(try!(Tag::read_type(ty, buf)));
+                    l.push(Tag::read_type(ty, buf)?);
                 }
                 Ok(Tag::List(l))
             }
             10 => {
                 let mut c = Tag::new_compound();
                 loop {
-                    let ty = try!(buf.read_u8());
+                    let ty = buf.read_u8()?;
                     if ty == 0 {
                         break;
                     }
-                    let name: String = try!(read_string(buf));
-                    c.put(&name[..], try!(Tag::read_type(ty, buf)));
+                    let name: String = read_string(buf)?;
+                    c.put(&name[..], Tag::read_type(ty, buf)?);
                 }
                 Ok(c)
             }
             11 => Ok(Tag::IntArray({
-                let len: i32 = try!(Serializable::read_from(buf));
+                let len: i32 = Serializable::read_from(buf)?;
                 let mut data = Vec::with_capacity(len as usize);
                 for _ in 0..len {
-                    data.push(try!(buf.read_i32::<BigEndian>()));
+                    data.push(buf.read_i32::<BigEndian>()?);
                 }
                 data
             })),
@@ -230,41 +230,41 @@ impl Serializable for Tag {
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
         match *self {
             Tag::End => {}
-            Tag::Byte(val) => try!(buf.write_i8(val)),
-            Tag::Short(val) => try!(buf.write_i16::<BigEndian>(val)),
-            Tag::Int(val) => try!(buf.write_i32::<BigEndian>(val)),
-            Tag::Long(val) => try!(buf.write_i64::<BigEndian>(val)),
-            Tag::Float(val) => try!(buf.write_f32::<BigEndian>(val)),
-            Tag::Double(val) => try!(buf.write_f64::<BigEndian>(val)),
+            Tag::Byte(val) => buf.write_i8(val)?,
+            Tag::Short(val) => buf.write_i16::<BigEndian>(val)?,
+            Tag::Int(val) => buf.write_i32::<BigEndian>(val)?,
+            Tag::Long(val) => buf.write_i64::<BigEndian>(val)?,
+            Tag::Float(val) => buf.write_f32::<BigEndian>(val)?,
+            Tag::Double(val) => buf.write_f64::<BigEndian>(val)?,
             Tag::ByteArray(ref val) => {
-                try!((val.len() as i32).write_to(buf));
-                try!(buf.write_all(val));
+                (val.len() as i32).write_to(buf)?;
+                buf.write_all(val)?;
             }
-            Tag::String(ref val) => try!(write_string(buf, val)),
+            Tag::String(ref val) => write_string(buf, val)?,
             Tag::List(ref val) => {
                 if val.is_empty() {
-                    try!(buf.write_u8(0));
-                    try!(buf.write_i32::<BigEndian>(0));
+                    buf.write_u8(0)?;
+                    buf.write_i32::<BigEndian>(0)?;
                 } else {
-                    try!(buf.write_u8(val[0].internal_id()));
-                    try!(buf.write_i32::<BigEndian>(val.len() as i32));
+                    buf.write_u8(val[0].internal_id())?;
+                    buf.write_i32::<BigEndian>(val.len() as i32)?;
                     for e in val {
-                        try!(e.write_to(buf));
+                        e.write_to(buf)?;
                     }
                 }
             }
             Tag::Compound(ref val) => {
                 for (k, v) in val {
-                    try!(v.internal_id().write_to(buf));
-                    try!(write_string(buf, k));
-                    try!(v.write_to(buf));
+                    v.internal_id().write_to(buf)?;
+                    write_string(buf, k)?;
+                    v.write_to(buf)?;
                 }
-                try!(buf.write_u8(0));
+                buf.write_u8(0)?;
             }
             Tag::IntArray(ref val) => {
-                try!((val.len() as i32).write_to(buf));
+                (val.len() as i32).write_to(buf)?;
                 for v in val {
-                    try!(v.write_to(buf));
+                    v.write_to(buf)?;
                 }
             }
         }
@@ -274,13 +274,13 @@ impl Serializable for Tag {
 
 pub fn write_string<W: io::Write>(buf: &mut W, s: &str) -> Result<(), protocol::Error> {
     let data = s.as_bytes();
-    try!((data.len() as i16).write_to(buf));
+    (data.len() as i16).write_to(buf)?;
     buf.write_all(data).map_err(|v| v.into())
 }
 
 pub fn read_string<R: io::Read>(buf: &mut R) -> Result<String, protocol::Error> {
-    let len: i16 = try!(buf.read_i16::<BigEndian>());
+    let len: i16 = buf.read_i16::<BigEndian>()?;
     let mut ret = String::new();
-    try!(buf.take(len as u64).read_to_string(&mut ret));
+    buf.take(len as u64).read_to_string(&mut ret)?;
     Result::Ok(ret)
 }
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index 53bc638..e565712 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -98,7 +98,7 @@ macro_rules! state_packets {
                         fn write<W: io::Write>(self, buf: &mut W) -> Result<(), Error> {
                             $(
                                 if true $(&& ($cond(&self)))* {
-                                    try!(self.$field.write_to(buf));
+                                    self.$field.write_to(buf)?;
                                 }
                             )+
 
@@ -127,7 +127,7 @@ macro_rules! state_packets {
                                             let mut packet : $name = $name::default();
                                             $(
                                                 if true $(&& ($cond(&packet)))* {
-                                                    packet.$field = try!(Serializable::read_from(&mut buf));
+                                                    packet.$field = Serializable::read_from(&mut buf)?;
                                                 }
                                             )+
                                             Result::Ok(Option::Some(Packet::$name(packet)))
@@ -155,7 +155,7 @@ pub trait Serializable: Sized {
 impl Serializable for Vec<u8> {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Vec<u8>, Error> {
         let mut v = Vec::new();
-        try!(buf.read_to_end(&mut v));
+        buf.read_to_end(&mut v)?;
         Ok(v)
     }
 
@@ -166,23 +166,23 @@ impl Serializable for Vec<u8> {
 
 impl Serializable for Option<nbt::NamedTag>{
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<nbt::NamedTag>, Error> {
-        let ty = try!(buf.read_u8());
+        let ty = buf.read_u8()?;
         if ty == 0 {
             Result::Ok(None)
         } else {
-            let name = try!(nbt::read_string(buf));
-            let tag = try!(nbt::Tag::read_from(buf));
+            let name = nbt::read_string(buf)?;
+            let tag = nbt::Tag::read_from(buf)?;
             Result::Ok(Some(nbt::NamedTag(name, tag)))
         }
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
         match *self {
             Some(ref val) => {
-                try!(buf.write_u8(10));
-                try!(nbt::write_string(buf, &val.0));
-                try!(val.1.write_to(buf));
+                buf.write_u8(10)?;
+                nbt::write_string(buf, &val.0)?;
+                val.1.write_to(buf)?;
             }
-            None => try!(buf.write_u8(0)),
+            None => buf.write_u8(0)?,
         }
         Result::Ok(())
     }
@@ -190,11 +190,11 @@ impl Serializable for Option<nbt::NamedTag>{
 
 impl <T> Serializable for Option<T> where T : Serializable {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Option<T>, Error> {
-        Result::Ok(Some(try!(T::read_from(buf))))
+        Result::Ok(Some(T::read_from(buf)?))
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
         if self.is_some() {
-            try!(self.as_ref().unwrap().write_to(buf));
+            self.as_ref().unwrap().write_to(buf)?;
         }
         Result::Ok(())
     }
@@ -206,30 +206,30 @@ impl Serializable for String {
         debug_assert!(len >= 0, "Negative string length: {}", len);
         debug_assert!(len <= 65536, "String length too big: {}", len);
         let mut ret = String::new();
-        try!(buf.take(len as u64).read_to_string(&mut ret));
+        buf.take(len as u64).read_to_string(&mut ret)?;
         Result::Ok(ret)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
         let bytes = self.as_bytes();
-        try!(VarInt(bytes.len() as i32).write_to(buf));
-        try!(buf.write_all(bytes));
+        VarInt(bytes.len() as i32).write_to(buf)?;
+        buf.write_all(bytes)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for format::Component {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
-        let len = try!(VarInt::read_from(buf)).0;
+        let len = VarInt::read_from(buf)?.0;
         let mut ret = String::new();
-        try!(buf.take(len as u64).read_to_string(&mut ret));
+        buf.take(len as u64).read_to_string(&mut ret)?;
         let val: serde_json::Value = serde_json::from_str(&ret[..]).unwrap();
         Result::Ok(Self::from_value(&val))
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
         let val = serde_json::to_string(&self.to_value()).unwrap();
         let bytes = val.as_bytes();
-        try!(VarInt(bytes.len() as i32).write_to(buf));
-        try!(buf.write_all(bytes));
+        VarInt(bytes.len() as i32).write_to(buf)?;
+        buf.write_all(bytes)?;
         Result::Ok(())
     }
 }
@@ -245,104 +245,104 @@ impl Serializable for () {
 
 impl Serializable for bool {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<bool, Error> {
-        Result::Ok(try!(buf.read_u8()) != 0)
+        Result::Ok(buf.read_u8()? != 0)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_u8(if *self {
+        buf.write_u8(if *self {
             1
         } else {
             0
-        }));
+        })?;
         Result::Ok(())
     }
 }
 
 impl Serializable for i8 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<i8, Error> {
-        Result::Ok(try!(buf.read_i8()))
+        Result::Ok(buf.read_i8()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_i8(*self));
+        buf.write_i8(*self)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for i16 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<i16, Error> {
-        Result::Ok(try!(buf.read_i16::<BigEndian>()))
+        Result::Ok(buf.read_i16::<BigEndian>()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_i16::<BigEndian>(*self));
+        buf.write_i16::<BigEndian>(*self)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for i32 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<i32, Error> {
-        Result::Ok(try!(buf.read_i32::<BigEndian>()))
+        Result::Ok(buf.read_i32::<BigEndian>()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_i32::<BigEndian>(*self));
+        buf.write_i32::<BigEndian>(*self)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for i64 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<i64, Error> {
-        Result::Ok(try!(buf.read_i64::<BigEndian>()))
+        Result::Ok(buf.read_i64::<BigEndian>()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_i64::<BigEndian>(*self));
+        buf.write_i64::<BigEndian>(*self)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for u8 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<u8, Error> {
-        Result::Ok(try!(buf.read_u8()))
+        Result::Ok(buf.read_u8()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_u8(*self));
+        buf.write_u8(*self)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for u16 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<u16, Error> {
-        Result::Ok(try!(buf.read_u16::<BigEndian>()))
+        Result::Ok(buf.read_u16::<BigEndian>()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_u16::<BigEndian>(*self));
+        buf.write_u16::<BigEndian>(*self)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for u64 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<u64, Error> {
-        Result::Ok(try!(buf.read_u64::<BigEndian>()))
+        Result::Ok(buf.read_u64::<BigEndian>()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_u64::<BigEndian>(*self));
+        buf.write_u64::<BigEndian>(*self)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for f32 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<f32, Error> {
-        Result::Ok(try!(buf.read_f32::<BigEndian>()))
+        Result::Ok(buf.read_f32::<BigEndian>()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_f32::<BigEndian>(*self));
+        buf.write_f32::<BigEndian>(*self)?;
         Result::Ok(())
     }
 }
 
 impl Serializable for f64 {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<f64, Error> {
-        Result::Ok(try!(buf.read_f64::<BigEndian>()))
+        Result::Ok(buf.read_f64::<BigEndian>()?)
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_f64::<BigEndian>(*self));
+        buf.write_f64::<BigEndian>(*self)?;
         Result::Ok(())
     }
 }
@@ -380,12 +380,12 @@ impl Default for UUID {
 
 impl Serializable for UUID {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<UUID, Error> {
-        Result::Ok(UUID(try!(buf.read_u64::<BigEndian>()),
-                        try!(buf.read_u64::<BigEndian>())))
+        Result::Ok(UUID(buf.read_u64::<BigEndian>()?,
+                        buf.read_u64::<BigEndian>()?))
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(buf.write_u64::<BigEndian>(self.0));
-        try!(buf.write_u64::<BigEndian>(self.1));
+        buf.write_u64::<BigEndian>(self.0)?;
+        buf.write_u64::<BigEndian>(self.1)?;
         Result::Ok(())
     }
 }
@@ -412,11 +412,11 @@ impl <L: Lengthable, V: Default>  LenPrefixed<L, V> {
 
 impl <L: Lengthable, V: Serializable>  Serializable for LenPrefixed<L, V> {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<LenPrefixed<L, V>, Error> {
-        let len_data: L = try!(Serializable::read_from(buf));
+        let len_data: L = Serializable::read_from(buf)?;
         let len: usize = len_data.into();
         let mut data: Vec<V> = Vec::with_capacity(len);
         for _ in 0..len {
-            data.push(try!(Serializable::read_from(buf)));
+            data.push(Serializable::read_from(buf)?);
         }
         Result::Ok(LenPrefixed {
             len: len_data,
@@ -426,10 +426,10 @@ impl <L: Lengthable, V: Serializable>  Serializable for LenPrefixed<L, V> {
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
         let len_data: L = L::from(self.data.len());
-        try!(len_data.write_to(buf));
+        len_data.write_to(buf)?;
         let data = &self.data;
         for val in data {
-            try!(val.write_to(buf));
+            val.write_to(buf)?;
         }
         Result::Ok(())
     }
@@ -468,10 +468,10 @@ impl <L: Lengthable>  LenPrefixedBytes<L> {
 
 impl <L: Lengthable>  Serializable for LenPrefixedBytes<L> {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<LenPrefixedBytes<L>, Error> {
-        let len_data: L = try!(Serializable::read_from(buf));
+        let len_data: L = Serializable::read_from(buf)?;
         let len: usize = len_data.into();
         let mut data: Vec<u8> = Vec::with_capacity(len);
-        try!(buf.take(len as u64).read_to_end(&mut data));
+        buf.take(len as u64).read_to_end(&mut data)?;
         Result::Ok(LenPrefixedBytes {
             len: len_data,
             data: data,
@@ -480,8 +480,8 @@ impl <L: Lengthable>  Serializable for LenPrefixedBytes<L> {
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
         let len_data: L = L::from(self.data.len());
-        try!(len_data.write_to(buf));
-        try!(buf.write_all(&self.data[..]));
+        len_data.write_to(buf)?;
+        buf.write_all(&self.data[..])?;
         Result::Ok(())
     }
 }
@@ -544,7 +544,7 @@ impl Serializable for VarInt {
         let mut size = 0;
         let mut val = 0u32;
         loop {
-            let b = try!(buf.read_u8()) as u32;
+            let b = buf.read_u8()? as u32;
             val |= (b & PART) << (size * 7);
             size += 1;
             if size > 5 {
@@ -564,10 +564,10 @@ impl Serializable for VarInt {
         let mut val = self.0 as u32;
         loop {
             if (val & !PART) == 0 {
-                try!(buf.write_u8(val as u8));
+                buf.write_u8(val as u8)?;
                 return Result::Ok(());
             }
-            try!(buf.write_u8(((val & PART) | 0x80) as u8));
+            buf.write_u8(((val & PART) | 0x80) as u8)?;
             val >>= 7;
         }
     }
@@ -607,7 +607,7 @@ impl Serializable for VarLong {
         let mut size = 0;
         let mut val = 0u64;
         loop {
-            let b = try!(buf.read_u8()) as u64;
+            let b = buf.read_u8()? as u64;
             val |= (b & PART) << (size * 7);
             size += 1;
             if size > 10 {
@@ -627,10 +627,10 @@ impl Serializable for VarLong {
         let mut val = self.0 as u64;
         loop {
             if (val & !PART) == 0 {
-                try!(buf.write_u8(val as u8));
+                buf.write_u8(val as u8)?;
                 return Result::Ok(());
             }
-            try!(buf.write_u8(((val & PART) | 0x80) as u8));
+            buf.write_u8(((val & PART) | 0x80) as u8)?;
             val >>= 7;
         }
     }
@@ -650,7 +650,7 @@ impl fmt::Debug for VarLong {
 
 impl Serializable for Position {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Position, Error> {
-        let pos = try!(buf.read_u64::<BigEndian>());
+        let pos = buf.read_u64::<BigEndian>()?;
         Ok(Position::new(
             ((pos as i64) >> 38) as i32,
             (((pos as i64) >> 26) & 0xFFF) as i32,
@@ -661,7 +661,7 @@ impl Serializable for Position {
         let pos = (((self.x as u64) & 0x3FFFFFF) << 38)
             | (((self.y as u64) & 0xFFF) << 26)
             | ((self.z as u64) & 0x3FFFFFF);
-        try!(buf.write_u64::<BigEndian>(pos));
+        buf.write_u64::<BigEndian>(pos)?;
         Result::Ok(())
     }
 }
@@ -763,7 +763,7 @@ impl Conn {
         } else {
             format!("{}:{}", parts[0], parts[1])
         };
-        let stream = try!(TcpStream::connect(&*address));
+        let stream = TcpStream::connect(&*address)?;
         Result::Ok(Conn {
             stream: stream,
             host: parts[0].to_owned(),
@@ -779,8 +779,8 @@ impl Conn {
 
     pub fn write_packet<T: PacketType>(&mut self, packet: T) -> Result<(), Error> {
         let mut buf = Vec::new();
-        try!(VarInt(packet.packet_id()).write_to(&mut buf));
-        try!(packet.write(&mut buf));
+        VarInt(packet.packet_id()).write_to(&mut buf)?;
+        packet.write(&mut buf)?;
 
         let mut extra = if self.compression_threshold >= 0 {
             1
@@ -794,26 +794,26 @@ impl Conn {
             extra = 0;
             let uncompressed_size = buf.len();
             let mut new = Vec::new();
-            try!(VarInt(uncompressed_size as i32).write_to(&mut new));
+            VarInt(uncompressed_size as i32).write_to(&mut new)?;
             let write = self.compression_write.as_mut().unwrap();
             write.reset(io::Cursor::new(buf));
-            try!(write.read_to_end(&mut new));
+            write.read_to_end(&mut new)?;
             buf = new;
         }
 
-        try!(VarInt(buf.len() as i32 + extra).write_to(self));
+        VarInt(buf.len() as i32 + extra).write_to(self)?;
         if self.compression_threshold >= 0 && extra == 1 {
-            try!(VarInt(0).write_to(self));
+            VarInt(0).write_to(self)?;
         }
-        try!(self.write_all(&buf));
+        self.write_all(&buf)?;
 
         Result::Ok(())
     }
 
     pub fn read_packet(&mut self) -> Result<packet::Packet, Error> {
-        let len = try!(VarInt::read_from(self)).0 as usize;
+        let len = VarInt::read_from(self)?.0 as usize;
         let mut ibuf = vec![0; len];
-        try!(self.read_exact(&mut ibuf));
+        self.read_exact(&mut ibuf)?;
 
         let mut buf = io::Cursor::new(ibuf);
 
@@ -821,25 +821,25 @@ impl Conn {
             if self.compression_read.is_none() {
                 self.compression_read = Some(ZlibDecoder::new(io::Cursor::new(Vec::new())));
             }
-            let uncompressed_size = try!(VarInt::read_from(&mut buf)).0;
+            let uncompressed_size = VarInt::read_from(&mut buf)?.0;
             if uncompressed_size != 0 {
                 let mut new = Vec::with_capacity(uncompressed_size as usize);
                 {
                     let reader = self.compression_read.as_mut().unwrap();
                     reader.reset(buf);
-                    try!(reader.read_to_end(&mut new));
+                    reader.read_to_end(&mut new)?;
                 }
                 buf = io::Cursor::new(new);
             }
         }
-        let id = try!(VarInt::read_from(&mut buf)).0;
+        let id = VarInt::read_from(&mut buf)?.0;
 
         let dir = match self.direction {
             Direction::Clientbound => Direction::Serverbound,
             Direction::Serverbound => Direction::Clientbound,
         };
 
-        let packet = try!(packet::packet_by_id(self.state, dir, id, &mut buf));
+        let packet = packet::packet_by_id(self.state, dir, id, &mut buf)?;
 
         match packet {
             Some(val) => {
@@ -873,26 +873,26 @@ impl Conn {
         use self::packet::Packet;
         let host = self.host.clone();
         let port = self.port;
-        try!(self.write_packet(Handshake {
+        self.write_packet(Handshake {
             protocol_version: VarInt(SUPPORTED_PROTOCOL),
             host: host,
             port: port,
             next: VarInt(1),
-        }));
+        })?;
         self.state = State::Status;
 
-        try!(self.write_packet(StatusRequest { empty: () }));
+        self.write_packet(StatusRequest { empty: () })?;
 
-        let status = if let Packet::StatusResponse(res) = try!(self.read_packet()) {
+        let status = if let Packet::StatusResponse(res) = self.read_packet()? {
             res.status
         } else {
             return Err(Error::Err("Wrong packet".to_owned()));
         };
 
         let start = Instant::now();
-        try!(self.write_packet(StatusPing { ping: 42 }));
+        self.write_packet(StatusPing { ping: 42 })?;
 
-        if let Packet::StatusPong(_) = try!(self.read_packet()) {
+        if let Packet::StatusPong(_) = self.read_packet()? {
         } else {
             return Err(Error::Err("Wrong packet".to_owned()));
         };
@@ -906,28 +906,28 @@ impl Conn {
 
         let invalid_status = || Error::Err("Invalid status".to_owned());
 
-        let version = try!(val.get("version").ok_or(invalid_status()));
-        let players = try!(val.get("players").ok_or(invalid_status()));
+        let version = val.get("version").ok_or(invalid_status())?;
+        let players = val.get("players").ok_or(invalid_status())?;
 
         Ok((Status {
             version: StatusVersion {
-                name: try!(version.get("name").and_then(Value::as_str).ok_or(invalid_status()))
+                name: version.get("name").and_then(Value::as_str).ok_or(invalid_status())?
                           .to_owned(),
-                protocol: try!(version.get("protocol")
+                protocol: version.get("protocol")
                                       .and_then(Value::as_i64)
-                                      .ok_or(invalid_status())) as i32,
+                                      .ok_or(invalid_status())? as i32,
             },
             players: StatusPlayers {
-                max: try!(players.get("max")
+                max: players.get("max")
                                  .and_then(Value::as_i64)
-                                 .ok_or(invalid_status())) as i32,
-                online: try!(players.get("online")
+                                 .ok_or(invalid_status())? as i32,
+                online: players.get("online")
                                     .and_then(Value::as_i64)
-                                    .ok_or(invalid_status())) as i32,
+                                    .ok_or(invalid_status())? as i32,
                 sample: Vec::new(), /* TODO */
             },
-            description: format::Component::from_value(try!(val.get("description")
-                                                               .ok_or(invalid_status()))),
+            description: format::Component::from_value(val.get("description")
+                                                               .ok_or(invalid_status())?),
             favicon: val.get("favicon").and_then(Value::as_str).map(|v| v.to_owned()),
         },
             ping))
@@ -966,7 +966,7 @@ impl Read for Conn {
         match self.cipher.as_mut() {
             Option::None => self.stream.read(buf),
             Option::Some(cipher) => {
-                let ret = try!(self.stream.read(buf));
+                let ret = self.stream.read(buf)?;
                 cipher.decrypt(&mut buf[..ret]);
 
                 Ok(ret)
@@ -988,7 +988,7 @@ impl Write for Conn {
 
                 cipher.encrypt(&mut data);
 
-                try!(self.stream.write_all(&data));
+                self.stream.write_all(&data)?;
                 Ok(buf.len())
             }
         }
diff --git a/src/protocol/mojang.rs b/src/protocol/mojang.rs
index d546363..a0c7704 100644
--- a/src/protocol/mojang.rs
+++ b/src/protocol/mojang.rs
@@ -38,7 +38,7 @@ impl Profile {
                 "name": "Minecraft",
                 "version": 1
             }});
-        let req = try!(serde_json::to_string(&req_msg));
+        let req = serde_json::to_string(&req_msg)?;
 
         let client = reqwest::Client::new();
         let res = client.post(LOGIN_URL)
@@ -46,7 +46,7 @@ impl Profile {
             .body(req)
             .send()?;
 
-        let ret: serde_json::Value = try!(serde_json::from_reader(res));
+        let ret: serde_json::Value = serde_json::from_reader(res)?;
         if let Some(error) = ret.get("error").and_then(|v| v.as_str()) {
             return Err(super::Error::Err(format!(
                 "{}: {}",
@@ -66,7 +66,7 @@ impl Profile {
             "accessToken": self.access_token.clone(),
             "clientToken": token
             });
-        let req = try!(serde_json::to_string(&req_msg));
+        let req = serde_json::to_string(&req_msg)?;
 
         let client = reqwest::Client::new();
         let res = client.post(VALIDATE_URL)
@@ -75,14 +75,14 @@ impl Profile {
             .send()?;
 
         if res.status() != reqwest::StatusCode::NO_CONTENT {
-            let req = try!(serde_json::to_string(&req_msg)); // TODO: fix parsing twice to avoid move
+            let req = serde_json::to_string(&req_msg)?; // TODO: fix parsing twice to avoid move
             // Refresh needed
             let res = client.post(REFRESH_URL)
                 .header(reqwest::header::CONTENT_TYPE, "application/json")
                 .body(req)
                 .send()?;
 
-            let ret: serde_json::Value = try!(serde_json::from_reader(res));
+            let ret: serde_json::Value = serde_json::from_reader(res)?;
             if let Some(error) = ret.get("error").and_then(|v| v.as_str()) {
                 return Err(super::Error::Err(format!(
                     "{}: {}",
diff --git a/src/protocol/packet.rs b/src/protocol/packet.rs
index fb4613f..6e1a943 100644
--- a/src/protocol/packet.rs
+++ b/src/protocol/packet.rs
@@ -953,13 +953,13 @@ pub struct Statistic {
 impl Serializable for Statistic {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
         Ok(Statistic {
-            name: try!(Serializable::read_from(buf)),
-            value: try!(Serializable::read_from(buf)),
+            name: Serializable::read_from(buf)?,
+            value: Serializable::read_from(buf)?,
         })
     }
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(self.name.write_to(buf));
+        self.name.write_to(buf)?;
         self.value.write_to(buf)
     }
 }
@@ -974,15 +974,15 @@ pub struct BlockChangeRecord {
 impl Serializable for BlockChangeRecord {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
         Ok(BlockChangeRecord {
-            xz: try!(Serializable::read_from(buf)),
-            y: try!(Serializable::read_from(buf)),
-            block_id: try!(Serializable::read_from(buf)),
+            xz: Serializable::read_from(buf)?,
+            y: Serializable::read_from(buf)?,
+            block_id: Serializable::read_from(buf)?,
         })
     }
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(self.xz.write_to(buf));
-        try!(self.y.write_to(buf));
+        self.xz.write_to(buf)?;
+        self.y.write_to(buf)?;
         self.block_id.write_to(buf)
     }
 }
@@ -997,15 +997,15 @@ pub struct ExplosionRecord {
 impl Serializable for ExplosionRecord {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
         Ok(ExplosionRecord {
-            x: try!(Serializable::read_from(buf)),
-            y: try!(Serializable::read_from(buf)),
-            z: try!(Serializable::read_from(buf)),
+            x: Serializable::read_from(buf)?,
+            y: Serializable::read_from(buf)?,
+            z: Serializable::read_from(buf)?,
         })
     }
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(self.x.write_to(buf));
-        try!(self.y.write_to(buf));
+        self.x.write_to(buf)?;
+        self.y.write_to(buf)?;
         self.z.write_to(buf)
     }
 }
@@ -1020,15 +1020,15 @@ pub struct MapIcon {
 impl Serializable for MapIcon {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
         Ok(MapIcon {
-            direction_type: try!(Serializable::read_from(buf)),
-            x: try!(Serializable::read_from(buf)),
-            z: try!(Serializable::read_from(buf)),
+            direction_type: Serializable::read_from(buf)?,
+            x: Serializable::read_from(buf)?,
+            z: Serializable::read_from(buf)?,
         })
     }
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(self.direction_type.write_to(buf));
-        try!(self.x.write_to(buf));
+        self.direction_type.write_to(buf)?;
+        self.x.write_to(buf)?;
         self.z.write_to(buf)
     }
 }
@@ -1053,15 +1053,15 @@ pub struct EntityProperty {
 impl Serializable for EntityProperty {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
         Ok(EntityProperty {
-            key: try!(Serializable::read_from(buf)),
-            value: try!(Serializable::read_from(buf)),
-            modifiers: try!(Serializable::read_from(buf)),
+            key: Serializable::read_from(buf)?,
+            value: Serializable::read_from(buf)?,
+            modifiers: Serializable::read_from(buf)?,
         })
     }
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(self.key.write_to(buf));
-        try!(self.value.write_to(buf));
+        self.key.write_to(buf)?;
+        self.value.write_to(buf)?;
         self.modifiers.write_to(buf)
     }
 }
@@ -1076,15 +1076,15 @@ pub struct PropertyModifier {
 impl Serializable for PropertyModifier {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
         Ok(PropertyModifier {
-            uuid: try!(Serializable::read_from(buf)),
-            amount: try!(Serializable::read_from(buf)),
-            operation: try!(Serializable::read_from(buf)),
+            uuid: Serializable::read_from(buf)?,
+            amount: Serializable::read_from(buf)?,
+            operation: Serializable::read_from(buf)?,
         })
     }
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
-        try!(self.uuid.write_to(buf));
-        try!(self.amount.write_to(buf));
+        self.uuid.write_to(buf)?;
+        self.amount.write_to(buf)?;
         self.operation.write_to(buf)
     }
 }
@@ -1098,25 +1098,25 @@ pub struct PlayerInfoData {
 impl Serializable for PlayerInfoData {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
         let mut m = PlayerInfoData {
-            action: try!(Serializable::read_from(buf)),
+            action: Serializable::read_from(buf)?,
             players: Vec::new(),
         };
-        let len = try!(VarInt::read_from(buf));
+        let len = VarInt::read_from(buf)?;
         for _ in 0..len.0 {
-            let uuid = try!(UUID::read_from(buf));
+            let uuid = UUID::read_from(buf)?;
             match m.action.0 {
                 0 => {
-                    let name = try!(String::read_from(buf));
+                    let name = String::read_from(buf)?;
                     let mut props = Vec::new();
-                    let plen = try!(VarInt::read_from(buf)).0;
+                    let plen = VarInt::read_from(buf)?.0;
                     for _ in 0..plen {
                         let mut prop = PlayerProperty {
-                            name: try!(String::read_from(buf)),
-                            value: try!(String::read_from(buf)),
+                            name: String::read_from(buf)?,
+                            value: String::read_from(buf)?,
                             signature: Default::default(),
                         };
-                        if try!(bool::read_from(buf)) {
-                            prop.signature = Some(try!(String::read_from(buf)));
+                        if bool::read_from(buf)? {
+                            prop.signature = Some(String::read_from(buf)?);
                         }
                         props.push(prop);
                     }
@@ -1124,11 +1124,11 @@ impl Serializable for PlayerInfoData {
                         uuid: uuid,
                         name: name,
                         properties: props,
-                        gamemode: try!(Serializable::read_from(buf)),
-                        ping: try!(Serializable::read_from(buf)),
+                        gamemode: Serializable::read_from(buf)?,
+                        ping: Serializable::read_from(buf)?,
                         display: {
-                            if try!(bool::read_from(buf)) {
-                                Some(try!(Serializable::read_from(buf)))
+                            if bool::read_from(buf)? {
+                                Some(Serializable::read_from(buf)?)
                             } else {
                                 None
                             }
@@ -1139,21 +1139,21 @@ impl Serializable for PlayerInfoData {
                 1 => {
                     m.players.push(PlayerDetail::UpdateGamemode {
                         uuid: uuid,
-                        gamemode: try!(Serializable::read_from(buf)),
+                        gamemode: Serializable::read_from(buf)?,
                     })
                 }
                 2 => {
                     m.players.push(PlayerDetail::UpdateLatency {
                         uuid: uuid,
-                        ping: try!(Serializable::read_from(buf)),
+                        ping: Serializable::read_from(buf)?,
                     })
                 }
                 3 => {
                     m.players.push(PlayerDetail::UpdateDisplayName {
                         uuid: uuid,
                         display: {
-                            if try!(bool::read_from(buf)) {
-                                Some(try!(Serializable::read_from(buf)))
+                            if bool::read_from(buf)? {
+                                Some(Serializable::read_from(buf)?)
                             } else {
                                 None
                             }
diff --git a/src/render/mod.rs b/src/render/mod.rs
index e82cd77..06482dc 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -863,12 +863,12 @@ impl TextureManager {
         use std::io::{Error, ErrorKind};
         let path = format!("skin-cache/{}/{}.png", &hash[..2], hash);
         let cache_path = Path::new(&path);
-        try!(fs::create_dir_all(cache_path.parent().unwrap()));
+        fs::create_dir_all(cache_path.parent().unwrap())?;
         let mut buf = vec![];
         if fs::metadata(cache_path).is_ok() {
             // We have a cached image
-            let mut file = try!(fs::File::open(cache_path));
-            try!(file.read_to_end(&mut buf));
+            let mut file = fs::File::open(cache_path)?;
+            file.read_to_end(&mut buf)?;
         } else {
             // Need to download it
             let url = &format!("http://textures.minecraft.net/texture/{}", hash);
@@ -888,8 +888,8 @@ impl TextureManager {
             }
 
             // Save to cache
-            let mut file = try!(fs::File::create(cache_path));
-            try!(file.write_all(&buf));
+            let mut file = fs::File::create(cache_path)?;
+            file.write_all(&buf)?;
         }
         let mut img = match image::load_from_memory(&buf) {
             Ok(val) => val,
diff --git a/src/resources.rs b/src/resources.rs
index a9b9cfb..76f8440 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -496,7 +496,7 @@ struct ProgressRead<'a, T> {
 
 impl <'a, T: io::Read> io::Read for ProgressRead<'a, T> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let size = try!(self.read.read(buf));
+        let size = self.read.read(buf)?;
         Manager::add_task_progress(self.progress, &self.task_name, &self.task_file, size as u64);
         Ok(size)
     }
diff --git a/src/server/mod.rs b/src/server/mod.rs
index 3cc1181..4e25914 100644
--- a/src/server/mod.rs
+++ b/src/server/mod.rs
@@ -103,24 +103,24 @@ macro_rules! handle_packet {
 impl Server {
 
     pub fn connect(resources: Arc<RwLock<resources::Manager>>, profile: mojang::Profile, address: &str) -> Result<Server, protocol::Error> {
-        let mut conn = try!(protocol::Conn::new(address));
+        let mut conn = protocol::Conn::new(address)?;
 
         let host = conn.host.clone();
         let port = conn.port;
-        try!(conn.write_packet(protocol::packet::handshake::serverbound::Handshake {
+        conn.write_packet(protocol::packet::handshake::serverbound::Handshake {
              protocol_version: protocol::VarInt(protocol::SUPPORTED_PROTOCOL),
              host: host,
              port: port,
              next: protocol::VarInt(2),
-         }));
+         })?;
         conn.state = protocol::State::Login;
-        try!(conn.write_packet(protocol::packet::login::serverbound::LoginStart {
+        conn.write_packet(protocol::packet::login::serverbound::LoginStart {
             username: profile.username.clone(),
-        }));
+        })?;
 
         let packet;
         loop {
-            match try!(conn.read_packet()) {
+            match conn.read_packet()? {
                 protocol::packet::Packet::SetInitialCompression(val) => {
                     conn.set_compresssion(val.threshold.0);
                 },
@@ -156,12 +156,12 @@ impl Server {
         println!("new shared_e({:}) = {:?}", shared_e.len(), &shared_e);
         println!("new token_e({:}) = {:?}", token_e.len(), &token_e);
 
-        try!(profile.join_server(&packet.server_id, &shared, &packet.public_key.data));
+        profile.join_server(&packet.server_id, &shared, &packet.public_key.data)?;
 
-        try!(conn.write_packet(protocol::packet::login::serverbound::EncryptionResponse {
+        conn.write_packet(protocol::packet::login::serverbound::EncryptionResponse {
             shared_secret: protocol::LenPrefixedBytes::new(shared_e),
             verify_token: protocol::LenPrefixedBytes::new(token_e),
-        }));
+        })?;
 
         let mut read = conn.clone();
         let mut write = conn.clone();
@@ -171,7 +171,7 @@ impl Server {
 
         let uuid;
         loop {
-           match try!(read.read_packet()) {
+           match read.read_packet()? {
                protocol::packet::Packet::SetInitialCompression(val) => {
                    read.set_compresssion(val.threshold.0);
                    write.set_compresssion(val.threshold.0);
diff --git a/src/types/metadata.rs b/src/types/metadata.rs
index 7616266..d59ba51 100644
--- a/src/types/metadata.rs
+++ b/src/types/metadata.rs
@@ -64,40 +64,40 @@ impl Serializable for Metadata {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, protocol::Error> {
         let mut m = Metadata::new();
         loop {
-            let index = try!(u8::read_from(buf)) as i32;
+            let index = u8::read_from(buf)? as i32;
             if index == 0xFF {
                 break;
             }
-            let ty = try!(u8::read_from(buf));
+            let ty = u8::read_from(buf)?;
             match ty {
-                0 => m.put_raw(index, try!(i8::read_from(buf))),
-                1 => m.put_raw(index, try!(protocol::VarInt::read_from(buf)).0),
-                2 => m.put_raw(index, try!(f32::read_from(buf))),
-                3 => m.put_raw(index, try!(String::read_from(buf))),
-                4 => m.put_raw(index, try!(format::Component::read_from(buf))),
-                5 => m.put_raw(index, try!(Option::<item::Stack>::read_from(buf))),
-                6 => m.put_raw(index, try!(bool::read_from(buf))),
+                0 => m.put_raw(index, i8::read_from(buf)?),
+                1 => m.put_raw(index, protocol::VarInt::read_from(buf)?.0),
+                2 => m.put_raw(index, f32::read_from(buf)?),
+                3 => m.put_raw(index, String::read_from(buf)?),
+                4 => m.put_raw(index, format::Component::read_from(buf)?),
+                5 => m.put_raw(index, Option::<item::Stack>::read_from(buf)?),
+                6 => m.put_raw(index, bool::read_from(buf)?),
                 7 => m.put_raw(index,
-                               [try!(f32::read_from(buf)),
-                                try!(f32::read_from(buf)),
-                                try!(f32::read_from(buf))]),
-                8 => m.put_raw(index, try!(Position::read_from(buf))),
+                               [f32::read_from(buf)?,
+                                f32::read_from(buf)?,
+                                f32::read_from(buf)?]),
+                8 => m.put_raw(index, Position::read_from(buf)?),
                 9 => {
-                    if try!(bool::read_from(buf)) {
-                        m.put_raw(index, try!(Option::<Position>::read_from(buf)));
+                    if bool::read_from(buf)? {
+                        m.put_raw(index, Option::<Position>::read_from(buf)?);
                     } else {
                         m.put_raw::<Option<Position>>(index, None);
                     }
                 }
-                10 => m.put_raw(index, try!(protocol::VarInt::read_from(buf))),
+                10 => m.put_raw(index, protocol::VarInt::read_from(buf)?),
                 11 => {
-                    if try!(bool::read_from(buf)) {
-                        m.put_raw(index, try!(Option::<protocol::UUID>::read_from(buf)));
+                    if bool::read_from(buf)? {
+                        m.put_raw(index, Option::<protocol::UUID>::read_from(buf)?);
                     } else {
                         m.put_raw::<Option<protocol::UUID>>(index, None);
                     }
                 }
-                12 => m.put_raw(index, try!(protocol::VarInt::read_from(buf)).0 as u16),
+                12 => m.put_raw(index, protocol::VarInt::read_from(buf)?.0 as u16),
                 _ => return Err(protocol::Error::Err("unknown metadata type".to_owned())),
             }
         }
@@ -106,76 +106,76 @@ impl Serializable for Metadata {
 
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), protocol::Error> {
         for (k, v) in &self.map {
-            try!((*k as u8).write_to(buf));
+            (*k as u8).write_to(buf)?;
             match *v {
                 Value::Byte(ref val) => {
-                    try!(u8::write_to(&0, buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&0, buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::Int(ref val) => {
-                    try!(u8::write_to(&1, buf));
-                    try!(protocol::VarInt(*val).write_to(buf));
+                    u8::write_to(&1, buf)?;
+                    protocol::VarInt(*val).write_to(buf)?;
                 }
                 Value::Float(ref val) => {
-                    try!(u8::write_to(&2, buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&2, buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::String(ref val) => {
-                    try!(u8::write_to(&3, buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&3, buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::FormatComponent(ref val) => {
-                    try!(u8::write_to(&4, buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&4, buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::OptionalItemStack(ref val) => {
-                    try!(u8::write_to(&5, buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&5, buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::Bool(ref val) => {
-                    try!(u8::write_to(&6, buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&6, buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::Vector(ref val) => {
-                    try!(u8::write_to(&7, buf));
-                    try!(val[0].write_to(buf));
-                    try!(val[1].write_to(buf));
-                    try!(val[2].write_to(buf));
+                    u8::write_to(&7, buf)?;
+                    val[0].write_to(buf)?;
+                    val[1].write_to(buf)?;
+                    val[2].write_to(buf)?;
                 }
                 Value::Position(ref val) => {
-                    try!(u8::write_to(&8, buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&8, buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::OptionalPosition(ref val) => {
-                    try!(u8::write_to(&9, buf));
-                    try!(val.is_some().write_to(buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&9, buf)?;
+                    val.is_some().write_to(buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::Direction(ref val) => {
-                    try!(u8::write_to(&10, buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&10, buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::OptionalUUID(ref val) => {
-                    try!(u8::write_to(&11, buf));
-                    try!(val.is_some().write_to(buf));
-                    try!(val.write_to(buf));
+                    u8::write_to(&11, buf)?;
+                    val.is_some().write_to(buf)?;
+                    val.write_to(buf)?;
                 }
                 Value::Block(ref val) => {
-                    try!(u8::write_to(&11, buf));
-                    try!(protocol::VarInt(*val as i32).write_to(buf));
+                    u8::write_to(&11, buf)?;
+                    protocol::VarInt(*val as i32).write_to(buf)?;
                 }
             }
         }
-        try!(u8::write_to(&0xFF, buf));
+        u8::write_to(&0xFF, buf)?;
         Ok(())
     }
 }
 
 impl fmt::Debug for Metadata {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "Metadata[ "));
+        write!(f, "Metadata[ ")?;
         for (k, v) in &self.map {
-            try!(write!(f, "{:?}={:?}, ", k, v));
+            write!(f, "{:?}={:?}, ", k, v)?;
         }
         write!(f, "]")
     }
diff --git a/src/world/mod.rs b/src/world/mod.rs
index 0bf9c44..c2107d3 100644
--- a/src/world/mod.rs
+++ b/src/world/mod.rs
@@ -580,20 +580,20 @@ impl World {
                 let section = chunk.sections[i as usize].as_mut().unwrap();
                 section.dirty = true;
 
-                let mut bit_size = try!(data.read_u8());
+                let mut bit_size = data.read_u8()?;
                 let mut mappings: HashMap<usize, block::Block, BuildHasherDefault<FNVHash>> = HashMap::with_hasher(BuildHasherDefault::default());
                 if bit_size == 0 {
                     bit_size = 13;
                 } else {
-                    let count = try!(VarInt::read_from(&mut data)).0;
+                    let count = VarInt::read_from(&mut data)?.0;
                     for i in 0 .. count {
-                        let id = try!(VarInt::read_from(&mut data)).0;
+                        let id = VarInt::read_from(&mut data)?.0;
                         let bl = block::Block::by_vanilla_id(id as usize);
                         mappings.insert(i as usize, bl);
                     }
                 }
 
-                let bits = try!(LenPrefixed::<VarInt, u64>::read_from(&mut data)).data;
+                let bits = LenPrefixed::<VarInt, u64>::read_from(&mut data)?.data;
                 let m = bit::Map::from_raw(bits, bit_size as usize);
 
                 for bi in 0 .. 4096 {
@@ -614,12 +614,12 @@ impl World {
                     }
                 }
 
-                try!(data.read_exact(&mut section.block_light.data));
-                try!(data.read_exact(&mut section.sky_light.data));
+                data.read_exact(&mut section.block_light.data)?;
+                data.read_exact(&mut section.sky_light.data)?;
             }
 
             if new {
-                try!(data.read_exact(&mut chunk.biomes));
+                data.read_exact(&mut chunk.biomes)?;
             }
 
             chunk.calculate_heightmap();