diff --git a/src/de.rs b/src/de.rs
index 0410c25..1b9c74c 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -15,6 +15,7 @@ impl<R: Read> Deserializer<R> {
         Deserializer { reader: reader }
     }
 
+    #[inline]
     fn read_string(&mut self) -> Result<String> {
         let len = try!(Deserialize::deserialize(&mut *self));
         let mut buffer = Vec::new();
@@ -46,6 +47,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         Err(Error)
     }
 
+    #[inline]
     fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
@@ -79,12 +81,14 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         visitor.visit_i8(try!(self.reader.read_i8()))
     }
 
+    #[inline]
     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
         visitor.visit_unit()
     }
 
+    #[inline]
     fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
@@ -105,18 +109,21 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         visitor.visit_char(res)
     }
 
+    #[inline]
     fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
         visitor.visit_str(&try!(self.read_string()))
     }
 
+    #[inline]
     fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
         visitor.visit_string(try!(self.read_string()))
     }
 
+    #[inline]
     fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
@@ -126,12 +133,14 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         visitor.visit_byte_buf(buf)
     }
 
+    #[inline]
     fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
         self.deserialize_bytes(visitor)
     }
 
+    #[inline]
     fn deserialize_enum<V>(self,
                            _enum: &'static str,
                            _variants: &'static [&'static str],
@@ -142,18 +151,21 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         visitor.visit_enum(self)
     }
 
+    #[inline]
     fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
         visitor.visit_seq(self)
     }
 
+    #[inline]
     fn deserialize_seq_fixed_size<V>(self, _: usize, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
         visitor.visit_seq(self)
     }
 
+    #[inline]
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
@@ -164,6 +176,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         }
     }
 
+    #[inline]
     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
@@ -175,6 +188,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         impl<'a, R: Read> de::SeqVisitor for SeqVisitor<'a, R> {
             type Error = Error;
 
+            #[inline]
             fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
                 where T: DeserializeSeed
             {
@@ -195,6 +209,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         })
     }
 
+    #[inline]
     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
@@ -206,6 +221,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         impl<'a, R: Read> de::MapVisitor for MapVisitor<'a, R> {
             type Error = Error;
 
+            #[inline]
             fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
                 where K: DeserializeSeed
             {
@@ -217,6 +233,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
                 }
             }
 
+            #[inline]
             fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
                 where V: DeserializeSeed
             {
@@ -232,6 +249,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         })
     }
 
+    #[inline]
     fn deserialize_struct<V>(self,
                              _name: &str,
                              _fields: &'static [&'static str],
@@ -249,12 +267,14 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         Err(Error)
     }
 
+    #[inline]
     fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
         visitor.visit_newtype_struct(self)
     }
 
+    #[inline]
     fn deserialize_unit_struct<V>(self,
                                   _name: &'static str,
                                   visitor: V)
@@ -264,6 +284,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
         visitor.visit_unit()
     }
 
+    #[inline]
     fn deserialize_tuple_struct<V>(self,
                                    _name: &'static str,
                                    _len: usize,
@@ -286,6 +307,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
 impl<R: Read> SeqVisitor for Deserializer<R> {
     type Error = Error;
 
+    #[inline]
     fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
         where T: DeserializeSeed
     {
@@ -297,6 +319,7 @@ impl<'a, R: Read> EnumVisitor for &'a mut Deserializer<R> {
     type Error = Error;
     type Variant = Self;
 
+    #[inline]
     fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
         where V: DeserializeSeed
     {
@@ -310,22 +333,26 @@ impl<'a, R: Read> EnumVisitor for &'a mut Deserializer<R> {
 impl<'a, R: Read> VariantVisitor for &'a mut Deserializer<R> {
     type Error = Error;
 
+    #[inline]
     fn visit_unit(self) -> Result<()> {
         Ok(())
     }
 
+    #[inline]
     fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value>
         where T: DeserializeSeed
     {
         seed.deserialize(self)
     }
 
+    #[inline]
     fn visit_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
         where V: Visitor
     {
         visitor.visit_seq(self)
     }
 
+    #[inline]
     fn visit_struct<V>(self,
                        _fields: &'static [&'static str],
                        visitor: V)
@@ -356,6 +383,7 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [
     4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF
 ];
 
+#[inline]
 fn utf8_char_width(b: u8) -> usize {
     UTF8_CHAR_WIDTH[b as usize] as usize
 }
diff --git a/src/ser.rs b/src/ser.rs
index 88e7494..3ac04d1 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -15,6 +15,7 @@ impl<W> Serializer<W>
         Serializer { writer: w }
     }
 
+    #[inline]
     fn serialize_enum_tag(&mut self, tag: usize) -> Result<()> {
         serde::Serializer::serialize_u32(self, tag as u32)
     }
@@ -34,76 +35,94 @@ impl<'a, W> serde::Serializer for &'a mut Serializer<W>
     type SerializeStruct = Self;
     type SerializeStructVariant = Self;
 
+    #[inline]
     fn serialize_unit(self) -> Result<()> {
         Ok(())
     }
 
+    #[inline]
     fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
         Ok(())
     }
 
+    #[inline]
     fn serialize_bool(self, v: bool) -> Result<()> {
         self.writer.write_u8(if v { 1 } else { 0 }).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_u8(self, v: u8) -> Result<()> {
         self.writer.write_u8(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_u16(self, v: u16) -> Result<()> {
         self.writer.write_u16::<NativeEndian>(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_u32(self, v: u32) -> Result<()> {
         self.writer.write_u32::<NativeEndian>(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_u64(self, v: u64) -> Result<()> {
         self.writer.write_u64::<NativeEndian>(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_i8(self, v: i8) -> Result<()> {
         self.writer.write_i8(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_i16(self, v: i16) -> Result<()> {
         self.writer.write_i16::<NativeEndian>(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_i32(self, v: i32) -> Result<()> {
         self.writer.write_i32::<NativeEndian>(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_i64(self, v: i64) -> Result<()> {
         self.writer.write_i64::<NativeEndian>(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_f32(self, v: f32) -> Result<()> {
         self.writer.write_f32::<NativeEndian>(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_f64(self, v: f64) -> Result<()> {
         self.writer.write_f64::<NativeEndian>(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_str(self, v: &str) -> Result<()> {
         try!(self.serialize_u64(v.len() as u64));
         self.writer.write_all(v.as_bytes()).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_char(self, c: char) -> Result<()> {
         self.writer.write_all(encode_utf8(c).as_slice()).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_bytes(self, v: &[u8]) -> Result<()> {
         try!(self.serialize_u64(v.len() as u64));
         self.writer.write_all(v).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_none(self) -> Result<()> {
         self.writer.write_u8(0).map_err(From::from)
     }
 
+    #[inline]
     fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
         where T: serde::Serialize
     {
@@ -111,24 +130,29 @@ impl<'a, W> serde::Serializer for &'a mut Serializer<W>
         v.serialize(self)
     }
 
+    #[inline]
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
         let len = len.expect("do not know how to serialize a sequence with no length");
         try!(self.serialize_u64(len as u64));
         Ok(self)
     }
 
+    #[inline]
     fn serialize_seq_fixed_size(self, _len: usize) -> Result<Self::SerializeSeq> {
         Ok(self)
     }
 
+    #[inline]
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
         Ok(self)
     }
 
+    #[inline]
     fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
         Ok(self)
     }
 
+    #[inline]
     fn serialize_tuple_variant(self,
                                _name: &'static str,
                                variant_index: usize,
@@ -139,16 +163,19 @@ impl<'a, W> serde::Serializer for &'a mut Serializer<W>
         Ok(self)
     }
 
+    #[inline]
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
         let len = len.expect("do not know how to serialize a map with no length");
         try!(self.serialize_u64(len as u64));
         Ok(self)
     }
 
+    #[inline]
     fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
         Ok(self)
     }
 
+    #[inline]
     fn serialize_struct_variant(self,
                                 _name: &'static str,
                                 variant_index: usize,
@@ -159,12 +186,14 @@ impl<'a, W> serde::Serializer for &'a mut Serializer<W>
         Ok(self)
     }
 
+    #[inline]
     fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<()>
         where T: serde::ser::Serialize
     {
         value.serialize(self)
     }
 
+    #[inline]
     fn serialize_newtype_variant<T: ?Sized>(self,
                                     _name: &'static str,
                                     variant_index: usize,
@@ -177,6 +206,7 @@ impl<'a, W> serde::Serializer for &'a mut Serializer<W>
         value.serialize(self)
     }
 
+    #[inline]
     fn serialize_unit_variant(self,
                               _name: &'static str,
                               variant_index: usize,
@@ -192,12 +222,14 @@ impl<'a, W> SerializeSeq for &'a mut Serializer<W>
     type Ok = ();
     type Error = Error;
 
+    #[inline]
     fn serialize_element<V: ?Sized>(&mut self, value: &V) -> Result<()>
         where V: serde::Serialize
     {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> Result<()> {
         Ok(())
     }
@@ -209,12 +241,14 @@ impl<'a, W> SerializeTuple for &'a mut Serializer<W>
     type Ok = ();
     type Error = Error;
 
+    #[inline]
     fn serialize_element<V: ?Sized>(&mut self, value: &V) -> Result<()>
         where V: serde::Serialize
     {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> Result<()> {
         Ok(())
     }
@@ -226,12 +260,14 @@ impl<'a, W> SerializeTupleStruct for &'a mut Serializer<W>
     type Ok = ();
     type Error = Error;
 
+    #[inline]
     fn serialize_field<V: ?Sized>(&mut self, value: &V) -> Result<()>
         where V: serde::Serialize
     {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> Result<()> {
         Ok(())
     }
@@ -243,12 +279,14 @@ impl<'a, W> SerializeTupleVariant for &'a mut Serializer<W>
     type Ok = ();
     type Error = Error;
 
+    #[inline]
     fn serialize_field<V: ?Sized>(&mut self, value: &V) -> Result<()>
         where V: serde::Serialize
     {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> Result<()> {
         Ok(())
     }
@@ -260,18 +298,21 @@ impl<'a, W> SerializeMap for &'a mut Serializer<W>
     type Ok = ();
     type Error = Error;
 
+    #[inline]
     fn serialize_key<K: ?Sized>(&mut self, key: &K) -> Result<()>
         where K: serde::Serialize
     {
         key.serialize(&mut **self)
     }
 
+    #[inline]
     fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
         where V: serde::Serialize
     {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> Result<()> {
         Ok(())
     }
@@ -283,12 +324,14 @@ impl<'a, W> SerializeStruct for &'a mut Serializer<W>
     type Ok = ();
     type Error = Error;
 
+    #[inline]
     fn serialize_field<V: ?Sized>(&mut self, _key: &'static str, value: &V) -> Result<()>
         where V: serde::Serialize
     {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> Result<()> {
         Ok(())
     }
@@ -300,17 +343,20 @@ impl<'a, W> SerializeStructVariant for &'a mut Serializer<W>
     type Ok = ();
     type Error = Error;
 
+    #[inline]
     fn serialize_field<V: ?Sized>(&mut self, _key: &'static str, value: &V) -> Result<()>
         where V: serde::Serialize
     {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> Result<()> {
         Ok(())
     }
 }
 
+#[inline]
 fn encode_utf8(c: char) -> EncodeUtf8 {
     const TAG_CONT: u8 = 0b1000_0000;
     const TAG_TWO_B: u8 = 0b1100_0000;
@@ -353,6 +399,7 @@ struct EncodeUtf8 {
 }
 
 impl EncodeUtf8 {
+    #[inline]
     fn as_slice(&self) -> &[u8] {
         &self.buf[self.pos..]
     }