diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2015, Index Int
+Copyright (c) 2015, Vladislav Zavialov
 
 All rights reserved.
 
@@ -13,7 +13,7 @@
       disclaimer in the documentation and/or other materials provided
       with the distribution.
 
-    * Neither the name of Index Int nor the names of other
+    * Neither the name of Vladislav Zavialov nor the names of other
       contributors may be used to endorse or promote products derived
       from this software without specific prior written permission.
 
diff --git a/src/Control/Monad/Trans/Lift/CallCC.hs b/src/Control/Monad/Trans/Lift/CallCC.hs
--- a/src/Control/Monad/Trans/Lift/CallCC.hs
+++ b/src/Control/Monad/Trans/Lift/CallCC.hs
@@ -23,10 +23,13 @@
 import qualified Control.Monad.Trans.Reader        as R
 import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy
 import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict
+import qualified Control.Monad.Trans.RWS.CPS       as RWS.CPS
 import qualified Control.Monad.Trans.State.Lazy    as S.Lazy
 import qualified Control.Monad.Trans.State.Strict  as S.Strict
 import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy
 import qualified Control.Monad.Trans.Writer.Strict as W.Strict
+import qualified Control.Monad.Trans.Writer.CPS    as W.CPS
+import qualified Control.Monad.Trans.Accum         as Acc
 
 import Control.Monad.Trans.Lift.StT
 
@@ -73,38 +76,66 @@
 
 instance LiftCallCC (E.ExceptT e) where
     liftCallCC  = E.liftCallCC
+    {-# INLINE liftCallCC #-}
 
 instance LiftCallCC I.IdentityT where
     liftCallCC  = I.liftCallCC
+    {-# INLINE liftCallCC #-}
 
 instance LiftCallCC L.ListT where
     liftCallCC  = L.liftCallCC
+    {-# INLINE liftCallCC #-}
 
 instance LiftCallCC M.MaybeT where
     liftCallCC  = M.liftCallCC
+    {-# INLINE liftCallCC #-}
 
 instance LiftCallCC (R.ReaderT r) where
     liftCallCC  = R.liftCallCC
+    {-# INLINE liftCallCC #-}
 
 instance Monoid w => LiftCallCC (W.Lazy.WriterT w) where
     liftCallCC  = W.Lazy.liftCallCC
+    {-# INLINE liftCallCC #-}
 
 instance Monoid w => LiftCallCC (W.Strict.WriterT w) where
     liftCallCC  = W.Strict.liftCallCC
+    {-# INLINE liftCallCC #-}
 
+instance Monoid w => LiftCallCC (W.CPS.WriterT w) where
+    liftCallCC  = W.CPS.liftCallCC
+    {-# INLINE liftCallCC #-}
+
 instance Monoid w => LiftCallCC (RWS.Lazy.RWST r w s) where
     liftCallCC  = RWS.Lazy.liftCallCC
+    {-# INLINE liftCallCC #-}
     liftCallCC' = RWS.Lazy.liftCallCC'
+    {-# INLINE liftCallCC' #-}
 
 instance Monoid w => LiftCallCC (RWS.Strict.RWST r w s) where
     liftCallCC  = RWS.Strict.liftCallCC
+    {-# INLINE liftCallCC #-}
     liftCallCC' = RWS.Strict.liftCallCC'
+    {-# INLINE liftCallCC' #-}
 
+instance Monoid w => LiftCallCC (RWS.CPS.RWST r w s) where
+    liftCallCC  = RWS.CPS.liftCallCC
+    {-# INLINE liftCallCC #-}
+    liftCallCC' = RWS.CPS.liftCallCC'
+    {-# INLINE liftCallCC' #-}
+
 instance LiftCallCC (S.Lazy.StateT s) where
     liftCallCC  = S.Lazy.liftCallCC
+    {-# INLINE liftCallCC #-}
     liftCallCC' = S.Lazy.liftCallCC'
+    {-# INLINE liftCallCC' #-}
 
 instance LiftCallCC (S.Strict.StateT s) where
     liftCallCC  = S.Strict.liftCallCC
+    {-# INLINE liftCallCC #-}
     liftCallCC' = S.Strict.liftCallCC'
+    {-# INLINE liftCallCC' #-}
 
+instance Monoid w => LiftCallCC (Acc.AccumT w) where
+    liftCallCC  = Acc.liftCallCC
+    {-# INLINE liftCallCC #-}
diff --git a/src/Control/Monad/Trans/Lift/Catch.hs b/src/Control/Monad/Trans/Lift/Catch.hs
--- a/src/Control/Monad/Trans/Lift/Catch.hs
+++ b/src/Control/Monad/Trans/Lift/Catch.hs
@@ -22,10 +22,13 @@
 import qualified Control.Monad.Trans.Reader        as R
 import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy
 import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict
+import qualified Control.Monad.Trans.RWS.CPS       as RWS.CPS
 import qualified Control.Monad.Trans.State.Lazy    as S.Lazy
 import qualified Control.Monad.Trans.State.Strict  as S.Strict
 import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy
 import qualified Control.Monad.Trans.Writer.Strict as W.Strict
+import qualified Control.Monad.Trans.Writer.CPS    as W.CPS
+import qualified Control.Monad.Trans.Accum         as Acc
 
 import Control.Monad.Trans.Lift.StT
 
@@ -50,33 +53,56 @@
 
 instance LiftCatch (E.ExceptT e) where
     liftCatch f m h = E.ExceptT $ f (E.runExceptT m) (E.runExceptT . h)
+    {-# INLINE liftCatch #-}
 
 instance LiftCatch I.IdentityT where
     liftCatch = I.liftCatch
+    {-# INLINE liftCatch #-}
 
 instance LiftCatch L.ListT where
     liftCatch = L.liftCatch
+    {-# INLINE liftCatch #-}
 
 instance LiftCatch M.MaybeT where
     liftCatch = M.liftCatch
+    {-# INLINE liftCatch #-}
 
 instance LiftCatch (R.ReaderT r) where
     liftCatch = R.liftCatch
+    {-# INLINE liftCatch #-}
 
 instance Monoid w => LiftCatch (RWS.Lazy.RWST r w s) where
     liftCatch = RWS.Lazy.liftCatch
+    {-# INLINE liftCatch #-}
 
 instance Monoid w => LiftCatch (RWS.Strict.RWST r w s) where
     liftCatch = RWS.Strict.liftCatch
+    {-# INLINE liftCatch #-}
 
+instance Monoid w => LiftCatch (RWS.CPS.RWST r w s) where
+    liftCatch = RWS.CPS.liftCatch
+    {-# INLINE liftCatch #-}
+
 instance LiftCatch (S.Lazy.StateT s) where
     liftCatch = S.Lazy.liftCatch
+    {-# INLINE liftCatch #-}
 
 instance LiftCatch (S.Strict.StateT s) where
     liftCatch = S.Strict.liftCatch
+    {-# INLINE liftCatch #-}
 
 instance Monoid w => LiftCatch (W.Lazy.WriterT w) where
     liftCatch = W.Lazy.liftCatch
+    {-# INLINE liftCatch #-}
 
 instance Monoid w => LiftCatch (W.Strict.WriterT w) where
     liftCatch = W.Strict.liftCatch
+    {-# INLINE liftCatch #-}
+
+instance Monoid w => LiftCatch (W.CPS.WriterT w) where
+    liftCatch = W.CPS.liftCatch
+    {-# INLINE liftCatch #-}
+
+instance Monoid w => LiftCatch (Acc.AccumT w) where
+    liftCatch = Acc.liftCatch
+    {-# INLINE liftCatch #-}
diff --git a/src/Control/Monad/Trans/Lift/Listen.hs b/src/Control/Monad/Trans/Lift/Listen.hs
--- a/src/Control/Monad/Trans/Lift/Listen.hs
+++ b/src/Control/Monad/Trans/Lift/Listen.hs
@@ -15,16 +15,19 @@
 import Control.Monad.Signatures
 import Control.Monad.Trans.Class
 
-import qualified Control.Monad.Trans.Except        as E
-import qualified Control.Monad.Trans.Identity      as I
-import qualified Control.Monad.Trans.Maybe         as M
-import qualified Control.Monad.Trans.Reader        as R
-import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy
-import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict
-import qualified Control.Monad.Trans.State.Lazy    as S.Lazy
-import qualified Control.Monad.Trans.State.Strict  as S.Strict
-import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy
-import qualified Control.Monad.Trans.Writer.Strict as W.Strict
+import qualified Control.Monad.Trans.Except              as E
+import qualified Control.Monad.Trans.Identity            as I
+import qualified Control.Monad.Trans.Maybe               as M
+import qualified Control.Monad.Trans.Reader              as R
+import qualified Control.Monad.Trans.RWS.Lazy            as RWS.Lazy
+import qualified Control.Monad.Trans.RWS.Strict          as RWS.Strict
+import qualified Control.Monad.Trans.RWS.CPS.Internal    as RWS.CPS
+import qualified Control.Monad.Trans.State.Lazy          as S.Lazy
+import qualified Control.Monad.Trans.State.Strict        as S.Strict
+import qualified Control.Monad.Trans.Writer.Lazy         as W.Lazy
+import qualified Control.Monad.Trans.Writer.Strict       as W.Strict
+import qualified Control.Monad.Trans.Writer.CPS.Internal as W.CPS
+import qualified Control.Monad.Trans.Accum               as Acc
 
 import Control.Monad.Trans.Lift.StT
 
@@ -49,38 +52,64 @@
 
 instance LiftListen (E.ExceptT e) where
     liftListen = E.liftListen
+    {-# INLINE liftListen #-}
 
 instance LiftListen I.IdentityT where
     liftListen = I.mapIdentityT
+    {-# INLINE liftListen #-}
 
 instance LiftListen M.MaybeT where
     liftListen = M.liftListen
+    {-# INLINE liftListen #-}
 
 instance LiftListen (R.ReaderT r) where
     liftListen = R.mapReaderT
+    {-# INLINE liftListen #-}
 
 instance LiftListen (S.Lazy.StateT s) where
     liftListen = S.Lazy.liftListen
+    {-# INLINE liftListen #-}
 
 instance LiftListen (S.Strict.StateT s) where
     liftListen = S.Strict.liftListen
+    {-# INLINE liftListen #-}
 
 instance Monoid w' => LiftListen (RWS.Lazy.RWST r w' s) where
     liftListen listen m = RWS.Lazy.RWST $ \r s -> do
         ~((a, w', s'), w) <- listen (RWS.Lazy.runRWST m r s)
         return ((a, w), w', s')
+    {-# INLINE liftListen #-}
 
 instance Monoid w' => LiftListen (RWS.Strict.RWST r w' s) where
     liftListen listen m = RWS.Strict.RWST $ \r s -> do
         ((a, w', s'), w) <- listen (RWS.Strict.runRWST m r s)
         return ((a, w), w', s')
+    {-# INLINE liftListen #-}
 
+instance Monoid w' => LiftListen (RWS.CPS.RWST r w' s) where
+    liftListen listen m = RWS.CPS.RWST $ \r w_ s -> do
+        ((a, w', s'), w) <- listen (RWS.CPS.unRWST m r w_ s)
+        return ((a, w), w', s')
+    {-# INLINE liftListen #-}
+
 instance Monoid w' => LiftListen (W.Lazy.WriterT w') where
     liftListen listen m = W.Lazy.WriterT $ do
         ~((a, w'), w) <- listen (W.Lazy.runWriterT m)
         return ((a, w), w')
+    {-# INLINE liftListen #-}
 
 instance Monoid w' => LiftListen (W.Strict.WriterT w') where
     liftListen listen m = W.Strict.WriterT $ do
         ((a, w'), w) <- listen (W.Strict.runWriterT m)
         return ((a, w), w')
+    {-# INLINE liftListen #-}
+
+instance Monoid w' => LiftListen (W.CPS.WriterT w') where
+    liftListen listen m = W.CPS.WriterT $ \w_ -> do
+        ((a, w'), w) <- listen (W.CPS.unWriterT m w_)
+        return ((a, w), w')
+    {-# INLINE liftListen #-}
+
+instance Monoid w' => LiftListen (Acc.AccumT w') where
+    liftListen = Acc.liftListen
+    {-# INLINE liftListen #-}
diff --git a/src/Control/Monad/Trans/Lift/Local.hs b/src/Control/Monad/Trans/Lift/Local.hs
--- a/src/Control/Monad/Trans/Lift/Local.hs
+++ b/src/Control/Monad/Trans/Lift/Local.hs
@@ -22,10 +22,13 @@
 import qualified Control.Monad.Trans.Reader        as R
 import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy
 import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict
+import qualified Control.Monad.Trans.RWS.CPS       as RWS.CPS
 import qualified Control.Monad.Trans.State.Lazy    as S.Lazy
 import qualified Control.Monad.Trans.State.Strict  as S.Strict
 import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy
 import qualified Control.Monad.Trans.Writer.Strict as W.Strict
+import qualified Control.Monad.Trans.Writer.CPS    as W.CPS
+import qualified Control.Monad.Trans.Accum         as Acc
 
 -- | Signature of the @local@ operation,
 -- introduced in "Control.Monad.Trans.Reader".
@@ -51,36 +54,60 @@
 
 instance LiftLocal (C.ContT r) where
     liftLocal a l f = C.liftLocal a l f
+    {-# INLINE liftLocal #-}
 
 instance LiftLocal (E.ExceptT e) where
     liftLocal _ l f = E.mapExceptT (l f)
+    {-# INLINE liftLocal #-}
 
 instance LiftLocal I.IdentityT where
     liftLocal _ l f = I.mapIdentityT (l f)
+    {-# INLINE liftLocal #-}
 
 instance LiftLocal L.ListT where
     liftLocal _ l f = L.mapListT (l f)
+    {-# INLINE liftLocal #-}
 
 instance LiftLocal M.MaybeT where
     liftLocal _ l f = M.mapMaybeT (l f)
+    {-# INLINE liftLocal #-}
 
 instance LiftLocal (R.ReaderT r) where
     liftLocal _ l f = R.mapReaderT (l f)
+    {-# INLINE liftLocal #-}
 
 instance Monoid w => LiftLocal (RWS.Lazy.RWST r w s) where
     liftLocal _ l f = RWS.Lazy.mapRWST (l f)
+    {-# INLINE liftLocal #-}
 
 instance Monoid w => LiftLocal (RWS.Strict.RWST r w s) where
     liftLocal _ l f = RWS.Strict.mapRWST (l f)
+    {-# INLINE liftLocal #-}
 
+instance Monoid w => LiftLocal (RWS.CPS.RWST r w s) where
+    liftLocal _ l f = RWS.CPS.mapRWST (l f)
+    {-# INLINE liftLocal #-}
+
 instance LiftLocal (S.Lazy.StateT s) where
     liftLocal _ l f = S.Lazy.mapStateT (l f)
+    {-# INLINE liftLocal #-}
 
 instance LiftLocal (S.Strict.StateT s) where
     liftLocal _ l f = S.Strict.mapStateT (l f)
+    {-# INLINE liftLocal #-}
 
 instance Monoid w => LiftLocal (W.Lazy.WriterT w) where
     liftLocal _ l f = W.Lazy.mapWriterT (l f)
+    {-# INLINE liftLocal #-}
 
 instance Monoid w => LiftLocal (W.Strict.WriterT w) where
     liftLocal _ l f = W.Strict.mapWriterT (l f)
+    {-# INLINE liftLocal #-}
+
+instance Monoid w => LiftLocal (W.CPS.WriterT w) where
+    liftLocal _ l f = W.CPS.mapWriterT (l f)
+    {-# INLINE liftLocal #-}
+
+instance Monoid w => LiftLocal (Acc.AccumT w) where
+    liftLocal _ l f = Acc.mapAccumT (l f)
+    {-# INLINE liftLocal #-}
diff --git a/src/Control/Monad/Trans/Lift/Pass.hs b/src/Control/Monad/Trans/Lift/Pass.hs
--- a/src/Control/Monad/Trans/Lift/Pass.hs
+++ b/src/Control/Monad/Trans/Lift/Pass.hs
@@ -15,16 +15,19 @@
 import Control.Monad.Signatures
 import Control.Monad.Trans.Class
 
-import qualified Control.Monad.Trans.Except        as E
-import qualified Control.Monad.Trans.Identity      as I
-import qualified Control.Monad.Trans.Maybe         as M
-import qualified Control.Monad.Trans.Reader        as R
-import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy
-import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict
-import qualified Control.Monad.Trans.State.Lazy    as S.Lazy
-import qualified Control.Monad.Trans.State.Strict  as S.Strict
-import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy
-import qualified Control.Monad.Trans.Writer.Strict as W.Strict
+import qualified Control.Monad.Trans.Except              as E
+import qualified Control.Monad.Trans.Identity            as I
+import qualified Control.Monad.Trans.Maybe               as M
+import qualified Control.Monad.Trans.Reader              as R
+import qualified Control.Monad.Trans.RWS.Lazy            as RWS.Lazy
+import qualified Control.Monad.Trans.RWS.Strict          as RWS.Strict
+import qualified Control.Monad.Trans.RWS.CPS.Internal    as RWS.CPS
+import qualified Control.Monad.Trans.State.Lazy          as S.Lazy
+import qualified Control.Monad.Trans.State.Strict        as S.Strict
+import qualified Control.Monad.Trans.Writer.Lazy         as W.Lazy
+import qualified Control.Monad.Trans.Writer.Strict       as W.Strict
+import qualified Control.Monad.Trans.Writer.CPS.Internal as W.CPS
+import qualified Control.Monad.Trans.Accum               as Acc
 
 import Control.Monad.Trans.Lift.StT
 
@@ -50,38 +53,64 @@
 
 instance LiftPass (E.ExceptT e) where
     liftPass = E.liftPass
+    {-# INLINE liftPass #-}
 
 instance LiftPass I.IdentityT where
     liftPass = I.mapIdentityT
+    {-# INLINE liftPass #-}
 
 instance LiftPass M.MaybeT where
     liftPass = M.liftPass
+    {-# INLINE liftPass #-}
 
 instance LiftPass (R.ReaderT r) where
     liftPass = R.mapReaderT
+    {-# INLINE liftPass #-}
 
 instance LiftPass (S.Lazy.StateT s) where
     liftPass = S.Lazy.liftPass
+    {-# INLINE liftPass #-}
 
 instance LiftPass (S.Strict.StateT s) where
     liftPass = S.Strict.liftPass
+    {-# INLINE liftPass #-}
 
 instance Monoid w' => LiftPass (RWS.Lazy.RWST r w' s) where
     liftPass pass m = RWS.Lazy.RWST $ \r s -> pass $ do
         ~((a, f), w', s') <- RWS.Lazy.runRWST m r s
         return ((a, w', s'), f)
+    {-# INLINE liftPass #-}
 
 instance Monoid w' => LiftPass (RWS.Strict.RWST r w' s) where
     liftPass pass m = RWS.Strict.RWST $ \r s -> pass $ do
         ((a, f), w', s') <- RWS.Strict.runRWST m r s
         return ((a, w', s'), f)
+    {-# INLINE liftPass #-}
 
+instance Monoid w' => LiftPass (RWS.CPS.RWST r w' s) where
+    liftPass pass m = RWS.CPS.RWST $ \r w_ s -> pass $ do
+        ((a, f), w', s') <- RWS.CPS.unRWST m r w_ s
+        return ((a, w', s'), f)
+    {-# INLINE liftPass #-}
+
 instance Monoid w' => LiftPass (W.Lazy.WriterT w') where
     liftPass pass m = W.Lazy.WriterT $ pass $ do
         ~((a, f), w') <- W.Lazy.runWriterT m
         return ((a, w'), f)
+    {-# INLINE liftPass #-}
 
 instance Monoid w' => LiftPass (W.Strict.WriterT w') where
     liftPass pass m = W.Strict.WriterT $ pass $ do
         ((a, f), w') <- W.Strict.runWriterT m
         return ((a, w'), f)
+    {-# INLINE liftPass #-}
+
+instance Monoid w' => LiftPass (W.CPS.WriterT w') where
+    liftPass pass m = W.CPS.WriterT $ \w_ -> pass $ do
+        ((a, f), w') <- W.CPS.unWriterT m w_
+        return ((a, w'), f)
+    {-# INLINE liftPass #-}
+
+instance Monoid w' => LiftPass (Acc.AccumT w') where
+    liftPass = Acc.liftPass
+    {-# INLINE liftPass #-}
diff --git a/src/Control/Monad/Trans/Lift/StT.hs b/src/Control/Monad/Trans/Lift/StT.hs
--- a/src/Control/Monad/Trans/Lift/StT.hs
+++ b/src/Control/Monad/Trans/Lift/StT.hs
@@ -10,10 +10,13 @@
 import qualified Control.Monad.Trans.Reader        as R
 import qualified Control.Monad.Trans.RWS.Lazy      as RWS.Lazy
 import qualified Control.Monad.Trans.RWS.Strict    as RWS.Strict
+import qualified Control.Monad.Trans.RWS.CPS       as RWS.CPS
 import qualified Control.Monad.Trans.State.Lazy    as S.Lazy
 import qualified Control.Monad.Trans.State.Strict  as S.Strict
 import qualified Control.Monad.Trans.Writer.Lazy   as W.Lazy
 import qualified Control.Monad.Trans.Writer.Strict as W.Strict
+import qualified Control.Monad.Trans.Writer.CPS    as W.CPS
+import qualified Control.Monad.Trans.Accum         as Acc
 
 -- | Internal state of a monad transformer.
 --   Same as @StT@ from the @monad-control@ package.
@@ -26,7 +29,10 @@
 type instance StT (R.ReaderT r) a = a
 type instance StT (RWS.Lazy.RWST r w s) a = (a, s, w)
 type instance StT (RWS.Strict.RWST r w s) a = (a, s, w)
+type instance StT (RWS.CPS.RWST r w s) a = (a, s, w)
 type instance StT (S.Lazy.StateT s) a = (a, s)
 type instance StT (S.Strict.StateT s) a = (a, s)
-type instance StT (W.Strict.WriterT w) a = (a, w)
 type instance StT (W.Lazy.WriterT w) a = (a, w)
+type instance StT (W.Strict.WriterT w) a = (a, w)
+type instance StT (W.CPS.WriterT w) a = (a, w)
+type instance StT (Acc.AccumT w) a = (a, w)
diff --git a/transformers-lift.cabal b/transformers-lift.cabal
--- a/transformers-lift.cabal
+++ b/transformers-lift.cabal
@@ -1,5 +1,5 @@
 name:                transformers-lift
-version:             0.1.0.1
+version:             0.2.0.0
 synopsis:            Ad-hoc type classes for lifting
 description:
     This simple and lightweight library provides type classes
@@ -7,8 +7,8 @@
 
 license:             BSD3
 license-file:        LICENSE
-author:              Index Int
-maintainer:          Index Int <vlad.z.4096@gmail.com>
+author:              Vladislav Zavialov
+maintainer:          Vladislav Zavialov <vlad.z.4096@gmail.com>
 category:            Control
 bug-reports:         https://github.com/int-index/transformers-lift/issues
 build-type:          Simple
@@ -22,8 +22,9 @@
                        Control.Monad.Trans.Lift.Pass
                        Control.Monad.Trans.Lift.StT
 
-  build-depends:       base >=4.6 && <4.10
-               ,       transformers >= 0.4.2
+  build-depends:       base >=4.6 && <4.11
+               ,       transformers >= 0.5.4.0
+               ,       writer-cps-transformers >= 0.1.1.3
 
   default-language:    Haskell2010
   other-extensions:    CPP
@@ -32,4 +33,4 @@
                        KindSignatures
 
   hs-source-dirs:      src
-  ghc-options:         -Wall
+  ghc-options:         -Wall -fno-warn-deprecations