diff --git a/bencode.cabal b/bencode.cabal
--- a/bencode.cabal
+++ b/bencode.cabal
@@ -1,15 +1,16 @@
-Name: bencode
-Version: 0.2
-Maintainer: Lemmih (lemmih@gmail.com)
-Author: Lemmih (lemmih@gmail.com), Jesper Louis Andersen
-Copyright: 2005-2007, Lemmih
-License-File: LICENSE
-License: BSD3
-Build-Depends: base, parsec, binary
-Category: Text
-Synopsis: Parser and printer for bencoded data.
-Tested-with: GHC ==6.6
-Extensions: PatternGuards
+Name:           bencode
+Version:        0.3
+Maintainer:     Lemmih (lemmih@gmail.com)
+Author:         Lemmih (lemmih@gmail.com), Jesper Louis Andersen
+Copyright:      2005-2007, Lemmih
+License-File:   LICENSE
+License:        BSD3
+Build-Depends:  base, parsec, bytestring, containers, binary
+Build-Type:     Simple
+Category:       Text
+Synopsis:       Parser and printer for bencoded data.
+Tested-with:    GHC ==6.8.1
+Extensions:     PatternGuards
 Exposed-Modules:
   Data.BEncode
   Data.BEncode.Lexer
diff --git a/src/Data/BEncode.hs b/src/Data/BEncode.hs
--- a/src/Data/BEncode.hs
+++ b/src/Data/BEncode.hs
@@ -36,14 +36,16 @@
    -- * Data types
    BEncode(..),  
    -- * Functions
-   bRead,        
-   bShow,        
+   bRead,
+   bShow,
+   bPack
   )
 where
 
 import qualified Data.Map as Map
 import Data.Map (Map)
 import Text.ParserCombinators.Parsec
+import qualified Data.ByteString.Lazy.Char8 as L
 import qualified Data.ByteString.Char8 as BS
 import Data.ByteString (ByteString)
 import Data.Binary
@@ -63,9 +65,9 @@
 	       deriving (Eq, Ord, Show)
 
 instance Binary BEncode where
-    put e = put (BS.pack $ bShow e "")
+    put e = put (BS.concat $ L.toChunks $ bPack e)
     get = do s <- get
-             case bRead s of
+             case bRead (L.fromChunks [s]) of
                Just e  -> return e
                Nothing -> fail "Failed to parse BEncoded data"
 
@@ -120,7 +122,7 @@
 {- | bRead is a conversion routine. It assumes a B-coded string as input
      and attempts a parse of it into a BEncode data type
 -}
-bRead :: ByteString -> Maybe BEncode
+bRead :: L.ByteString -> Maybe BEncode
 bRead str = case parse bParse "" (lexer str) of
 	     Left _err -> Nothing
 	     Right b   -> Just b
@@ -141,3 +143,18 @@
         BString s -> sString (BS.unpack s) (BS.length s)
         BList bl  -> sc 'l' . sList bl . sc 'e'
         BDict bd  -> sc 'd' . sDict bd . sc 'e'
+
+bPack :: BEncode -> L.ByteString
+bPack be = L.fromChunks (bPack' be [])
+    where intTag = BS.pack "i"
+          colonTag = BS.pack ":"
+          endTag = BS.pack "e"
+          listTag = BS.pack "l"
+          dictTag = BS.pack "d"
+          sString s r = BS.pack (show (BS.length s)) : colonTag : s : r
+          bPack' (BInt i) r = intTag : BS.pack (show i) : endTag : r
+          bPack' (BString s) r = sString s r
+          bPack' (BList bl) r = listTag : foldr bPack' (endTag : r) bl
+          bPack' (BDict bd) r = dictTag : foldr (\(k,v) -> sString (BS.pack k) . bPack' v) (endTag : r) (Map.toAscList bd)
+
+--check be = bShow be "" == L.unpack (bPack be)
diff --git a/src/Data/BEncode/Lexer.hs b/src/Data/BEncode/Lexer.hs
--- a/src/Data/BEncode/Lexer.hs
+++ b/src/Data/BEncode/Lexer.hs
@@ -2,6 +2,7 @@
 
 import Data.Char
 
+import qualified Data.ByteString.Lazy.Char8 as L
 import qualified Data.ByteString.Char8 as BS
 import Data.ByteString (ByteString)
 
@@ -15,27 +16,27 @@
       deriving (Show,Eq)
 
 
-lexer :: ByteString -> [Token]
-lexer fs | BS.null fs = []
+lexer :: L.ByteString -> [Token]
+lexer fs | L.null fs = []
 lexer fs
     = case ch of
         'd' -> TDict : lexer rest
         'l' -> TList : lexer rest
         'i' -> TInt  : lexer rest
         'e' -> TEnd  : lexer rest
-        '-' -> let (digits,rest') = BS.span isDigit rest
-                   number = read (BS.unpack digits)
+        '-' -> let (digits,rest') = L.span isDigit rest
+                   number = read (L.unpack digits)
                in TNumber (-number) : lexer rest'
         _ | isDigit ch
-              -> let (digits,rest') = BS.span isDigit fs
-                     number = read (BS.unpack digits)
-                 in if BS.null rest'
+              -> let (digits,rest') = L.span isDigit fs
+                     number = read (L.unpack digits)
+                 in if L.null rest'
                        then [TNumber number]
-                       else case BS.head rest' of
-                              ':' -> let (str, rest'') = BS.splitAt number (BS.tail rest')
-                                     in TString str : lexer rest''
+                       else case L.head rest' of
+                              ':' -> let (str, rest'') = L.splitAt (fromIntegral number) (L.tail rest')
+                                     in TString (BS.concat $ L.toChunks str) : lexer rest''
                               _ -> TNumber number : lexer rest'
           | otherwise -> error "Lexer error."
-    where ch = BS.head fs
-          rest = BS.tail fs
+    where ch = L.head fs
+          rest = L.tail fs