diff --git a/Cargo.toml b/Cargo.toml
index ffaaeee..fcc65ab 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bincode"
-version = "0.4.1"
+version = "0.5.0"
 authors = ["Ty Overby <ty@pre-alpha.com>", "Francesco Mazzoli <f@mazzo.li>"]
 
 repository = "https://github.com/TyOverby/bincode"
@@ -14,7 +14,7 @@ description = "A binary serialization / deserialization strategy and implementat
 rustc-serialize = "0.3.*"
 byteorder = "0.4.*"
 num = "0.1.*"
-serde = "0.6.*"
+serde = "0.7.*"
 
 [dev-dependencies]
-serde_macros = "0.6.*"
+serde_macros = "0.7.*"
diff --git a/src/serde/reader.rs b/src/serde/reader.rs
index a8f4d5e..f0a957c 100644
--- a/src/serde/reader.rs
+++ b/src/serde/reader.rs
@@ -9,6 +9,7 @@ use byteorder::{BigEndian, ReadBytesExt};
 use num;
 use serde_crate as serde;
 use serde_crate::de::value::ValueDeserializer;
+use serde_crate::de::Deserializer as SerdeDeserializer;
 
 use ::SizeLimit;
 
@@ -46,10 +47,7 @@ pub enum DeserializeError {
     /// If decoding a message takes more than the provided size limit, this
     /// error is returned.
     SizeLimit,
-    SyntaxError(String),
-    EndOfStreamError,
-    UnknownFieldError,
-    MissingFieldError,
+    Serde(serde::de::value::Error)
 }
 
 impl Error for DeserializeError {
@@ -58,10 +56,8 @@ impl Error for DeserializeError {
             DeserializeError::IoError(ref err) => Error::description(err),
             DeserializeError::InvalidEncoding(ref ib) => ib.desc,
             DeserializeError::SizeLimit => "the size limit for decoding has been reached",
-            DeserializeError::SyntaxError(ref s) => &*s,
-            DeserializeError::EndOfStreamError => "Unexpected EOF while reading a multi-byte number",
-            DeserializeError::UnknownFieldError => "unknown field error",
-            DeserializeError::MissingFieldError => "missing field error",
+            DeserializeError::Serde(ref s) => s.description(),
+
         }
     }
 
@@ -70,10 +66,7 @@ impl Error for DeserializeError {
             DeserializeError::IoError(ref err) => err.cause(),
             DeserializeError::InvalidEncoding(_) => None,
             DeserializeError::SizeLimit => None,
-            DeserializeError::SyntaxError(_) => None,
-            DeserializeError::EndOfStreamError => None,
-            DeserializeError::UnknownFieldError => None,
-            DeserializeError::MissingFieldError => None,
+            DeserializeError::Serde(ref s) => s.cause(),
         }
     }
 }
@@ -88,23 +81,15 @@ impl From<ByteOrderError> for DeserializeError {
     fn from(err: ByteOrderError) -> DeserializeError {
         match err {
             ByteOrderError::Io(ioe) => DeserializeError::IoError(ioe),
-            ByteOrderError::UnexpectedEOF => DeserializeError::EndOfStreamError,
+            ByteOrderError::UnexpectedEOF => DeserializeError::Serde(
+                serde::de::value::Error::EndOfStream),
         }
     }
 }
 
 impl From<serde::de::value::Error> for DeserializeError {
     fn from(err: serde::de::value::Error) -> DeserializeError {
-        use serde_crate::de::value::Error;
-
-        match err {
-            Error::SyntaxError => DeserializeError::SyntaxError("syntax error".to_string()),
-            Error::EndOfStreamError => {
-                DeserializeError::EndOfStreamError
-            }
-            Error::UnknownFieldError(_) => DeserializeError::UnknownFieldError,
-            Error::MissingFieldError(_) => DeserializeError::MissingFieldError,
-        }
+        DeserializeError::Serde(err)
     }
 }
 
@@ -117,33 +102,19 @@ impl fmt::Display for DeserializeError {
                 write!(fmt, "InvalidEncoding: {}", ib),
             DeserializeError::SizeLimit =>
                 write!(fmt, "SizeLimit"),
-            DeserializeError::SyntaxError(ref d) =>
-                write!(fmt, "SyntaxError: {}", d),
-            DeserializeError::EndOfStreamError =>
-                write!(fmt, "EndOfStreamError"),
-            DeserializeError::UnknownFieldError =>
-                write!(fmt, "UnknownFieldError"),
-            DeserializeError::MissingFieldError =>
-                write!(fmt, "MissingFieldError"),
+            DeserializeError::Serde(ref s) =>
+                s.fmt(fmt),
         }
     }
 }
 
 impl serde::de::Error for DeserializeError {
-    fn syntax(desc: &str) -> DeserializeError {
-        DeserializeError::SyntaxError(desc.into())
+    fn custom<T: Into<String>>(desc: T) -> DeserializeError {
+        DeserializeError::Serde(serde::de::value::Error::Custom(desc.into()))
     }
 
     fn end_of_stream() -> DeserializeError {
-        DeserializeError::EndOfStreamError
-    }
-
-    fn unknown_field(_field: &str) -> DeserializeError {
-        DeserializeError::UnknownFieldError
-    }
-
-    fn missing_field(_field: &'static str) -> DeserializeError {
-        DeserializeError::MissingFieldError
+        DeserializeError::Serde(serde::de::value::Error::EndOfStream)
     }
 }
 
@@ -198,9 +169,9 @@ impl <'a, A> Deserializer<'a, A> {
 }
 
 macro_rules! impl_nums {
-    ($ty:ty, $visitor_method:ident, $reader_method:ident) => {
+    ($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => {
         #[inline]
-        fn $visitor_method<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+        fn $dser_method<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
             where V: serde::de::Visitor,
         {
             try!(self.read_type::<$ty>());
@@ -215,13 +186,14 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
     type Error = DeserializeError;
 
     #[inline]
-    fn visit<V>(&mut self, _visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize<V>(&mut self, _visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
-        Err(serde::de::Error::syntax("bincode does not support Deserializer::visit"))
+        let message = "bincode does not support Deserializer::deserialize";
+        Err(DeserializeError::Serde(serde::de::value::Error::Custom(message.into())))
     }
 
-    fn visit_bool<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_bool<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         let value: u8 = try!(serde::Deserialize::deserialize(self));
@@ -237,64 +209,63 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         }
     }
 
+    impl_nums!(u16, deserialize_u16, visit_u16, read_u16);
+    impl_nums!(u32, deserialize_u32, visit_u32, read_u32);
+    impl_nums!(u64, deserialize_u64, visit_u64, read_u64);
+    impl_nums!(i16, deserialize_i16, visit_i16, read_i16);
+    impl_nums!(i32, deserialize_i32, visit_i32, read_i32);
+    impl_nums!(i64, deserialize_i64, visit_i64, read_i64);
+    impl_nums!(f32, deserialize_f32, visit_f32, read_f32);
+    impl_nums!(f64, deserialize_f64, visit_f64, read_f64);
+
+
     #[inline]
-    fn visit_u8<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_u8<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         try!(self.read_type::<u8>());
         visitor.visit_u8(try!(self.reader.read_u8()))
     }
 
-    impl_nums!(u16, visit_u16, read_u16);
-    impl_nums!(u32, visit_u32, read_u32);
-    impl_nums!(u64, visit_u64, read_u64);
-
     #[inline]
-    fn visit_usize<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_usize<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         try!(self.read_type::<u64>());
         let value = try!(self.reader.read_u64::<BigEndian>());
         match num::cast(value) {
             Some(value) => visitor.visit_usize(value),
-            None => Err(serde::de::Error::syntax("expected usize")),
+            None => Err(DeserializeError::Serde(serde::de::value::Error::Custom("expected usize".into())))
         }
     }
 
     #[inline]
-    fn visit_i8<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_i8<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         try!(self.read_type::<i8>());
         visitor.visit_i8(try!(self.reader.read_i8()))
     }
 
-    impl_nums!(i16, visit_i16, read_i16);
-    impl_nums!(i32, visit_i32, read_i32);
-    impl_nums!(i64, visit_i64, read_i64);
-
     #[inline]
-    fn visit_isize<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_isize<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         try!(self.read_type::<i64>());
         let value = try!(self.reader.read_i64::<BigEndian>());
         match num::cast(value) {
             Some(value) => visitor.visit_isize(value),
-            None => Err(serde::de::Error::syntax("expected isize")),
+            None => Err(DeserializeError::Serde(serde::de::value::Error::Custom("expected isize".into()))),
         }
     }
 
-    impl_nums!(f32, visit_f32, read_f32);
-    impl_nums!(f64, visit_f64, read_f64);
-
-    fn visit_unit<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_unit<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         visitor.visit_unit()
     }
 
-    fn visit_char<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_char<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         use std::str;
@@ -333,7 +304,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         visitor.visit_char(res)
     }
 
-    fn visit_string<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_string<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         let len = try!(serde::Deserialize::deserialize(self));
@@ -351,7 +322,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         }
     }
 
-    fn visit_enum<V>(&mut self,
+    fn deserialize_enum<V>(&mut self,
                      _enum: &'static str,
                      _variants: &'static [&'static str],
                      mut visitor: V) -> Result<V::Value, Self::Error>
@@ -360,7 +331,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         visitor.visit(self)
     }
 
-    fn visit_tuple<V>(&mut self,
+    fn deserialize_tuple<V>(&mut self,
                       _len: usize,
                       mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
@@ -385,7 +356,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         visitor.visit_seq(TupleVisitor(self))
     }
 
-    fn visit_option<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_option<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         let value: u8 = try!(serde::de::Deserialize::deserialize(self));
@@ -399,7 +370,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         }
     }
 
-    fn visit_seq<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_seq<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         struct SeqVisitor<'a, 'b: 'a, R: Read + 'b> {
@@ -426,7 +397,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
                 if self.len == 0 {
                     Ok(())
                 } else {
-                    Err(serde::de::Error::syntax("expected end"))
+                    Err(DeserializeError::Serde(serde::de::value::Error::Custom("expected end".into())))
                 }
             }
         }
@@ -436,7 +407,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         visitor.visit_seq(SeqVisitor { deserializer: self, len: len })
     }
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+    fn deserialize_map<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         struct MapVisitor<'a, 'b: 'a, R: Read + 'b> {
@@ -470,7 +441,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
                 if self.len == 0 {
                     Ok(())
                 } else {
-                    Err(serde::de::Error::syntax("expected end"))
+                    Err(DeserializeError::Serde(serde::de::value::Error::Custom("expected end".into())))
                 }
             }
         }
@@ -480,16 +451,16 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         visitor.visit_map(MapVisitor { deserializer: self, len: len })
     }
 
-    fn visit_struct<V>(&mut self,
+    fn deserialize_struct<V>(&mut self,
                        _name: &str,
                        fields: &'static [&'static str],
                        visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
-        self.visit_tuple(fields.len(), visitor)
+        self.deserialize_tuple(fields.len(), visitor)
     }
 
-    fn visit_newtype_struct<V>(&mut self,
+    fn deserialize_newtype_struct<V>(&mut self,
                                _name: &str,
                                mut visitor: V) -> Result<V::Value, Self::Error>
         where V: serde::de::Visitor,
@@ -506,7 +477,8 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
     {
         let index: u32 = try!(serde::Deserialize::deserialize(self));
         let mut deserializer = (index as usize).into_deserializer();
-        Ok(try!(serde::Deserialize::deserialize(&mut deserializer)))
+        let attempt: Result<V, serde::de::value::Error> = serde::Deserialize::deserialize(&mut deserializer);
+        Ok(try!(attempt))
     }
 
     fn visit_unit(&mut self) -> Result<(), Self::Error> {
@@ -524,7 +496,7 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
                       visitor: V) -> Result<V::Value, Self::Error>
         where V: serde::de::Visitor,
     {
-        serde::de::Deserializer::visit_tuple(self, len, visitor)
+        serde::de::Deserializer::deserialize_tuple(self, len, visitor)
     }
 
     fn visit_struct<V>(&mut self,
@@ -532,7 +504,7 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
                        visitor: V) -> Result<V::Value, Self::Error>
         where V: serde::de::Visitor,
     {
-        serde::de::Deserializer::visit_tuple(self, fields.len(), visitor)
+        serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
     }
 }
 static UTF8_CHAR_WIDTH: [u8; 256] = [
diff --git a/src/serde/writer.rs b/src/serde/writer.rs
index 00c6474..3f8e71b 100644
--- a/src/serde/writer.rs
+++ b/src/serde/writer.rs
@@ -22,7 +22,9 @@ pub enum SerializeError {
     ///
     /// This error is returned before any bytes are written to the
     /// output `Writer`.
-    SizeLimit
+    SizeLimit,
+    /// A custom error message
+    Custom(String)
 }
 
 /// An Serializer that encodes values directly into a Writer.
@@ -42,11 +44,18 @@ fn wrap_io(err: ByteOrderError) -> SerializeError {
     }
 }
 
+impl serde::ser::Error for SerializeError {
+    fn custom<T: Into<String>>(msg: T) -> Self {
+        SerializeError::Custom(msg.into())
+    }
+}
+
 impl fmt::Display for SerializeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match *self {
             SerializeError::IoError(ref err) => write!(f, "IoError: {}", err),
-            SerializeError::SizeLimit => write!(f, "SizeLimit")
+            SerializeError::Custom(ref s) => write!(f, "Custom Error {}", s),
+            SerializeError::SizeLimit => write!(f, "SizeLimit"),
         }
     }
 }
@@ -55,14 +64,16 @@ impl Error for SerializeError {
     fn description(&self) -> &str {
         match *self {
             SerializeError::IoError(ref err) => Error::description(err),
-            SerializeError::SizeLimit => "the size limit for decoding has been reached"
+            SerializeError::SizeLimit => "the size limit for decoding has been reached",
+            SerializeError::Custom(_) => "a custom serialization error was reported",
         }
     }
 
     fn cause(&self) -> Option<&Error> {
         match *self {
-            SerializeError::IoError(ref err)     => err.cause(),
-            SerializeError::SizeLimit => None
+            SerializeError::IoError(ref err) => err.cause(),
+            SerializeError::SizeLimit => None,
+            SerializeError::Custom(_) => None,
         }
     }
 }
@@ -79,76 +90,76 @@ impl<'a, W: Write> Serializer<'a, W> {
             panic!("Variant tag doesn't fit in a u32")
         }
 
-        serde::Serializer::visit_u32(self, tag as u32)
+        serde::Serializer::serialize_u32(self, tag as u32)
     }
 }
 
 impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
     type Error = SerializeError;
 
-    fn visit_unit(&mut self) -> SerializeResult<()> { Ok(()) }
+    fn serialize_unit(&mut self) -> SerializeResult<()> { Ok(()) }
 
-    fn visit_bool(&mut self, v: bool) -> SerializeResult<()> {
+    fn serialize_bool(&mut self, v: bool) -> SerializeResult<()> {
         self.writer.write_u8(if v {1} else {0}).map_err(wrap_io)
     }
 
-    fn visit_u8(&mut self, v: u8) -> SerializeResult<()> {
+    fn serialize_u8(&mut self, v: u8) -> SerializeResult<()> {
         self.writer.write_u8(v).map_err(wrap_io)
     }
 
-    fn visit_u16(&mut self, v: u16) -> SerializeResult<()> {
+    fn serialize_u16(&mut self, v: u16) -> SerializeResult<()> {
         self.writer.write_u16::<BigEndian>(v).map_err(wrap_io)
     }
 
-    fn visit_u32(&mut self, v: u32) -> SerializeResult<()> {
+    fn serialize_u32(&mut self, v: u32) -> SerializeResult<()> {
         self.writer.write_u32::<BigEndian>(v).map_err(wrap_io)
     }
 
-    fn visit_u64(&mut self, v: u64) -> SerializeResult<()> {
+    fn serialize_u64(&mut self, v: u64) -> SerializeResult<()> {
         self.writer.write_u64::<BigEndian>(v).map_err(wrap_io)
     }
 
-    fn visit_i8(&mut self, v: i8) -> SerializeResult<()> {
+    fn serialize_i8(&mut self, v: i8) -> SerializeResult<()> {
         self.writer.write_i8(v).map_err(wrap_io)
     }
 
-    fn visit_i16(&mut self, v: i16) -> SerializeResult<()> {
+    fn serialize_i16(&mut self, v: i16) -> SerializeResult<()> {
         self.writer.write_i16::<BigEndian>(v).map_err(wrap_io)
     }
 
-    fn visit_i32(&mut self, v: i32) -> SerializeResult<()> {
+    fn serialize_i32(&mut self, v: i32) -> SerializeResult<()> {
         self.writer.write_i32::<BigEndian>(v).map_err(wrap_io)
     }
 
-    fn visit_i64(&mut self, v: i64) -> SerializeResult<()> {
+    fn serialize_i64(&mut self, v: i64) -> SerializeResult<()> {
         self.writer.write_i64::<BigEndian>(v).map_err(wrap_io)
     }
 
-    fn visit_f32(&mut self, v: f32) -> SerializeResult<()> {
+    fn serialize_f32(&mut self, v: f32) -> SerializeResult<()> {
         self.writer.write_f32::<BigEndian>(v).map_err(wrap_io)
     }
 
-    fn visit_f64(&mut self, v: f64) -> SerializeResult<()> {
+    fn serialize_f64(&mut self, v: f64) -> SerializeResult<()> {
         self.writer.write_f64::<BigEndian>(v).map_err(wrap_io)
     }
 
-    fn visit_str(&mut self, v: &str) -> SerializeResult<()> {
-        try!(self.visit_usize(v.len()));
+    fn serialize_str(&mut self, v: &str) -> SerializeResult<()> {
+        try!(self.serialize_usize(v.len()));
         self.writer.write_all(v.as_bytes()).map_err(SerializeError::IoError)
     }
 
-    fn visit_none(&mut self) -> SerializeResult<()> {
+    fn serialize_none(&mut self) -> SerializeResult<()> {
         self.writer.write_u8(0).map_err(wrap_io)
     }
 
-    fn visit_some<T>(&mut self, v: T) -> SerializeResult<()>
+    fn serialize_some<T>(&mut self, v: T) -> SerializeResult<()>
         where T: serde::Serialize,
     {
         try!(self.writer.write_u8(1).map_err(wrap_io));
         v.serialize(self)
     }
 
-    fn visit_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()>
         where V: serde::ser::SeqVisitor,
     {
         let len = match visitor.len() {
@@ -156,14 +167,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
             None => panic!("do not know how to serialize a sequence with no length"),
         };
 
-        try!(self.visit_usize(len));
+        try!(self.serialize_usize(len));
 
         while let Some(()) = try!(visitor.visit(self)) { }
 
         Ok(())
     }
 
-    fn visit_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()>
         where V: serde::ser::SeqVisitor,
     {
         while let Some(()) = try!(visitor.visit(self)) { }
@@ -171,13 +182,13 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         Ok(())
     }
 
-    fn visit_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
+    fn serialize_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
         where V: serde::Serialize,
     {
         value.serialize(self)
     }
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_map<V>(&mut self, mut visitor: V) -> SerializeResult<()>
         where V: serde::ser::MapVisitor,
     {
         let len = match visitor.len() {
@@ -185,14 +196,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
             None => panic!("do not know how to serialize a map with no length"),
         };
 
-        try!(self.visit_usize(len));
+        try!(self.serialize_usize(len));
 
         while let Some(()) = try!(visitor.visit(self)) { }
 
         Ok(())
     }
 
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()>
+    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()>
         where K: serde::Serialize,
               V: serde::Serialize,
     {
@@ -200,7 +211,7 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         value.serialize(self)
     }
 
-    fn visit_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
+    fn serialize_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
         where V: serde::ser::MapVisitor,
     {
         while let Some(()) = try!(visitor.visit(self)) { }
@@ -208,13 +219,13 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         Ok(())
     }
 
-    fn visit_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()>
+    fn serialize_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()>
         where V: serde::Serialize,
     {
         value.serialize(self)
     }
 
-    fn visit_newtype_struct<T>(&mut self,
+    fn serialize_newtype_struct<T>(&mut self,
                                _name: &str,
                                value: T) -> SerializeResult<()>
         where T: serde::ser::Serialize,
@@ -222,14 +233,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         value.serialize(self)
     }
 
-    fn visit_unit_variant(&mut self,
+    fn serialize_unit_variant(&mut self,
                           _name: &str,
                           variant_index: usize,
                           _variant: &str) -> SerializeResult<()> {
         self.add_enum_tag(variant_index)
     }
 
-    fn visit_tuple_variant<V>(&mut self,
+    fn serialize_tuple_variant<V>(&mut self,
                               _name: &str,
                               variant_index: usize,
                               _variant: &str,
@@ -243,7 +254,7 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         Ok(())
     }
 
-    fn visit_struct_variant<V>(&mut self,
+    fn serialize_struct_variant<V>(&mut self,
                                _name: &str,
                                variant_index: usize,
                                _variant: &str,
@@ -297,69 +308,69 @@ impl SizeChecker {
 impl serde::Serializer for SizeChecker {
     type Error = SerializeError;
 
-    fn visit_unit(&mut self) -> SerializeResult<()> { Ok(()) }
+    fn serialize_unit(&mut self) -> SerializeResult<()> { Ok(()) }
 
-    fn visit_bool(&mut self, _: bool) -> SerializeResult<()> {
+    fn serialize_bool(&mut self, _: bool) -> SerializeResult<()> {
         self.add_value(0 as u8)
     }
 
-    fn visit_u8(&mut self, v: u8) -> SerializeResult<()> {
+    fn serialize_u8(&mut self, v: u8) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_u16(&mut self, v: u16) -> SerializeResult<()> {
+    fn serialize_u16(&mut self, v: u16) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_u32(&mut self, v: u32) -> SerializeResult<()> {
+    fn serialize_u32(&mut self, v: u32) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_u64(&mut self, v: u64) -> SerializeResult<()> {
+    fn serialize_u64(&mut self, v: u64) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_i8(&mut self, v: i8) -> SerializeResult<()> {
+    fn serialize_i8(&mut self, v: i8) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_i16(&mut self, v: i16) -> SerializeResult<()> {
+    fn serialize_i16(&mut self, v: i16) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_i32(&mut self, v: i32) -> SerializeResult<()> {
+    fn serialize_i32(&mut self, v: i32) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_i64(&mut self, v: i64) -> SerializeResult<()> {
+    fn serialize_i64(&mut self, v: i64) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_f32(&mut self, v: f32) -> SerializeResult<()> {
+    fn serialize_f32(&mut self, v: f32) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_f64(&mut self, v: f64) -> SerializeResult<()> {
+    fn serialize_f64(&mut self, v: f64) -> SerializeResult<()> {
         self.add_value(v)
     }
 
-    fn visit_str(&mut self, v: &str) -> SerializeResult<()> {
+    fn serialize_str(&mut self, v: &str) -> SerializeResult<()> {
         try!(self.add_value(0 as u64));
         self.add_raw(v.len())
     }
 
-    fn visit_none(&mut self) -> SerializeResult<()> {
+    fn serialize_none(&mut self) -> SerializeResult<()> {
         self.add_value(0 as u8)
     }
 
-    fn visit_some<T>(&mut self, v: T) -> SerializeResult<()>
+    fn serialize_some<T>(&mut self, v: T) -> SerializeResult<()>
         where T: serde::Serialize,
     {
         try!(self.add_value(1 as u8));
         v.serialize(self)
     }
 
-    fn visit_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()>
         where V: serde::ser::SeqVisitor,
     {
         let len = match visitor.len() {
@@ -367,14 +378,14 @@ impl serde::Serializer for SizeChecker {
             None => panic!("do not know how to serialize a sequence with no length"),
         };
 
-        try!(self.visit_usize(len));
+        try!(self.serialize_usize(len));
 
         while let Some(()) = try!(visitor.visit(self)) { }
 
         Ok(())
     }
 
-    fn visit_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()>
         where V: serde::ser::SeqVisitor,
     {
         while let Some(()) = try!(visitor.visit(self)) { }
@@ -382,13 +393,13 @@ impl serde::Serializer for SizeChecker {
         Ok(())
     }
 
-    fn visit_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
+    fn serialize_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
         where V: serde::Serialize,
     {
         value.serialize(self)
     }
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_map<V>(&mut self, mut visitor: V) -> SerializeResult<()>
         where V: serde::ser::MapVisitor,
     {
         let len = match visitor.len() {
@@ -396,14 +407,14 @@ impl serde::Serializer for SizeChecker {
             None => panic!("do not know how to serialize a map with no length"),
         };
 
-        try!(self.visit_usize(len));
+        try!(self.serialize_usize(len));
 
         while let Some(()) = try!(visitor.visit(self)) { }
 
         Ok(())
     }
 
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()>
+    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()>
         where K: serde::Serialize,
               V: serde::Serialize,
     {
@@ -411,7 +422,7 @@ impl serde::Serializer for SizeChecker {
         value.serialize(self)
     }
 
-    fn visit_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
+    fn serialize_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
         where V: serde::ser::MapVisitor,
     {
         while let Some(()) = try!(visitor.visit(self)) { }
@@ -419,20 +430,20 @@ impl serde::Serializer for SizeChecker {
         Ok(())
     }
 
-    fn visit_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()>
+    fn serialize_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()>
         where V: serde::Serialize,
     {
         value.serialize(self)
     }
 
-    fn visit_unit_variant(&mut self,
+    fn serialize_unit_variant(&mut self,
                           _name: &str,
                           variant_index: usize,
                           _variant: &str) -> SerializeResult<()> {
         self.add_enum_tag(variant_index)
     }
 
-    fn visit_tuple_variant<V>(&mut self,
+    fn serialize_tuple_variant<V>(&mut self,
                          _name: &str,
                          variant_index: usize,
                          _variant: &str,
@@ -446,7 +457,7 @@ impl serde::Serializer for SizeChecker {
         Ok(())
     }
 
-    fn visit_struct_variant<V>(&mut self,
+    fn serialize_struct_variant<V>(&mut self,
                                _name: &str,
                                variant_index: usize,
                                _variant: &str,
diff --git a/tests/test.rs b/tests/test.rs
index b017c55..e2540ea 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -243,7 +243,8 @@ fn deserializing_errors() {
     fn isize_invalid_deserialize<T: Debug>(res: DeserializeResult<T>) {
         match res {
             Err(DeserializeError::InvalidEncoding(_)) => {},
-            Err(DeserializeError::SyntaxError(_)) => {},
+            Err(DeserializeError::Serde(serde::de::value::Error::UnknownVariant(_))) => {},
+            Err(DeserializeError::Serde(serde::de::value::Error::InvalidValue(_))) => {},
             _ => panic!("Expecting InvalidEncoding, got {:?}", res),
         }
     }