diff --git a/Data/Conduit/Blaze.hs b/Data/Conduit/Blaze.hs
--- a/Data/Conduit/Blaze.hs
+++ b/Data/Conduit/Blaze.hs
@@ -63,6 +63,7 @@
 builderToByteString :: (MonadBase base m, PrimMonad base) => Conduit Builder m S.ByteString
 builderToByteString =
   builderToByteStringWith defaultStrategy
+{-# INLINE builderToByteString #-}
 
 -- |
 --
@@ -70,6 +71,7 @@
 builderToByteStringFlush :: (MonadBase base m, PrimMonad base) => Conduit (Flush Builder) m (Flush S.ByteString)
 builderToByteStringFlush =
   builderToByteStringWithFlush defaultStrategy
+{-# INLINE builderToByteStringFlush #-}
 
 -- | Incrementally execute builders on the given buffer and pass on the filled
 -- chunks as bytestrings. Note that, if the given buffer is too small for the
@@ -82,6 +84,7 @@
                           => IO Buffer  -- action yielding the inital buffer.
                           -> Conduit Builder m S.ByteString
 unsafeBuilderToByteString = builderToByteStringWith . reuseBufferStrategy
+{-# INLINE unsafeBuilderToByteString #-}
 
 
 -- | A conduit that incrementally executes builders and passes on the
@@ -96,6 +99,7 @@
   where
     yield' Flush = return ()
     yield' (Chunk bs) = yield bs
+{-# INLINE builderToByteStringWith #-}
 
 -- |
 --
@@ -105,6 +109,7 @@
     => BufferAllocStrategy
     -> Conduit (Flush Builder) m (Flush S.ByteString)
 builderToByteStringWithFlush = helper await yield
+{-# INLINE builderToByteStringWithFlush #-}
 
 helper :: (MonadBase base m, PrimMonad base, Monad (t m), MonadTrans t)
        => t m (Maybe (Flush Builder))
@@ -134,3 +139,4 @@
                 Chunk _ -> return ()
             loop
     loop
+{-# INLINE helper #-}
diff --git a/bench/blaze.hs b/bench/blaze.hs
new file mode 100644
--- /dev/null
+++ b/bench/blaze.hs
@@ -0,0 +1,72 @@
+{-# LANGUAGE OverloadedStrings #-}
+import Data.Conduit
+import qualified Data.Conduit.List as CL
+import Data.Conduit.Blaze
+import Criterion.Main
+import Blaze.ByteString.Builder
+import Data.Monoid
+import qualified Data.ByteString.Builder as BS
+import Data.Functor.Identity (runIdentity)
+import Control.Monad.ST (runST)
+import Data.ByteString.Lazy.Internal (defaultChunkSize)
+
+count :: Int
+count = 100000
+
+single :: Builder
+single = copyByteString "Hello World!\n"
+
+oneBuilderLeft :: Builder
+oneBuilderLeft =
+    loop count mempty
+  where
+    loop 0 b = b
+    loop i b = loop (i - 1) (b <> single)
+
+oneBuilderRight :: Builder
+oneBuilderRight =
+    loop count mempty
+  where
+    loop 0 b = b
+    loop i b = loop (i - 1) (b <> single)
+
+builderSource :: Monad m => Source m Builder
+builderSource = CL.replicate count single
+
+singleBS :: BS.Builder
+singleBS = BS.shortByteString "Hello World!\n"
+
+oneBSBuilderLeft :: BS.Builder
+oneBSBuilderLeft =
+    loop count mempty
+  where
+    loop 0 b = b
+    loop i b = loop (i - 1) (b <> singleBS)
+
+oneBSBuilderRight :: BS.Builder
+oneBSBuilderRight =
+    loop count mempty
+  where
+    loop 0 b = b
+    loop i b = loop (i - 1) (b <> singleBS)
+
+builderBSSource :: Monad m => Source m BS.Builder
+builderBSSource = CL.replicate count singleBS
+
+main :: IO ()
+main = defaultMain
+    [ bench "conduit, strict, safe" $ whnfIO $
+        builderSource $$ builderToByteString =$ CL.sinkNull
+    , bench "conduit, strict, unsafe" $ whnfIO $
+        builderSource $$ unsafeBuilderToByteString (allocBuffer defaultChunkSize) =$ CL.sinkNull
+
+    , bench "one builder, left" $ nf toLazyByteString oneBuilderLeft
+    , bench "one builder, right" $ nf toLazyByteString oneBuilderRight
+    , bench "conduit, lazy" $ flip nf builderSource $ \src ->
+        toLazyByteString $ runIdentity $ src $$ CL.fold (<>) mempty
+
+    , bench "one bs builder, left" $ nf BS.toLazyByteString oneBSBuilderLeft
+    , bench "one bs builder, right" $ nf BS.toLazyByteString oneBSBuilderRight
+    , bench "conduit BS, lazy" $ flip nf builderBSSource $ \src ->
+        BS.toLazyByteString $ runIdentity $ src $$ CL.fold (<>) mempty
+    ]
diff --git a/conduit-extra.cabal b/conduit-extra.cabal
--- a/conduit-extra.cabal
+++ b/conduit-extra.cabal
@@ -1,5 +1,5 @@
 Name:                conduit-extra
-Version:             1.1.4
+Version:             1.1.4.1
 Synopsis:            Batteries included conduit: adapters for common libraries.
 Description:
     The conduit package itself maintains relative small dependencies. The purpose of this package is to collect commonly used utility functions wrapping other library dependencies, without depending on heavier-weight dependencies. The basic idea is that this package should only depend on haskell-platform packages and conduit.
@@ -89,6 +89,20 @@
                      Data.Conduit.ProcessSpec
                      Data.Conduit.TextSpec
                      Data.Conduit.ZlibSpec
+
+benchmark blaze
+    type:           exitcode-stdio-1.0
+    hs-source-dirs: bench
+    build-depends:  base
+                  , blaze-builder
+                  , conduit
+                  , conduit-extra
+                  , criterion
+                  , bytestring
+                  , bytestring-builder
+                  , transformers
+    main-is:        blaze.hs
+    ghc-options:    -Wall -O2 -rtsopts
 
 source-repository head
   type:     git