diff --git a/serde2/Cargo.lock b/serde2/Cargo.lock
index 386763db..edccb429 100644
--- a/serde2/Cargo.lock
+++ b/serde2/Cargo.lock
@@ -1,4 +1,11 @@
 [root]
 name = "serde2"
 version = "0.1.0"
+dependencies = [
+ "serde2_macros 0.1.0",
+]
+
+[[package]]
+name = "serde2_macros"
+version = "0.1.0"
 
diff --git a/serde2/Cargo.toml b/serde2/Cargo.toml
index 32c309b4..9001c6bd 100644
--- a/serde2/Cargo.toml
+++ b/serde2/Cargo.toml
@@ -9,3 +9,6 @@ name = "serde2"
 [[bin]]
 name = "serde2"
 path = "src/bin.rs"
+
+[dependencies.serde2_macros]
+path = "serde2_macros/"
diff --git a/serde2/src/json/ser.rs b/serde2/src/json/ser.rs
index 3fa4ecc6..f44b89e6 100644
--- a/serde2/src/json/ser.rs
+++ b/serde2/src/json/ser.rs
@@ -12,6 +12,7 @@ pub struct Serializer<W> {
 impl<W: Writer> Serializer<W> {
     /// Creates a new JSON serializer whose output will be written to the writer
     /// specified.
+    #[inline]
     pub fn new(writer: W) -> Serializer<W> {
         Serializer {
             writer: writer,
@@ -19,6 +20,7 @@ impl<W: Writer> Serializer<W> {
     }
 
     /// Unwrap the Writer from the Serializer.
+    #[inline]
     pub fn unwrap(self) -> W {
         self.writer
     }
@@ -39,11 +41,51 @@ impl<W: Writer> ser::VisitorState<io::IoResult<()>> for Serializer<W> {
         }
     }
 
+    #[inline]
+    fn visit_int(&mut self, value: int) -> io::IoResult<()> {
+        write!(self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i8(&mut self, value: i8) -> io::IoResult<()> {
+        write!(self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i16(&mut self, value: i16) -> io::IoResult<()> {
+        write!(self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i32(&mut self, value: i32) -> io::IoResult<()> {
+        write!(self.writer, "{}", value)
+    }
+
     #[inline]
     fn visit_i64(&mut self, value: i64) -> io::IoResult<()> {
         write!(self.writer, "{}", value)
     }
 
+    #[inline]
+    fn visit_uint(&mut self, value: uint) -> io::IoResult<()> {
+        write!(self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u8(&mut self, value: u8) -> io::IoResult<()> {
+        write!(self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u16(&mut self, value: u16) -> io::IoResult<()> {
+        write!(self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u32(&mut self, value: u32) -> io::IoResult<()> {
+        write!(self.writer, "{}", value)
+    }
+
     #[inline]
     fn visit_u64(&mut self, value: u64) -> io::IoResult<()> {
         write!(self.writer, "{}", value)
@@ -60,10 +102,11 @@ impl<W: Writer> ser::VisitorState<io::IoResult<()>> for Serializer<W> {
     }
 
     #[inline]
-    fn visit_str(&mut self, value: &'static str) -> io::IoResult<()> {
+    fn visit_str(&mut self, value: &str) -> io::IoResult<()> {
         escape_str(&mut self.writer, value)
     }
 
+    #[inline]
     fn visit_seq<
         V: ser::Visitor<Serializer<W>, io::IoResult<()>>
     >(&mut self, mut visitor: V) -> io::IoResult<()> {
@@ -76,19 +119,22 @@ impl<W: Writer> ser::VisitorState<io::IoResult<()>> for Serializer<W> {
                 None => { break; }
             }
         }
+
         write!(self.writer, "]")
     }
 
+    #[inline]
     fn visit_seq_elt<
         T: ser::Serialize<Serializer<W>, io::IoResult<()>>
     >(&mut self, first: bool, value: T) -> io::IoResult<()> {
         if !first {
-            try!(write!(self.writer, ", "));
+            try!(write!(self.writer, ","));
         }
 
-        value.serialize(self)
+        //value.serialize(self)
     }
 
+    #[inline]
     fn visit_map<
         V: ser::Visitor<Serializer<W>, io::IoResult<()>>
     >(&mut self, mut visitor: V) -> io::IoResult<()> {
@@ -104,21 +150,22 @@ impl<W: Writer> ser::VisitorState<io::IoResult<()>> for Serializer<W> {
         write!(self.writer, "}}")
     }
 
+    #[inline]
     fn visit_map_elt<
         K: ser::Serialize<Serializer<W>, io::IoResult<()>>,
         V: ser::Serialize<Serializer<W>, io::IoResult<()>>
     >(&mut self, first: bool, key: K, value: V) -> io::IoResult<()> {
         if !first {
-            try!(write!(self.writer, ", "));
+            try!(write!(self.writer, ","));
         }
 
         try!(key.serialize(self));
-        try!(write!(self.writer, ": "));
+        try!(write!(self.writer, ":"));
         value.serialize(self)
     }
 }
 
-pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
+fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
     try!(wr.write_str("\""));
 
     let mut start = 0;
@@ -151,7 +198,7 @@ pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
     wr.write_str("\"")
 }
 
-pub fn escape_str<W: Writer>(wr: &mut W, value: &str) -> io::IoResult<()> {
+fn escape_str<W: Writer>(wr: &mut W, value: &str) -> io::IoResult<()> {
     escape_bytes(wr, value.as_bytes())
 }
 
@@ -168,6 +215,7 @@ fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> io::IoResult<()> {
     }
 }
 
+#[inline]
 pub fn to_vec<
     T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>>
 >(value: &T) -> io::IoResult<Vec<u8>> {
@@ -177,6 +225,7 @@ pub fn to_vec<
     Ok(state.unwrap().unwrap())
 }
 
+#[inline]
 pub fn to_string<
     T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>>
 >(value: &T) -> io::IoResult<Result<String, Vec<u8>>> {
diff --git a/serde2/src/lib.rs b/serde2/src/lib.rs
index ada153c1..5d2e81f7 100644
--- a/serde2/src/lib.rs
+++ b/serde2/src/lib.rs
@@ -1,3 +1,5 @@
+#![feature(macro_rules)]
+
 pub use ser::{Serialize, Serializer};
 pub use ser::{Visitor, VisitorState};
 pub use ser::GatherTokens;
diff --git a/serde2/src/ser.rs b/serde2/src/ser.rs
index 9b3a9ea4..c3718050 100644
--- a/serde2/src/ser.rs
+++ b/serde2/src/ser.rs
@@ -82,7 +82,7 @@ pub trait VisitorState<R> {
 
     fn visit_char(&mut self, value: char) -> R;
 
-    fn visit_str(&mut self, value: &'static str) -> R;
+    fn visit_str(&mut self, value: &str) -> R;
 
     fn visit_seq<
         V: Visitor<Self, R>
@@ -125,15 +125,45 @@ pub trait VisitorState<R> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl<S: VisitorState<R>, R> Serialize<S, R> for int {
-    fn serialize(&self, state: &mut S) -> R {
-        state.visit_int(*self)
+macro_rules! impl_serialize {
+    ($ty:ty, $method:ident) => {
+        impl<S: VisitorState<R>, R> Serialize<S, R> for $ty {
+            #[inline]
+            fn serialize(&self, state: &mut S) -> R {
+                state.$method(*self)
+            }
+        }
     }
 }
 
-impl<S: VisitorState<R>, R> Serialize<S, R> for &'static str {
-    fn serialize(&self, state: &mut S) -> R {
-        state.visit_str(*self)
+impl_serialize!(bool, visit_bool)
+impl_serialize!(int, visit_int)
+impl_serialize!(i8, visit_i8)
+impl_serialize!(i16, visit_i16)
+impl_serialize!(i32, visit_i32)
+impl_serialize!(i64, visit_i64)
+impl_serialize!(uint, visit_uint)
+impl_serialize!(u8, visit_u8)
+impl_serialize!(u16, visit_u16)
+impl_serialize!(u32, visit_u32)
+impl_serialize!(u64, visit_u64)
+impl_serialize!(f32, visit_f32)
+impl_serialize!(f64, visit_f64)
+impl_serialize!(char, visit_char)
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<'a, S: VisitorState<R>, R> Serialize<S, R> for &'a str {
+    #[inline]
+    fn serialize(&self, s: &mut S) -> R {
+        s.visit_str(*self)
+    }
+}
+
+impl<S: VisitorState<R>, R> Serialize<S, R> for String {
+    #[inline]
+    fn serialize(&self, s: &mut S) -> R {
+        s.visit_str(self.as_slice())
     }
 }
 
@@ -145,6 +175,7 @@ pub struct SeqIteratorVisitor<Iter> {
 }
 
 impl<T, Iter: Iterator<T>> SeqIteratorVisitor<Iter> {
+    #[inline]
     pub fn new(iter: Iter) -> SeqIteratorVisitor<Iter> {
         SeqIteratorVisitor {
             iter: iter,
@@ -159,6 +190,7 @@ impl<
     S: VisitorState<R>,
     R
 > Visitor<S, R> for SeqIteratorVisitor<Iter> {
+    #[inline]
     fn visit(&mut self, state: &mut S) -> Option<R> {
         let first = self.first;
         self.first = false;
@@ -169,6 +201,7 @@ impl<
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
         self.iter.size_hint()
     }
@@ -181,6 +214,7 @@ impl<
     R,
     T: Serialize<S, R>
 > Serialize<S, R> for Vec<T> {
+    #[inline]
     fn serialize(&self, state: &mut S) -> R {
         state.visit_seq(SeqIteratorVisitor::new(self.iter()))
     }
@@ -193,10 +227,8 @@ pub struct MapIteratorVisitor<Iter> {
     first: bool,
 }
 
-impl<
-    K,
-    V,
-    Iter: Iterator<(K, V)>> MapIteratorVisitor<Iter> {
+impl<K, V, Iter: Iterator<(K, V)>> MapIteratorVisitor<Iter> {
+    #[inline]
     pub fn new(iter: Iter) -> MapIteratorVisitor<Iter> {
         MapIteratorVisitor {
             iter: iter,
@@ -212,6 +244,7 @@ impl<
     S: VisitorState<R>,
     R
 > Visitor<S, R> for MapIteratorVisitor<Iter> {
+    #[inline]
     fn visit(&mut self, state: &mut S) -> Option<R> {
         let first = self.first;
         self.first = false;
@@ -222,6 +255,7 @@ impl<
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
         self.iter.size_hint()
     }
@@ -235,6 +269,7 @@ impl<
     K: Serialize<S, R> + Ord,
     V: Serialize<S, R>
 > Serialize<S, R> for TreeMap<K, V> {
+    #[inline]
     fn serialize(&self, state: &mut S) -> R {
         state.visit_map(MapIteratorVisitor::new(self.iter()))
     }
@@ -247,6 +282,7 @@ impl<
     T0: Serialize<S, R>,
     T1: Serialize<S, R>
 > Serialize<S, R> for (T0, T1) {
+    #[inline]
     fn serialize(&self, state: &mut S) -> R {
         state.visit_seq(Tuple2Serialize { value: self, state: 0 })
     }
@@ -264,6 +300,7 @@ impl<
     T0: Serialize<S, R>,
     T1: Serialize<S, R>
 > Visitor<S, R> for Tuple2Serialize<'a, T0, T1> {
+    #[inline]
     fn visit(&mut self, state: &mut S) -> Option<R> {
         match self.state {
             0 => {
@@ -282,6 +319,7 @@ impl<
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
         let size = 2 - self.state;
         (size, Some(size))
@@ -294,6 +332,7 @@ impl<
     R,
     T: Serialize<S, R>
 > Serialize<S, R> for &'a T {
+    #[inline]
     fn serialize(&self, state: &mut S) -> R {
         (**self).serialize(state)
     }
@@ -302,7 +341,7 @@ impl<
 ///////////////////////////////////////////////////////////////////////////////
 
 #[deriving(Show)]
-pub enum Token {
+pub enum Token<'a> {
     Null,
     Bool(bool),
     Int(int),
@@ -310,42 +349,43 @@ pub enum Token {
     U64(u64),
     F64(f64),
     Char(char),
-    Str(&'static str),
+    Str(&'a str),
+    String(String),
     SeqStart(uint),
     MapStart(uint),
     StructStart(&'static str, uint),
     End,
 }
 
-pub trait TokenState<R>: VisitorState<R> {
-    fn serialize(&mut self, token: Token) -> R;
+pub trait TokenState<'a, R>: VisitorState<R> {
+    fn serialize(&mut self, token: Token<'a>) -> R;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub struct GatherTokens {
-    tokens: Vec<Token>,
+pub struct GatherTokens<'a> {
+    tokens: Vec<Token<'a>>,
 }
 
-impl GatherTokens {
-    pub fn new() -> GatherTokens {
+impl<'a> GatherTokens<'a> {
+    pub fn new() -> GatherTokens<'a> {
         GatherTokens {
             tokens: Vec::new(),
         }
     }
 
-    pub fn unwrap(self) -> Vec<Token> {
+    pub fn unwrap(self) -> Vec<Token<'a>> {
         self.tokens
     }
 }
 
-impl TokenState<()> for GatherTokens {
-    fn serialize(&mut self, token: Token) -> () {
+impl<'a> TokenState<'a, ()> for GatherTokens<'a> {
+    fn serialize(&mut self, token: Token<'a>) -> () {
         self.tokens.push(token);
     }
 }
 
-impl VisitorState<()> for GatherTokens {
+impl<'a> VisitorState<()> for GatherTokens<'a> {
     fn visit_null(&mut self) -> () {
         self.serialize(Null)
     }
@@ -370,12 +410,12 @@ impl VisitorState<()> for GatherTokens {
         self.serialize(Char(value))
     }
 
-    fn visit_str(&mut self, value: &'static str) -> () {
-        self.serialize(Str(value))
+    fn visit_str(&mut self, value: &str) -> () {
+        self.serialize(String(value.to_string()))
     }
 
     fn visit_seq<
-        V: Visitor<GatherTokens, ()>
+        V: Visitor<GatherTokens<'a>, ()>
     >(&mut self, mut visitor: V) -> () {
         let (len, _) = visitor.size_hint();
         self.tokens.push(SeqStart(len));
@@ -389,13 +429,13 @@ impl VisitorState<()> for GatherTokens {
     }
 
     fn visit_seq_elt<
-        T: Serialize<GatherTokens, ()>
+        T: Serialize<GatherTokens<'a>, ()>
     >(&mut self, _first: bool, value: T) -> () {
         value.serialize(self)
     }
 
     fn visit_map<
-        V: Visitor<GatherTokens, ()>
+        V: Visitor<GatherTokens<'a>, ()>
     >(&mut self, mut visitor: V) -> () {
         let (len, _) = visitor.size_hint();
         self.serialize(MapStart(len));
@@ -409,7 +449,7 @@ impl VisitorState<()> for GatherTokens {
     }
 
     fn visit_named_map<
-        V: Visitor<GatherTokens, ()>
+        V: Visitor<GatherTokens<'a>, ()>
     >(&mut self, name: &'static str, mut visitor: V) -> () {
         let (len, _) = visitor.size_hint();
         self.serialize(StructStart(name, len));
@@ -423,8 +463,8 @@ impl VisitorState<()> for GatherTokens {
     }
 
     fn visit_map_elt<
-        K: Serialize<GatherTokens, ()>,
-        V: Serialize<GatherTokens, ()>
+        K: Serialize<GatherTokens<'a>, ()>,
+        V: Serialize<GatherTokens<'a>, ()>
     >(&mut self, _first: bool, key: K, value: V) -> () {
         key.serialize(self);
         value.serialize(self)