diff --git a/cereal.cabal b/cereal.cabal
--- a/cereal.cabal
+++ b/cereal.cabal
@@ -1,5 +1,5 @@
 name:                   cereal
-version:                0.3.1.0
+version:                0.3.2.0
 license:                BSD3
 license-file:           LICENSE
 author:                 Lennart Kolmodin <kolmodin@dtek.chalmers.se>,
diff --git a/src/Data/Serialize.hs b/src/Data/Serialize.hs
--- a/src/Data/Serialize.hs
+++ b/src/Data/Serialize.hs
@@ -62,16 +62,23 @@
 ------------------------------------------------------------------------
 -- Wrappers to run the underlying monad
 
--- | Encode a value using binary serialisation to a strict ByteString.
---
+-- | Encode a value using binary serialization to a strict ByteString.
 encode :: Serialize a => a -> ByteString
 encode = runPut . put
 
+-- | Encode a value using binary serialization to a lazy ByteString.
+encodeLazy :: Serialize a => a -> L.ByteString
+encodeLazy  = runPutLazy . put
+
 -- | Decode a value from a strict ByteString, reconstructing the original
 -- structure.
---
 decode :: Serialize a => ByteString -> Either String a
 decode = runGet get
+
+-- | Decode a value from a lazy ByteString, reconstructing the original
+-- structure.
+decodeLazy :: Serialize a => L.ByteString -> Either String a
+decodeLazy  = runGetLazy get
 
 ------------------------------------------------------------------------
 -- Simple instances
diff --git a/src/Data/Serialize/Builder.hs b/src/Data/Serialize/Builder.hs
--- a/src/Data/Serialize/Builder.hs
+++ b/src/Data/Serialize/Builder.hs
@@ -58,10 +58,9 @@
 
 import Data.Monoid
 import Foreign
-import qualified Data.ByteString               as S
-import qualified Data.ByteString.Lazy          as L
-import qualified Data.ByteString.Internal      as S
-import qualified Data.ByteString.Lazy.Internal as L
+import qualified Data.ByteString          as S
+import qualified Data.ByteString.Lazy     as L
+import qualified Data.ByteString.Internal as S
 
 #if defined(__GLASGOW_HASKELL__) && !defined(__HADDOCK__)
 import GHC.Base
diff --git a/src/Data/Serialize/Get.hs b/src/Data/Serialize/Get.hs
--- a/src/Data/Serialize/Get.hs
+++ b/src/Data/Serialize/Get.hs
@@ -26,7 +26,9 @@
     -- * The Get type
       Get
     , runGet
+    , runGetLazy
     , runGetState
+    , runGetLazyState
     , Result(..)
     , runGetPartial
 
@@ -198,6 +200,18 @@
   Partial{} -> Left "Failed reading: Internal error: unexpected Partial."
 {-# INLINE runGet #-}
 
+-- | Run the Get monad over a Lazy ByteString.  Note that this will not run the
+-- Get parser lazily, but will operate on lazy ByteStrings.
+runGetLazy :: Get a -> L.ByteString -> Either String a
+runGetLazy m lstr = loop (runGetPartial m) (L.toChunks lstr)
+  where
+  loop _ []     = Left "Failed reading: Internal error: unexpected end of input"
+  loop k (c:cs) = case k c of
+    Fail str   -> Left str
+    Partial k' -> loop k' cs
+    Done r _   -> Right r
+{-# INLINE runGetLazy #-}
+
 -- | Run the Get monad applies a 'get'-based parser on the input ByteString
 runGetPartial :: Get a -> B.ByteString -> Result a
 runGetPartial m str = unGet m str Incomplete failK finalK
@@ -214,6 +228,18 @@
       Done a bs   -> Right (a, bs)
       Partial{}   -> Left "Failed reading: Internal error: unexpected Partial."
 {-# INLINE runGetState #-}
+
+-- | Run the Get monad over a Lazy ByteString.  Note that this does not run the
+-- Get parser lazily, but will operate on lazy ByteStrings.
+runGetLazyState :: Get a -> L.ByteString -> Either String (a,L.ByteString)
+runGetLazyState m lstr = loop (runGetPartial m) (L.toChunks lstr)
+  where
+  loop _ []     = Left "Failed reading: Internal error: unexpected end of input"
+  loop k (c:cs) = case k c of
+    Fail str   -> Left str
+    Partial k' -> loop k' cs
+    Done r c'  -> Right (r,L.fromChunks (c':cs))
+{-# INLINE runGetLazyState #-}
 
 ------------------------------------------------------------------------
 
diff --git a/src/Data/Serialize/Put.hs b/src/Data/Serialize/Put.hs
--- a/src/Data/Serialize/Put.hs
+++ b/src/Data/Serialize/Put.hs
@@ -20,6 +20,8 @@
     , Putter
     , runPut
     , runPutM
+    , runPutLazy
+    , runPutMLazy
     , putBuilder
     , execPut
 
@@ -62,12 +64,11 @@
 
   ) where
 
-import Data.Serialize.Builder (Builder, toByteString)
+import Data.Serialize.Builder (Builder, toByteString, toLazyByteString)
 import qualified Data.Serialize.Builder as B
 
 import Control.Applicative
 import Data.Array.Unboxed
-import Data.Ix
 import Data.Monoid
 import Data.Word
 import qualified Data.ByteString        as S
@@ -150,6 +151,16 @@
 runPutM :: PutM a -> (a, S.ByteString)
 runPutM (Put (PairS f s)) = (f, toByteString s)
 {-# INLINE runPutM #-}
+
+-- | Run the 'Put' monad with a serialiser
+runPutLazy :: Put -> L.ByteString
+runPutLazy = toLazyByteString . sndS . unPut
+{-# INLINE runPutLazy #-}
+
+-- | Run the 'Put' monad with a serialiser
+runPutMLazy :: PutM a -> (a, L.ByteString)
+runPutMLazy (Put (PairS f s)) = (f, toLazyByteString s)
+{-# INLINE runPutMLazy #-}
 
 ------------------------------------------------------------------------