diff --git a/Cargo.toml b/Cargo.toml
index c4f24c5..1a91bd4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,14 +15,13 @@ khronos_api = "1.0"
 [features]
 default = []
 test_egl_in_linux = []
-serde_serialization = ["serde", "serde_macros"]
+serde_serialization = ["serde"]
 
 [dependencies]
 log  = "0.3.3"
 gleam = "0.2"
 euclid = "0.6.1"
 serde = { version = ">=0.6.1, <0.8", optional = true }
-serde_macros = { version = ">=0.6.1, <0.8", optional = true }
 
 [target.x86_64-apple-darwin.dependencies]
 core-foundation = "0.2.0"
diff --git a/src/gl_context_attributes.rs b/src/gl_context_attributes.rs
index 82f1ab3..8227ad6 100644
--- a/src/gl_context_attributes.rs
+++ b/src/gl_context_attributes.rs
@@ -1,8 +1,9 @@
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// This structure represents the attributes the context must support
 /// It's almost (if not) identical to WebGLGLContextAttributes
 #[derive(Clone, Debug, Copy)]
-#[cfg_attr(feature="serde_serialization", derive(Serialize, Deserialize))]
 pub struct GLContextAttributes {
     pub alpha: bool,
     pub depth: bool,
@@ -12,6 +13,43 @@ pub struct GLContextAttributes {
     pub preserve_drawing_buffer: bool,
 }
 
+#[cfg(feature = "serde")]
+impl Deserialize for GLContextAttributes {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer
+    {
+        let alpha = try!(bool::deserialize(deserializer));
+        let depth = try!(bool::deserialize(deserializer));
+        let stencil = try!(bool::deserialize(deserializer));
+        let antialias = try!(bool::deserialize(deserializer));
+        let premultiplied_alpha = try!(bool::deserialize(deserializer));
+        let preserve_drawing_buffer = try!(bool::deserialize(deserializer));
+        Ok(GLContextAttributes {
+            alpha: alpha,
+            depth: depth,
+            stencil: stencil,
+            antialias: antialias,
+            premultiplied_alpha: premultiplied_alpha,
+            preserve_drawing_buffer: preserve_drawing_buffer,
+        })
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for GLContextAttributes {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer
+    {
+        try!(self.alpha.serialize(serializer));
+        try!(self.depth.serialize(serializer));
+        try!(self.stencil.serialize(serializer));
+        try!(self.antialias.serialize(serializer));
+        try!(self.premultiplied_alpha.serialize(serializer));
+        try!(self.preserve_drawing_buffer.serialize(serializer));
+        Ok(())
+    }
+}
+
 impl GLContextAttributes {
     pub fn any() -> GLContextAttributes {
         GLContextAttributes {
diff --git a/src/gl_limits.rs b/src/gl_limits.rs
index 471421e..abbe35a 100644
--- a/src/gl_limits.rs
+++ b/src/gl_limits.rs
@@ -1,13 +1,42 @@
 use gleam::gl;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[derive(Debug, Clone)]
-#[cfg_attr(feature="serde_serialization", derive(Serialize, Deserialize))]
 pub struct GLLimits {
     pub max_vertex_attribs: u32,
     pub max_tex_size: u32,
     pub max_cube_map_tex_size: u32
 }
 
+#[cfg(feature = "serde")]
+impl Deserialize for GLLimits {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer
+    {
+        let max_vertex_attribs = try!(u32::deserialize(deserializer));
+        let max_tex_size = try!(u32::deserialize(deserializer));
+        let max_cube_map_tex_size = try!(u32::deserialize(deserializer));
+        Ok(GLLimits {
+            max_vertex_attribs: max_vertex_attribs,
+            max_tex_size: max_tex_size,
+            max_cube_map_tex_size: max_cube_map_tex_size,
+        })
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for GLLimits {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer
+    {
+        try!(self.max_vertex_attribs.serialize(serializer));
+        try!(self.max_tex_size.serialize(serializer));
+        try!(self.max_cube_map_tex_size.serialize(serializer));
+        Ok(())
+    }
+}
+
 impl GLLimits {
     pub fn detect() -> GLLimits {
         GLLimits {
diff --git a/src/lib.rs b/src/lib.rs
index ed5794f..51159f2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,7 @@
-#![cfg_attr(feature="serde_serialization", feature(plugin, custom_derive))]
-#![cfg_attr(feature="serde_serialization", plugin(serde_macros))]
-
 extern crate gleam;
 extern crate euclid;
 
-#[cfg(feature="serde_serialization")]
+#[cfg(feature="serde")]
 extern crate serde;
 
 #[cfg(target_os="linux")]