diff --git a/Data/Conduit/Blaze.hs b/Data/Conduit/Blaze.hs
--- a/Data/Conduit/Blaze.hs
+++ b/Data/Conduit/Blaze.hs
@@ -41,9 +41,8 @@
   , builderToByteStringWithFlush
     ) where
 
-import Data.Conduit hiding (SinkResult (Done))
-import Control.Monad.Trans.Resource
-import Control.Monad.Trans.Class
+import Data.Conduit hiding (Sink (Done))
+import Control.Monad (liftM)
 
 import qualified Data.ByteString                   as S
 
@@ -53,14 +52,14 @@
 
 -- | Incrementally execute builders and pass on the filled chunks as
 -- bytestrings.
-builderToByteString :: ResourceUnsafeIO m => Conduit Builder m S.ByteString
+builderToByteString :: MonadUnsafeIO m => Conduit Builder m S.ByteString
 builderToByteString =
   builderToByteStringWith (allNewBuffersStrategy defaultBufferSize)
 
 -- |
 --
 -- Since 0.0.2
-builderToByteStringFlush :: ResourceUnsafeIO m => Conduit (Flush Builder) m (Flush S.ByteString)
+builderToByteStringFlush :: MonadUnsafeIO m => Conduit (Flush Builder) m (Flush S.ByteString)
 builderToByteStringFlush =
   builderToByteStringWithFlush (allNewBuffersStrategy defaultBufferSize)
 
@@ -71,7 +70,7 @@
 -- WARNING: This conduit yields bytestrings that are NOT
 -- referentially transparent. Their content will be overwritten as soon
 -- as control is returned from the inner sink!
-unsafeBuilderToByteString :: ResourceUnsafeIO m
+unsafeBuilderToByteString :: MonadUnsafeIO m
                           => IO Buffer  -- action yielding the inital buffer.
                           -> Conduit Builder m S.ByteString
 unsafeBuilderToByteString = builderToByteStringWith . reuseBufferStrategy
@@ -81,7 +80,7 @@
 -- filled chunks as bytestrings to an inner sink.
 --
 -- INV: All bytestrings passed to the inner sink are non-empty.
-builderToByteStringWith :: ResourceUnsafeIO m
+builderToByteStringWith :: MonadUnsafeIO m
                         => BufferAllocStrategy
                         -> Conduit Builder m S.ByteString
 builderToByteStringWith (ioBuf0, nextBuf) = conduitState
@@ -89,7 +88,7 @@
     (push nextBuf)
     close
   where
-    close ioBuf = lift $ unsafeFromIO $ do
+    close ioBuf = unsafeLiftIO $ do
         buf <- ioBuf
         return $ maybe [] return $ unsafeFreezeNonEmptyBuffer buf
 
@@ -97,7 +96,7 @@
 --
 -- Since 0.0.2
 builderToByteStringWithFlush
-    :: ResourceUnsafeIO m
+    :: MonadUnsafeIO m
     => BufferAllocStrategy
     -> Conduit (Flush Builder) m (Flush S.ByteString)
 builderToByteStringWithFlush (ioBuf0, nextBuf) = conduitState
@@ -105,14 +104,14 @@
     push'
     close
   where
-    close ioBuf = lift $ unsafeFromIO $ do
+    close ioBuf = unsafeLiftIO $ do
         buf <- ioBuf
         return $ maybe [] (return . Chunk) $ unsafeFreezeNonEmptyBuffer buf
 
-    push' :: ResourceUnsafeIO m
+    push' :: MonadUnsafeIO m
           => IO Buffer
           -> Flush Builder
-          -> ResourceT m (ConduitStateResult (IO Buffer) input (Flush S.ByteString))
+          -> m (ConduitStateResult (IO Buffer) input (Flush S.ByteString))
     push' ioBuf Flush = do
         StateProducing ioBuf' chunks <- push nextBuf ioBuf flush
         let myFold bs rest
@@ -120,14 +119,14 @@
                 | otherwise = Chunk bs : rest
             chunks' = foldr myFold [Flush] chunks
         return $ StateProducing ioBuf' chunks'
-    push' ioBuf (Chunk builder) = (fmap . fmap) Chunk (push nextBuf ioBuf builder)
+    push' ioBuf (Chunk builder) = (liftM . fmap) Chunk (push nextBuf ioBuf builder)
 
-push :: ResourceUnsafeIO m
+push :: MonadUnsafeIO m
      => (Int -> Buffer -> IO (IO Buffer))
      -> IO Buffer
      -> Builder
-     -> ResourceT m (ConduitStateResult (IO Buffer) input S.ByteString)
-push nextBuf ioBuf0 x = lift $ unsafeFromIO $ do
+     -> m (ConduitStateResult (IO Buffer) input S.ByteString)
+push nextBuf ioBuf0 x = unsafeLiftIO $ do
     (ioBuf', front) <- go (unBuilder x (buildStep finalStep)) ioBuf0 id
     return $ StateProducing ioBuf' $ front []
   where
diff --git a/blaze-builder-conduit.cabal b/blaze-builder-conduit.cabal
--- a/blaze-builder-conduit.cabal
+++ b/blaze-builder-conduit.cabal
@@ -1,5 +1,5 @@
 Name:                blaze-builder-conduit
-Version:             0.2.0.1
+Version:             0.3.0
 Synopsis:            Convert streams of builders to streams of bytestrings.
 Description:         Convert streams of builders to streams of bytestrings.
 License:             BSD3
@@ -20,7 +20,7 @@
                      , bytestring               >= 0.9
                      , text                     >= 0.11
                      , blaze-builder            >= 0.2.1.4      && < 0.4
-                     , conduit                  >= 0.2          && < 0.3
+                     , conduit                  >= 0.3          && < 0.4
   ghc-options:     -Wall
 
 test-suite test
diff --git a/test/main.hs b/test/main.hs
--- a/test/main.hs
+++ b/test/main.hs
@@ -9,19 +9,17 @@
 import qualified Data.Conduit.List as CL
 import Data.ByteString.Char8 ()
 import Data.Conduit.Blaze (builderToByteString, builderToByteStringFlush)
-import Data.Conduit (runResourceT)
 import Control.Monad.ST (runST)
 import Data.Monoid
 import qualified Data.ByteString as S
 import Blaze.ByteString.Builder (fromByteString, toLazyByteString, insertLazyByteString)
 import qualified Data.ByteString.Lazy as L
 import Data.ByteString.Lazy.Char8 ()
-import Control.Monad.IO.Class (liftIO)
 
 main :: IO ()
 main = hspecX $ do
     describe "blaze" $ do
-        prop "idempotent to toLazyByteString" $ \bss' -> runST $ runResourceT $ do
+        prop "idempotent to toLazyByteString" $ \bss' -> runST $ do
             let bss = map S.pack bss'
             let builders = map fromByteString bss
             let lbs = toLazyByteString $ mconcat builders
@@ -29,21 +27,21 @@
             outBss <- src C.$= builderToByteString C.$$ CL.consume
             return $ lbs == L.fromChunks outBss
 
-        it "works for large input" $ runResourceT $ do
+        it "works for large input" $ do
             let builders = replicate 10000 (fromByteString "hello world!")
             let lbs = toLazyByteString $ mconcat builders
             let src = mconcat $ map (CL.sourceList . return) builders
-            outBss <- src C.$= builderToByteString C.$$ CL.consume :: C.ResourceT IO [S.ByteString]
-            liftIO $ lbs @=? L.fromChunks outBss
+            outBss <- src C.$= builderToByteString C.$$ CL.consume
+            lbs @=? L.fromChunks outBss
 
-        it "works for lazy bytestring insertion" $ runResourceT $ do
+        it "works for lazy bytestring insertion" $ do
             let builders = replicate 10000 (insertLazyByteString "hello world!")
             let lbs = toLazyByteString $ mconcat builders
             let src = mconcat $ map (CL.sourceList . return) builders
-            outBss <- src C.$= builderToByteString C.$$ CL.consume :: C.ResourceT IO [S.ByteString]
-            liftIO $ lbs @=? L.fromChunks outBss
+            outBss <- src C.$= builderToByteString C.$$ CL.consume
+            lbs @=? L.fromChunks outBss
 
-        prop "flushing" $ \bss' -> runST $ runResourceT $ do
+        prop "flushing" $ \bss' -> runST $ do
             let bss = concatMap (\bs -> [C.Chunk $ S.pack bs, C.Flush]) $ filter (not . null) bss'
             let src = CL.sourceList $ map (fmap fromByteString) bss
             outBss <- src C.$= builderToByteStringFlush C.$$ CL.consume