diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# Version 0.2
+
+* Rename 'gserialize' to 'gserializeDefault'.
+
+* Rename 'gdeserialize' to 'gdeserializeDefault'.
+
+* Export 'RepGSerial'.
+
+
 # Version 0.1.0.1
 
 * Raise upper bound on `instant-generics` dependency.
diff --git a/instant-bytes.cabal b/instant-bytes.cabal
--- a/instant-bytes.cabal
+++ b/instant-bytes.cabal
@@ -1,15 +1,20 @@
 name:                instant-bytes
-version:             0.1.0.1
+version:             0.2
 author:              Renzo Carbonara
 maintainer:          renzo@carbonara.com.ar
 copyright:           Renzo Carbonara 2015
 license:             BSD3
 license-file:        LICENSE.txt
-category:            Web
+stability:           Experimental
+homepage:            https://github.com/k0001/instant-bytes
+bug-reports:         https://github.com/k0001/instant-bytes/issues
+category:            Generics
 build-type:          Simple
 extra-source-files:  README.md CHANGELOG.md
 cabal-version:       >=1.18
 synopsis:            Generic Serial instances through instant-generics
+
+
 
 library
   hs-source-dirs: src/lib
diff --git a/src/lib/Generics/Instant/Functions/Bytes.hs b/src/lib/Generics/Instant/Functions/Bytes.hs
--- a/src/lib/Generics/Instant/Functions/Bytes.hs
+++ b/src/lib/Generics/Instant/Functions/Bytes.hs
@@ -5,13 +5,15 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 module Generics.Instant.Functions.Bytes
   ( -- $defaults
-    gserialize
-  , gdeserialize
+    gserializeDefault
+  , gdeserializeDefault
+  , RepGSerial
     -- * Internals
-  , GSerial
+  , GSerial(..)
     -- ** Even more internal
   , GSumSerial
   , GSumSize
@@ -28,70 +30,78 @@
 --------------------------------------------------------------------------------
 -- $defaults
 --
--- You can use 'gserialize' and 'gdeserialize' as your generic 'Bytes.serialize'
--- and 'Bytes.deserialize' implementations for any 'Representable' type as
--- follows:
+-- You can use 'gserializeDefault' and 'gdeserializeDefault' as your generic
+-- 'Bytes.serialize' and 'Bytes.deserialize' implementations for any 'Representable'
+-- type as follows:
 --
 -- @
 -- instance 'Bytes.Serial' MyType where
---    serialize = 'gserialize'
---    deserialize = 'gdeserialize'
+--    serialize = 'gserializeDefault'
+--    deserialize = 'gdeserializeDefault'
 -- @
 
-gserialize :: (Representable a, GSerial (Rep a), Bytes.MonadPut m) => a -> m ()
-gserialize = \a -> gserialize' (from a)
-{-# INLINABLE gserialize #-}
+gserializeDefault :: (Representable a, GSerial (Rep a), Bytes.MonadPut m) => a -> m ()
+gserializeDefault = \a -> gserialize (from a)
+{-# INLINABLE gserializeDefault #-}
 
-gdeserialize :: (Representable a, GSerial (Rep a), Bytes.MonadGet m) => m a
-gdeserialize = fmap to gdeserialize'
-{-# INLINABLE gdeserialize #-}
+gdeserializeDefault :: (Representable a, GSerial (Rep a), Bytes.MonadGet m) => m a
+gdeserializeDefault = fmap to gdeserialize
+{-# INLINABLE gdeserializeDefault #-}
 
 --------------------------------------------------------------------------------
 
+-- | @'RepGSerial'@ is simply a synonym for
+-- @('Representable' a, 'GSerial' ('Rep' a))@ with the convenient
+-- kind @(* -> 'GHC.Exts.Constraint')@
+class (Representable a, GSerial (Rep a)) => RepGSerial a
+instance (Representable a, GSerial (Rep a)) => RepGSerial a
+
+--------------------------------------------------------------------------------
+
 class GSerial a where
-  gserialize' :: Bytes.MonadPut m => a -> m ()
-  gdeserialize' :: Bytes.MonadGet m => m a
+  gserialize :: Bytes.MonadPut m => a -> m ()
+  gdeserialize :: Bytes.MonadGet m => m a
 
 instance GSerial Z where
-  gserialize' _ = fail "Generics.Instant.Functions.Serial.GSerial Z gserialize' - impossible"
-  gdeserialize' = fail "Generics.Instant.Functions.Serial.GSerial Z gdeserialize' - impossible"
+  gserialize _ = fail "Generics.Instant.Functions.Serial.GSerial Z gserialize - impossible"
+  gdeserialize = fail "Generics.Instant.Functions.Serial.GSerial Z gdeserialize - impossible"
 
 instance GSerial U where
-  gserialize' U = Bytes.serialize ()
-  {-# INLINABLE gserialize' #-}
-  gdeserialize' = Bytes.deserialize >>= \() -> return U
-  {-# INLINABLE gdeserialize' #-}
+  gserialize U = Bytes.serialize ()
+  {-# INLINABLE gserialize #-}
+  gdeserialize = Bytes.deserialize >>= \() -> return U
+  {-# INLINABLE gdeserialize #-}
 
 instance GSerial a => GSerial (CEq c p p a) where
-  gserialize' (C a) = gserialize' a
-  {-# INLINABLE gserialize' #-}
-  gdeserialize' = gdeserialize' >>= \a -> return (C a)
-  {-# INLINABLE gdeserialize' #-}
+  gserialize (C a) = gserialize a
+  {-# INLINABLE gserialize #-}
+  gdeserialize = gdeserialize >>= \a -> return (C a)
+  {-# INLINABLE gdeserialize #-}
 
 instance {-# OVERLAPPABLE #-} GSerial a => GSerial (CEq c p q a) where
-  gserialize' (C a) = gserialize' a
-  {-# INLINABLE gserialize' #-}
-  gdeserialize' = fail "Generics.Instant.Functions.Serial.GSerial (CEq c p q a) gdeserialize' - impossible"
+  gserialize (C a) = gserialize a
+  {-# INLINABLE gserialize #-}
+  gdeserialize = fail "Generics.Instant.Functions.Serial.GSerial (CEq c p q a) gdeserialize - impossible"
 
 instance Bytes.Serial a => GSerial (Var a) where
-  gserialize' (Var a) = Bytes.serialize a
-  {-# INLINABLE gserialize' #-}
-  gdeserialize' = Bytes.deserialize >>= \a -> return (Var a)
-  {-# INLINABLE gdeserialize' #-}
+  gserialize (Var a) = Bytes.serialize a
+  {-# INLINABLE gserialize #-}
+  gdeserialize = Bytes.deserialize >>= \a -> return (Var a)
+  {-# INLINABLE gdeserialize #-}
 
 instance Bytes.Serial a => GSerial (Rec a) where
-  gserialize' (Rec a) = Bytes.serialize a
-  {-# INLINABLE gserialize' #-}
-  gdeserialize' = Bytes.deserialize >>= \a -> return (Rec a)
-  {-# INLINABLE gdeserialize' #-}
+  gserialize (Rec a) = Bytes.serialize a
+  {-# INLINABLE gserialize #-}
+  gdeserialize = Bytes.deserialize >>= \a -> return (Rec a)
+  {-# INLINABLE gdeserialize #-}
 
 instance (GSerial a, GSerial b) => GSerial (a :*: b) where
-  gserialize' (a :*: b) = gserialize' a >> gserialize' b
-  {-# INLINABLE gserialize' #-}
-  gdeserialize' = gdeserialize' >>= \a ->
-                  gdeserialize' >>= \b ->
+  gserialize (a :*: b) = gserialize a >> gserialize b
+  {-# INLINABLE gserialize #-}
+  gdeserialize = gdeserialize >>= \a ->
+                  gdeserialize >>= \b ->
                   return (a :*: b)
-  {-# INLINABLE gdeserialize' #-}
+  {-# INLINABLE gdeserialize #-}
 
 ---
 
@@ -108,8 +118,8 @@
   ( GSumSerial a, GSumSerial b, GSerial a, GSerial b, GSumSize a, GSumSize b
   ) => GSerial (a :+: b)
   where
-    {-# INLINABLE gserialize' #-}
-    gserialize' x
+    {-# INLINABLE gserialize #-}
+    gserialize x
       | predSize <= fromIntegral (maxBound :: Word8)
           = putSum (0 :: Word8) (fromIntegral size) x
       | predSize <= fromIntegral (maxBound :: Word16)
@@ -123,8 +133,8 @@
         size = unTagged (sumSize :: Tagged (a :+: b) Word64)
         predSize = size - 1
 
-    {-# INLINABLE gdeserialize' #-}
-    gdeserialize'
+    {-# INLINABLE gdeserialize #-}
+    gdeserialize
       | predSize <= fromIntegral (maxBound :: Word8)
           = Bytes.deserialize >>= \(c :: Word8) ->
             checkGetSum (fromIntegral size) c
@@ -177,13 +187,13 @@
       sizeR = size - sizeL
 
 instance GSerial a => GSumSerial (CEq c p p a) where
-  putSum !code _ ca = Bytes.serialize code >> gserialize' ca
+  putSum !code _ ca = Bytes.serialize code >> gserialize ca
   {-# INLINABLE putSum #-}
-  getSum _ _ = gdeserialize'
+  getSum _ _ = gdeserialize
   {-# INLINABLE getSum #-}
 
 instance {-# OVERLAPPABLE #-} GSerial a => GSumSerial (CEq c p q a) where
-  putSum !code _ ca = Bytes.serialize code >> gserialize' ca
+  putSum !code _ ca = Bytes.serialize code >> gserialize ca
   {-# INLINABLE putSum #-}
   getSum _ _ = fail "Generics.Instant.Functions.Serial.GSumSerial (CEq c p q a) getSum - impossible"
 
diff --git a/tests/Main.hs b/tests/Main.hs
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -22,7 +22,8 @@
 
 import qualified Generics.Instant as GI
 import qualified Generics.Instant.TH as GI
-import Generics.Instant.Functions.Bytes (GSerial, gserialize, gdeserialize)
+import Generics.Instant.Functions.Bytes (GSerial, RepGSerial,
+                                         gserializeDefault, gdeserializeDefault)
 
 --------------------------------------------------------------------------------
 -- orphans
@@ -46,8 +47,8 @@
 data ZZ = ZZ1 Int | ZZ2 Char | ZZ3 ZZ deriving (Show, Eq)
 GI.deriveAll ''ZZ
 instance Bytes.Serial ZZ where
-  serialize = gserialize
-  deserialize = gdeserialize
+  serialize = gserializeDefault
+  deserialize = gdeserializeDefault
 instance Arbitrary ZZ where
   arbitrary = QC.oneof [ ZZ1 <$> QC.arbitrary
                        , ZZ2 <$> QC.arbitrary
@@ -137,8 +138,6 @@
   , QC.testProperty "Bar2 Float 'False" (prop_IdGSerial :: Bar2 Float 'False -> Bool)
   ]
 
-prop_IdGSerial
-  :: (Eq a, GI.Representable a, GSerial (GI.Rep a), Show a)
-  => a -> Bool
+prop_IdGSerial :: (Eq a, Show a, RepGSerial a) => a -> Bool
 prop_IdGSerial a =
-  a == Bytes.runGetL gdeserialize (Bytes.runPutL (gserialize a))
+  a == Bytes.runGetL gdeserializeDefault (Bytes.runPutL (gserializeDefault a))