diff --git a/Cargo.toml b/Cargo.toml
index 868a0877..2bd52e6e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,7 @@ libc = "0.1"
 rand = "0.3"
 rust-crypto = "0.2.31"
 rustc-serialize = "0.3"
-serde = "~0.6.1"
+serde = "0.7"
 time = "0.1"
 
 [dependencies.num]
diff --git a/serde-tests/Cargo.toml b/serde-tests/Cargo.toml
index 4d3aabe3..7a68621e 100644
--- a/serde-tests/Cargo.toml
+++ b/serde-tests/Cargo.toml
@@ -6,12 +6,12 @@ build = "build.rs"
 
 
 [dependencies]
-serde = "0.6"
+serde = "0.7"
 bson = { path = "..", features = ["serde"] }
 
 [build-dependencies]
-syntex = "0.22"
-serde_codegen = "0.6"
+syntex = "^0.29.0"
+serde_codegen = "0.7"
 
 [lib]
 name = "serde_tests"
diff --git a/serde-tests/test.rs.in b/serde-tests/test.rs.in
index 00293219..590a19a7 100644
--- a/serde-tests/test.rs.in
+++ b/serde-tests/test.rs.in
@@ -121,7 +121,7 @@ fn application_decode_error() {
          fn deserialize<D: Deserializer>(d: &mut D) -> Result<Range10, D::Error> {
              let x: usize = try!(Deserialize::deserialize(d));
              if x > 10 {
-                 Err(serde::de::Error::syntax("more than 10"))
+                 Err(serde::de::Error::invalid_value("more than 10"))
              } else {
                  Ok(Range10(x))
              }
diff --git a/src/decoder/error.rs b/src/decoder/error.rs
index b34c984e..f1368587 100644
--- a/src/decoder/error.rs
+++ b/src/decoder/error.rs
@@ -14,9 +14,10 @@ pub enum DecoderError {
     // An unexpected field was found.
     UnknownField(String),
     // There was an error with the syntactical structure of the BSON.
-    SyntaxError,
+    SyntaxError(String),
     // The end of the BSON input was reached too soon.
     EndOfStream,
+    Unknown(String),
 }
 
 impl From<io::Error> for DecoderError {
@@ -52,8 +53,9 @@ impl fmt::Display for DecoderError {
                 write!(fmt, "expected a field of type `{}`", field_type)
             }
             DecoderError::UnknownField(ref field) => write!(fmt, "unknown field `{}`", field),
-            DecoderError::SyntaxError => write!(fmt, "syntax error"),
+            DecoderError::SyntaxError(ref inner) => inner.fmt(fmt),
             DecoderError::EndOfStream => write!(fmt, "end of stream"),
+            DecoderError::Unknown(ref inner) => inner.fmt(fmt),
         }
     }
 }
@@ -67,8 +69,9 @@ impl error::Error for DecoderError {
             DecoderError::InvalidArrayKey(_, _) => "invalid array key",
             DecoderError::ExpectedField(_) => "expected a field",
             DecoderError::UnknownField(_) => "found an unknown field",
-            DecoderError::SyntaxError => "syntax error",
+            DecoderError::SyntaxError(ref inner) => inner,
             DecoderError::EndOfStream => "end of stream",
+            DecoderError::Unknown(ref inner) => inner,
         }
     }
     fn cause(&self) -> Option<&error::Error> {
@@ -81,8 +84,12 @@ impl error::Error for DecoderError {
 }
 
 impl de::Error for DecoderError {
-    fn syntax(_: &str) -> DecoderError {
-        DecoderError::SyntaxError
+    fn custom<T: Into<String>>(msg: T) -> DecoderError {
+        DecoderError::Unknown(msg.into())
+    }
+
+    fn invalid_value(msg: &str) -> DecoderError {
+        DecoderError::SyntaxError(msg.to_owned())
     }
 
     fn end_of_stream() -> DecoderError {
diff --git a/src/decoder/serde.rs b/src/decoder/serde.rs
index bd8f1aaa..f2b312a4 100644
--- a/src/decoder/serde.rs
+++ b/src/decoder/serde.rs
@@ -15,11 +15,11 @@ impl Deserialize for ObjectId {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit_map(BsonVisitor)
+        deserializer.deserialize_map(BsonVisitor)
             .and_then(|bson| if let Bson::ObjectId(oid) = bson {
                 Ok(oid)
             } else {
-                Err(de::Error::syntax(&format!("expected objectId extended document, found {}", bson)))
+                Err(de::Error::invalid_value(&format!("expected objectId extended document, found {}", bson)))
             })
     }
 }
@@ -29,11 +29,11 @@ impl Deserialize for OrderedDocument {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit_map(BsonVisitor)
+        deserializer.deserialize_map(BsonVisitor)
             .and_then(|bson| if let Bson::Document(doc) = bson {
                 Ok(doc)
             } else {
-                Err(de::Error::syntax(&format!("expected document, found extended JSON data type: {}", bson)))
+                Err(de::Error::invalid_value(&format!("expected document, found extended JSON data type: {}", bson)))
             })
     }
 }
@@ -43,7 +43,7 @@ impl Deserialize for Bson {
     fn deserialize<D>(deserializer: &mut D) -> Result<Bson, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit(BsonVisitor)
+        deserializer.deserialize(BsonVisitor)
     }
 }
 
@@ -149,7 +149,7 @@ impl Deserializer for Decoder {
     type Error = DecoderError;
 
     #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+    fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         let value = match self.value.take() {
@@ -195,7 +195,7 @@ impl Deserializer for Decoder {
     }
 
     #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+    fn deserialize_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         match self.value {
@@ -206,7 +206,7 @@ impl Deserializer for Decoder {
     }
 
     #[inline]
-    fn visit_enum<V>(&mut self,
+    fn deserialize_enum<V>(&mut self,
                      _name: &str,
                      _variants: &'static [&'static str],
                      mut visitor: V) -> DecoderResult<V::Value>
@@ -214,7 +214,7 @@ impl Deserializer for Decoder {
     {
         let value = match self.value.take() {
             Some(Bson::Document(value)) => value,
-            Some(_) => { return Err(de::Error::syntax("expected an enum")); }
+            Some(_) => { return Err(de::Error::invalid_value("expected an enum")); }
             None => { return Err(de::Error::end_of_stream()); }
         };
 
@@ -222,12 +222,12 @@ impl Deserializer for Decoder {
 
         let (variant, value) = match iter.next() {
             Some(v) => v,
-            None => return Err(de::Error::syntax("expected a variant name")),
+            None => return Err(de::Error::invalid_value("expected a variant name")),
         };
 
         // enums are encoded in json as maps with a single key:value pair
         match iter.next() {
-            Some(_) => Err(de::Error::syntax("expected map")),
+            Some(_) => Err(de::Error::invalid_value("expected map")),
             None => visitor.visit(VariantDecoder {
                 de: self,
                 val: Some(value),
@@ -237,18 +237,13 @@ impl Deserializer for Decoder {
     }
 
     #[inline]
-    fn visit_newtype_struct<V>(&mut self,
+    fn deserialize_newtype_struct<V>(&mut self,
                                _name: &'static str,
                                mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         visitor.visit_newtype_struct(self)
     }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
 }
 
 struct VariantDecoder<'a> {
@@ -286,7 +281,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
     {
         if let Bson::Array(fields) = try!(self.val.take()
                                           .ok_or(DecoderError::EndOfStream)) {
-            Deserializer::visit(
+            Deserializer::deserialize(
                 &mut SeqDecoder {
                     de: self.de,
                     len: fields.len(),
@@ -295,7 +290,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
                 visitor,
             )
         } else {
-            Err(de::Error::syntax("expected a tuple"))
+            Err(de::Error::invalid_value("expected a tuple"))
         }
     }
 
@@ -306,7 +301,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
     {
         if let Bson::Document(fields) = try!(self.val.take()
                                              .ok_or(DecoderError::EndOfStream)) {
-            Deserializer::visit(
+            Deserializer::deserialize(
                 &mut MapDecoder {
                     de: self.de,
                     len: fields.len(),
@@ -316,7 +311,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
                 visitor,
             )
         } else {
-            Err(de::Error::syntax("expected a struct"))
+            Err(de::Error::invalid_value("expected a struct"))
         }
     }
 }
@@ -331,7 +326,7 @@ impl<'a> Deserializer for SeqDecoder<'a> {
     type Error = DecoderError;
 
     #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+    fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         if self.len == 0 {
@@ -362,7 +357,7 @@ impl<'a> SeqVisitor for SeqDecoder<'a> {
         if self.len == 0 {
             Ok(())
         } else {
-            Err(de::Error::length_mismatch(self.len))
+            Err(de::Error::invalid_length(self.len))
         }
     }
 
@@ -422,13 +417,13 @@ impl<'a> MapVisitor for MapDecoder<'a> {
         impl Deserializer for UnitDecoder {
             type Error = DecoderError;
 
-            fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+            fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
                 where V: Visitor,
             {
                 visitor.visit_unit()
             }
 
-            fn visit_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+            fn deserialize_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
                 where V: Visitor,
             {
                 visitor.visit_none()
@@ -447,7 +442,7 @@ impl<'a> Deserializer for MapDecoder<'a> {
     type Error = DecoderError;
 
     #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+    fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         visitor.visit_map(self)
diff --git a/src/encoder/error.rs b/src/encoder/error.rs
index 9960a1b5..b46a44d2 100644
--- a/src/encoder/error.rs
+++ b/src/encoder/error.rs
@@ -1,5 +1,6 @@
 use std::{io, error, fmt};
 use byteorder;
+use serde::ser;
 use super::serde::State;
 
 /// Possible errors that can arise during encoding.
@@ -9,6 +10,7 @@ pub enum EncoderError {
     InvalidMapKeyType(State),
     InvalidState(State),
     EmptyState,
+    Unknown(String),
 }
 
 impl From<io::Error> for EncoderError {
@@ -30,6 +32,7 @@ impl fmt::Display for EncoderError {
             &EncoderError::InvalidMapKeyType(ref inner) => write!(fmt, "Invalid map key type: {:?}", inner),
             &EncoderError::InvalidState(ref inner) => write!(fmt, "Invalid state emitted: {:?}", inner),
             &EncoderError::EmptyState => write!(fmt, "No state emitted"),
+            &EncoderError::Unknown(ref inner) => inner.fmt(fmt),
         }
     }
 }
@@ -41,6 +44,7 @@ impl error::Error for EncoderError {
             &EncoderError::InvalidMapKeyType(_) => "Invalid map key type",
             &EncoderError::InvalidState(_) => "Invalid state emitted",
             &EncoderError::EmptyState => "No state emitted",
+            &EncoderError::Unknown(ref inner) => inner,
         }
     }
     fn cause(&self) -> Option<&error::Error> {
@@ -51,5 +55,11 @@ impl error::Error for EncoderError {
     }
 }
 
+impl ser::Error for EncoderError {
+    fn custom<T: Into<String>>(msg: T) -> EncoderError {
+        EncoderError::Unknown(msg.into())
+    }
+}
+
 /// Alias for `Result<T, EncoderError>`.
 pub type EncoderResult<T> = Result<T, EncoderError>;
diff --git a/src/encoder/serde.rs b/src/encoder/serde.rs
index 6dbbb075..a77908ba 100644
--- a/src/encoder/serde.rs
+++ b/src/encoder/serde.rs
@@ -13,7 +13,7 @@ impl Serialize for ObjectId {
     {
         let mut doc = Document::new();
         doc.insert("$oid".to_owned(), self.to_string());
-        serializer.visit_map(MapIteratorVisitor::new(doc.iter(), Some(doc.len())))
+        serializer.serialize_map(MapIteratorVisitor::new(doc.iter(), Some(doc.len())))
     }
 }
 
@@ -22,7 +22,7 @@ impl Serialize for Document {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
     }
 }
 
@@ -32,14 +32,14 @@ impl Serialize for Bson {
         where S: Serializer,
     {
         match *self {
-            Bson::FloatingPoint(v) => serializer.visit_f64(v),
-            Bson::String(ref v) => serializer.visit_str(v),
+            Bson::FloatingPoint(v) => serializer.serialize_f64(v),
+            Bson::String(ref v) => serializer.serialize_str(v),
             Bson::Array(ref v) => v.serialize(serializer),
             Bson::Document(ref v) => v.serialize(serializer),
-            Bson::Boolean(v) => serializer.visit_bool(v),
-            Bson::Null => serializer.visit_unit(),
-            Bson::I32(v) => serializer.visit_i32(v),
-            Bson::I64(v) => serializer.visit_i64(v),                        
+            Bson::Boolean(v) => serializer.serialize_bool(v),
+            Bson::Null => serializer.serialize_unit(),
+            Bson::I32(v) => serializer.serialize_i32(v),
+            Bson::I64(v) => serializer.serialize_i64(v),
             _ => {
                 let doc = self.to_extended_document();
                 doc.serialize(serializer)
@@ -88,78 +88,78 @@ impl Serializer for Encoder {
     type Error = EncoderError;
 
     #[inline]
-    fn visit_bool(&mut self, value: bool) -> EncoderResult<()> {
+    fn serialize_bool(&mut self, value: bool) -> EncoderResult<()> {
         self.state.push(State::Bson(Bson::Boolean(value)));
         Ok(())
     }
 
     #[inline]
-    fn visit_i8(&mut self, value: i8) -> EncoderResult<()> {
-        self.visit_i32(value as i32)
+    fn serialize_i8(&mut self, value: i8) -> EncoderResult<()> {
+        self.serialize_i32(value as i32)
     }    
 
     #[inline]
-    fn visit_i16(&mut self, value: i16) -> EncoderResult<()> {
-        self.visit_i32(value as i32)
+    fn serialize_i16(&mut self, value: i16) -> EncoderResult<()> {
+        self.serialize_i32(value as i32)
     }    
 
     #[inline]
-    fn visit_i32(&mut self, value: i32) -> EncoderResult<()> {
+    fn serialize_i32(&mut self, value: i32) -> EncoderResult<()> {
         self.state.push(State::Bson(Bson::I32(value)));
         Ok(())
     }
 
     #[inline]
-    fn visit_i64(&mut self, value: i64) -> EncoderResult<()> {
+    fn serialize_i64(&mut self, value: i64) -> EncoderResult<()> {
         self.state.push(State::Bson(Bson::I64(value)));
         Ok(())
     }
 
     #[inline]
-    fn visit_u64(&mut self, value: u64) -> EncoderResult<()> {
+    fn serialize_u64(&mut self, value: u64) -> EncoderResult<()> {
         self.state.push(State::Bson(Bson::FloatingPoint(value as f64)));
         Ok(())
     }
 
     #[inline]
-    fn visit_f64(&mut self, value: f64) -> EncoderResult<()> {
+    fn serialize_f64(&mut self, value: f64) -> EncoderResult<()> {
         self.state.push(State::Bson(Bson::FloatingPoint(value as f64)));
         Ok(())
     }
 
     #[inline]
-    fn visit_char(&mut self, value: char) -> EncoderResult<()> {
+    fn serialize_char(&mut self, value: char) -> EncoderResult<()> {
         let mut s = String::new();
         s.push(value);
-        self.visit_str(&s)
+        self.serialize_str(&s)
     }
 
     #[inline]
-    fn visit_str(&mut self, value: &str) -> EncoderResult<()> {
+    fn serialize_str(&mut self, value: &str) -> EncoderResult<()> {
         self.state.push(State::Bson(Bson::String(String::from(value))));
         Ok(())
     }
 
     #[inline]
-    fn visit_none(&mut self) -> EncoderResult<()> {
-        self.visit_unit()
+    fn serialize_none(&mut self) -> EncoderResult<()> {
+        self.serialize_unit()
     }
 
     #[inline]
-    fn visit_some<V>(&mut self, value: V) -> EncoderResult<()>
+    fn serialize_some<V>(&mut self, value: V) -> EncoderResult<()>
         where V: Serialize,
     {
         value.serialize(self)
     }
 
     #[inline]
-    fn visit_unit(&mut self) -> EncoderResult<()> {
+    fn serialize_unit(&mut self) -> EncoderResult<()> {
         self.state.push(State::Bson(Bson::Null));
         Ok(())
     }
 
     #[inline]
-    fn visit_unit_variant(&mut self,
+    fn serialize_unit_variant(&mut self,
                           _name: &str,
                           _variant_index: usize,
                           variant: &str) -> EncoderResult<()> {
@@ -172,7 +172,7 @@ impl Serializer for Encoder {
     }
 
     #[inline]
-    fn visit_newtype_variant<T>(&mut self,
+    fn serialize_newtype_variant<T>(&mut self,
                                 _name: &str,
                                 _variant_index: usize,
                                 variant: &str,
@@ -187,7 +187,7 @@ impl Serializer for Encoder {
     }
 
     #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> EncoderResult<()>
+    fn serialize_seq<V>(&mut self, mut visitor: V) -> EncoderResult<()>
         where V: SeqVisitor,
     {
         let len = visitor.len().unwrap_or(0);
@@ -206,14 +206,14 @@ impl Serializer for Encoder {
     }
 
     #[inline]
-    fn visit_tuple_variant<V>(&mut self,
+    fn serialize_tuple_variant<V>(&mut self,
                               _name: &str,
                               _variant_index: usize,
                               variant: &str,
                               visitor: V) -> EncoderResult<()>
         where V: SeqVisitor,
     {
-        try!(self.visit_seq(visitor));
+        try!(self.serialize_seq(visitor));
 
         let value = match try!(self.pop()) {
             State::Bson(value) => value,
@@ -228,7 +228,7 @@ impl Serializer for Encoder {
     }
 
     #[inline]
-    fn visit_seq_elt<T>(&mut self, value: T) -> EncoderResult<()>
+    fn serialize_seq_elt<T>(&mut self, value: T) -> EncoderResult<()>
         where T: Serialize,
     {
         try!(value.serialize(self));
@@ -248,7 +248,7 @@ impl Serializer for Encoder {
     }
 
     #[inline]
-    fn visit_map<V>(&mut self, mut visitor: V) -> EncoderResult<()>
+    fn serialize_map<V>(&mut self, mut visitor: V) -> EncoderResult<()>
         where V: MapVisitor,
     {
         let values = bson::Document::new();
@@ -267,14 +267,14 @@ impl Serializer for Encoder {
     }
 
     #[inline]
-    fn visit_struct_variant<V>(&mut self,
+    fn serialize_struct_variant<V>(&mut self,
                                _name: &str,
                                _variant_index: usize,
                                variant: &str,
                                visitor: V) -> EncoderResult<()>
         where V: MapVisitor,
     {
-        try!(self.visit_map(visitor));
+        try!(self.serialize_map(visitor));
 
         let value = match try!(self.pop()) {
             State::Bson(value) => value,
@@ -289,7 +289,7 @@ impl Serializer for Encoder {
     }
 
     #[inline]
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> EncoderResult<()>
+    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> EncoderResult<()>
         where K: Serialize,
               V: Serialize,
     {
@@ -317,9 +317,4 @@ impl Serializer for Encoder {
 
         Ok(())
     }
-
-    #[inline]
-    fn format() -> &'static str {
-        "bson"
-    }
 }