diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,16 @@
 # Changelog for [`multistate` package](https://hackage.haskell.org/package/multistate)
 
+## 0.7.0.0 *February 2016*
+
+  * Add instances:
+
+    + MonadIO
+    + Alternative
+    + MonadPlus
+    + MonadBase
+    + MonadTransControl
+    + MonadBaseControl
+
 ## 0.6.2.0 *June 2015*
 
   * Add MonadFix instances
diff --git a/multistate.cabal b/multistate.cabal
--- a/multistate.cabal
+++ b/multistate.cabal
@@ -1,5 +1,5 @@
 Name:          multistate
-Version:       0.6.2.0
+Version:       0.7.0.0
 Cabal-Version: >= 1.10
 Build-Type:    Simple
 license:       BSD3
@@ -71,7 +71,9 @@
     base         >= 4.6   && <4.9,
     mtl          >= 2.1   && <2.3,
     transformers >= 0.3   && <0.5,
-    tagged       >= 0.7   && <0.9
+    tagged       >= 0.7   && <0.9,
+    transformers-base <0.5,
+    monad-control     <1.1
   default-extensions:
     GADTs
     TypeFamilies
@@ -82,7 +84,10 @@
     UndecidableInstances
     TypeOperators
     DataKinds
-  ghc-options: -Wall
+  ghc-options: {
+    -Wall
+    -fno-warn-unused-imports
+  }
   hs-source-dirs: src
 }
 
@@ -94,9 +99,9 @@
     -- no version constraints necessary, because they are already
     -- given by library
     multistate,
-    base,
-    transformers,
-    hspec
+    base <4.9,
+    transformers <0.5,
+    hspec <2.3
   ghc-options:      -Wall
   main-is:          Test.hs
   hs-source-dirs:   test
@@ -111,9 +116,9 @@
       -- no version constraints necessary, because they are already
       -- given by library
       multistate,
-      base,
-      mtl,
-      transformers
+      base <4.9,
+      mtl <2.3,
+      transformers <0.5
   } else {
     buildable: False
   }
diff --git a/src/Control/Monad/Trans/MultiRWS/Lazy.hs b/src/Control/Monad/Trans/MultiRWS/Lazy.hs
--- a/src/Control/Monad/Trans/MultiRWS/Lazy.hs
+++ b/src/Control/Monad/Trans/MultiRWS/Lazy.hs
@@ -79,23 +79,36 @@
 import Control.Monad.Trans.MultiState.Lazy   ( MultiStateT(..)
                                              , runMultiStateT )
 
-import Control.Monad.State.Lazy   ( StateT(..)
-                                  , MonadState(..)
-                                  , execStateT
-                                  , evalStateT
-                                  , mapStateT )
-import Control.Monad.Reader       ( ReaderT(..) )
-import Control.Monad.Writer.Lazy  ( WriterT(..) )
-import Control.Monad.Trans.Class  ( MonadTrans
-                                  , lift )
+import Control.Monad.State.Lazy        ( StateT(..)
+                                       , MonadState(..)
+                                       , execStateT
+                                       , evalStateT
+                                       , mapStateT )
+import Control.Monad.Reader            ( ReaderT(..) )
+import Control.Monad.Writer.Lazy       ( WriterT(..) )
+import Control.Monad.Trans.Class       ( MonadTrans
+                                       , lift )
 
-import Data.Functor.Identity      ( Identity )
+import Data.Functor.Identity           ( Identity )
 
-import Control.Applicative        ( Applicative(..) )
-import Control.Monad              ( liftM
-                                  , ap
-                                  , void )
-import Control.Monad.Fix          ( MonadFix(..) )
+import Control.Applicative             ( Applicative(..)
+                                       , Alternative(..)
+                                       )
+import Control.Monad                   ( MonadPlus(..)
+                                       , liftM
+                                       , ap
+                                       , void )
+import Control.Monad.Base              ( MonadBase(..)
+                                       , liftBaseDefault
+                                       )
+import Control.Monad.Trans.Control     ( MonadTransControl(..)
+                                       , MonadBaseControl(..)
+                                       , ComposeSt
+                                       , defaultLiftBaseWith
+                                       , defaultRestoreM
+                                       )
+import Control.Monad.Fix               ( MonadFix(..) )
+import Control.Monad.IO.Class          ( MonadIO(..) )
 
 import Data.Monoid
 
@@ -411,3 +424,29 @@
              -> MultiRWST r w s m a
              -> MultiRWST r w s m' a'
 mapMultiRWST f = MultiRWST . mapStateT f . runMultiRWSTRaw
+
+-- foreign lifting instances
+
+instance MonadIO m => MonadIO (MultiRWST r w s m) where
+  liftIO = lift . liftIO
+
+instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiRWST r w s m) where
+  empty = lift mzero
+  MultiRWST m <|> MultiRWST n = MultiRWST $ m <|> n
+
+instance MonadPlus m => MonadPlus (MultiRWST r w s m) where
+  mzero = MultiRWST $ mzero
+  MultiRWST m `mplus` MultiRWST n = MultiRWST $ m `mplus` n
+
+instance MonadBase b m => MonadBase b (MultiRWST r w s m) where
+  liftBase = liftBaseDefault
+
+instance MonadTransControl (MultiRWST r w s) where
+  type StT (MultiRWST r w s) a = (a, (HList r, HList w, HList s))
+  liftWith f = MultiRWST $ liftWith $ \s -> f $ \r -> s $ runMultiRWSTRaw r
+  restoreT = MultiRWST . restoreT
+
+instance MonadBaseControl b m => MonadBaseControl b (MultiRWST r w s m) where
+  type StM (MultiRWST r w s m) a = ComposeSt (MultiRWST r w s) m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
diff --git a/src/Control/Monad/Trans/MultiRWS/Strict.hs b/src/Control/Monad/Trans/MultiRWS/Strict.hs
--- a/src/Control/Monad/Trans/MultiRWS/Strict.hs
+++ b/src/Control/Monad/Trans/MultiRWS/Strict.hs
@@ -79,23 +79,36 @@
 import Control.Monad.Trans.MultiState.Strict  ( MultiStateT(..)
                                               , runMultiStateT )
 
-import Control.Monad.State.Strict   ( StateT(..)
-                                    , MonadState(..)
-                                    , execStateT
-                                    , evalStateT
-                                    , mapStateT )
-import Control.Monad.Reader         ( ReaderT(..) )
-import Control.Monad.Writer.Strict  ( WriterT(..) )
-import Control.Monad.Trans.Class    ( MonadTrans
-                                    , lift )
+import Control.Monad.State.Strict      ( StateT(..)
+                                       , MonadState(..)
+                                       , execStateT
+                                       , evalStateT
+                                       , mapStateT )
+import Control.Monad.Reader            ( ReaderT(..) )
+import Control.Monad.Writer.Strict     ( WriterT(..) )
+import Control.Monad.Trans.Class       ( MonadTrans
+                                       , lift )
 
-import Data.Functor.Identity        ( Identity )
+import Data.Functor.Identity           ( Identity )
 
-import Control.Applicative          ( Applicative(..) )
-import Control.Monad                ( liftM
-                                    , ap
-                                    , void )
-import Control.Monad.Fix            ( MonadFix(..) )
+import Control.Applicative             ( Applicative(..)
+                                       , Alternative(..)
+                                       )
+import Control.Monad                   ( MonadPlus(..)
+                                       , liftM
+                                       , ap
+                                       , void )
+import Control.Monad.Base              ( MonadBase(..)
+                                       , liftBaseDefault
+                                       )
+import Control.Monad.Trans.Control     ( MonadTransControl(..)
+                                       , MonadBaseControl(..)
+                                       , ComposeSt
+                                       , defaultLiftBaseWith
+                                       , defaultRestoreM
+                                       )
+import Control.Monad.Fix               ( MonadFix(..) )
+import Control.Monad.IO.Class          ( MonadIO(..) )
 
 import Data.Monoid
 
@@ -411,3 +424,29 @@
              -> MultiRWST r w s m a
              -> MultiRWST r w s m' a'
 mapMultiRWST f = MultiRWST . mapStateT f . runMultiRWSTRaw
+
+-- foreign lifting instances
+
+instance MonadIO m => MonadIO (MultiRWST r w s m) where
+  liftIO = lift . liftIO
+
+instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiRWST r w s m) where
+  empty = lift mzero
+  MultiRWST m <|> MultiRWST n = MultiRWST $ m <|> n
+
+instance MonadPlus m => MonadPlus (MultiRWST r w s m) where
+  mzero = MultiRWST $ mzero
+  MultiRWST m `mplus` MultiRWST n = MultiRWST $ m `mplus` n
+
+instance MonadBase b m => MonadBase b (MultiRWST r w s m) where
+  liftBase = liftBaseDefault
+
+instance MonadTransControl (MultiRWST r w s) where
+  type StT (MultiRWST r w s) a = (a, (HList r, HList w, HList s))
+  liftWith f = MultiRWST $ liftWith $ \s -> f $ \r -> s $ runMultiRWSTRaw r
+  restoreT = MultiRWST . restoreT
+
+instance MonadBaseControl b m => MonadBaseControl b (MultiRWST r w s m) where
+  type StM (MultiRWST r w s m) a = ComposeSt (MultiRWST r w s) m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
diff --git a/src/Control/Monad/Trans/MultiReader/Lazy.hs b/src/Control/Monad/Trans/MultiReader/Lazy.hs
--- a/src/Control/Monad/Trans/MultiReader/Lazy.hs
+++ b/src/Control/Monad/Trans/MultiReader/Lazy.hs
@@ -33,26 +33,39 @@
 
 import Control.Monad.Trans.MultiReader.Class ( MonadMultiReader(..) )
 
-import Control.Monad.State.Lazy   ( StateT(..)
-                                  , MonadState(..)
-                                  , evalStateT
-                                  , mapStateT )
-import Control.Monad.Reader       ( ReaderT(..) )
-import Control.Monad.Trans.Class  ( MonadTrans
-                                  , lift )
-import Control.Monad.Writer.Class ( MonadWriter
-                                  , listen
-                                  , tell
-                                  , writer
-                                  , pass )
+import Control.Monad.State.Lazy        ( StateT(..)
+                                       , MonadState(..)
+                                       , evalStateT
+                                       , mapStateT )
+import Control.Monad.Reader            ( ReaderT(..) )
+import Control.Monad.Trans.Class       ( MonadTrans
+                                       , lift )
+import Control.Monad.Writer.Class      ( MonadWriter
+                                       , listen
+                                       , tell
+                                       , writer
+                                       , pass )
 
-import Data.Functor.Identity      ( Identity )
+import Data.Functor.Identity           ( Identity )
 
-import Control.Applicative        ( Applicative(..) )
-import Control.Monad              ( liftM
-                                  , ap
-                                  , void )
-import Control.Monad.Fix          ( MonadFix(..) )
+import Control.Applicative             ( Applicative(..)
+                                       , Alternative(..)
+                                       )
+import Control.Monad                   ( MonadPlus(..)
+                                       , liftM
+                                       , ap
+                                       , void )
+import Control.Monad.Base              ( MonadBase(..)
+                                       , liftBaseDefault
+                                       )
+import Control.Monad.Trans.Control     ( MonadTransControl(..)
+                                       , MonadBaseControl(..)
+                                       , ComposeSt
+                                       , defaultLiftBaseWith
+                                       , defaultRestoreM
+                                       )
+import Control.Monad.Fix               ( MonadFix(..) )
+import Control.Monad.IO.Class          ( MonadIO(..) )
 
 
 
@@ -176,6 +189,26 @@
     mapStateT (pass . liftM (\(~(~(a, f), w)) -> ((a, w), f))) .
     runMultiReaderTRaw  
 
+instance MonadIO m => MonadIO (MultiReaderT c m) where
+  liftIO = lift . liftIO
 
+instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiReaderT c m) where
+  empty = lift mzero
+  MultiReaderT m <|> MultiReaderT n = MultiReaderT $ m <|> n
 
+instance MonadPlus m => MonadPlus (MultiReaderT c m) where
+  mzero = MultiReaderT $ mzero
+  MultiReaderT m `mplus` MultiReaderT n = MultiReaderT $ m `mplus` n
 
+instance MonadBase b m => MonadBase b (MultiReaderT r m) where
+  liftBase = liftBaseDefault
+
+instance MonadTransControl (MultiReaderT r) where
+  type StT (MultiReaderT r) a = (a, HList r)
+  liftWith f = MultiReaderT $ liftWith $ \s -> f $ \r -> s $ runMultiReaderTRaw r
+  restoreT = MultiReaderT . restoreT
+
+instance MonadBaseControl b m => MonadBaseControl b (MultiReaderT r m) where
+  type StM (MultiReaderT r m) a = ComposeSt (MultiReaderT r) m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
diff --git a/src/Control/Monad/Trans/MultiReader/Strict.hs b/src/Control/Monad/Trans/MultiReader/Strict.hs
--- a/src/Control/Monad/Trans/MultiReader/Strict.hs
+++ b/src/Control/Monad/Trans/MultiReader/Strict.hs
@@ -33,26 +33,39 @@
 
 import Control.Monad.Trans.MultiReader.Class ( MonadMultiReader(..) )
 
-import Control.Monad.State.Strict ( StateT(..)
-                                  , MonadState(..)
-                                  , evalStateT
-                                  , mapStateT )
-import Control.Monad.Reader       ( ReaderT(..) )
-import Control.Monad.Trans.Class  ( MonadTrans
-                                  , lift )
-import Control.Monad.Writer.Class ( MonadWriter
-                                  , listen
-                                  , tell
-                                  , writer
-                                  , pass )
+import Control.Monad.State.Strict      ( StateT(..)
+                                       , MonadState(..)
+                                       , evalStateT
+                                       , mapStateT )
+import Control.Monad.Reader            ( ReaderT(..) )
+import Control.Monad.Trans.Class       ( MonadTrans
+                                       , lift )
+import Control.Monad.Writer.Class      ( MonadWriter
+                                       , listen
+                                       , tell
+                                       , writer
+                                       , pass )
 
-import Data.Functor.Identity      ( Identity )
+import Data.Functor.Identity           ( Identity )
 
-import Control.Applicative        ( Applicative(..) )
-import Control.Monad              ( liftM
-                                  , ap
-                                  , void )
-import Control.Monad.Fix          ( MonadFix(..) )
+import Control.Applicative             ( Applicative(..)
+                                       , Alternative(..)
+                                       )
+import Control.Monad                   ( MonadPlus(..)
+                                       , liftM
+                                       , ap
+                                       , void )
+import Control.Monad.Base              ( MonadBase(..)
+                                       , liftBaseDefault
+                                       )
+import Control.Monad.Trans.Control     ( MonadTransControl(..)
+                                       , MonadBaseControl(..)
+                                       , ComposeSt
+                                       , defaultLiftBaseWith
+                                       , defaultRestoreM
+                                       )
+import Control.Monad.Fix               ( MonadFix(..) )
+import Control.Monad.IO.Class          ( MonadIO(..) )
 
 
 
@@ -176,6 +189,26 @@
     mapStateT (pass . liftM (\((a, f), w) -> ((a, w), f))) .
     runMultiReaderTRaw  
 
+instance MonadIO m => MonadIO (MultiReaderT c m) where
+  liftIO = lift . liftIO
 
+instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiReaderT c m) where
+  empty = lift mzero
+  MultiReaderT m <|> MultiReaderT n = MultiReaderT $ m <|> n
 
+instance MonadPlus m => MonadPlus (MultiReaderT c m) where
+  mzero = MultiReaderT $ mzero
+  MultiReaderT m `mplus` MultiReaderT n = MultiReaderT $ m `mplus` n
 
+instance MonadBase b m => MonadBase b (MultiReaderT r m) where
+  liftBase = liftBaseDefault
+
+instance MonadTransControl (MultiReaderT r) where
+  type StT (MultiReaderT r) a = (a, HList r)
+  liftWith f = MultiReaderT $ liftWith $ \s -> f $ \r -> s $ runMultiReaderTRaw r
+  restoreT = MultiReaderT . restoreT
+
+instance MonadBaseControl b m => MonadBaseControl b (MultiReaderT r m) where
+  type StM (MultiReaderT r m) a = ComposeSt (MultiReaderT r) m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
diff --git a/src/Control/Monad/Trans/MultiState/Lazy.hs b/src/Control/Monad/Trans/MultiState/Lazy.hs
--- a/src/Control/Monad/Trans/MultiState/Lazy.hs
+++ b/src/Control/Monad/Trans/MultiState/Lazy.hs
@@ -47,29 +47,42 @@
 
 import Control.Monad.Trans.MultiState.Class
 
-import Control.Monad.State.Lazy   ( StateT(..)
-                                  , MonadState(..)
-                                  , evalStateT
-                                  , execStateT
-                                  , mapStateT )
-import Control.Monad.Reader       ( ReaderT(..) )
-import Control.Monad.Writer.Lazy  ( WriterT(..) )
-import Control.Monad.Trans.Class  ( MonadTrans
-                                  , lift )
-import Control.Monad.Writer.Class ( MonadWriter
-                                  , listen
-                                  , tell
-                                  , writer
-                                  , pass )
+import Control.Monad.State.Lazy        ( StateT(..)
+                                       , MonadState(..)
+                                       , evalStateT
+                                       , execStateT
+                                       , mapStateT )
+import Control.Monad.Reader            ( ReaderT(..) )
+import Control.Monad.Writer.Lazy       ( WriterT(..) )
+import Control.Monad.Trans.Class       ( MonadTrans
+                                       , lift )
+import Control.Monad.Writer.Class      ( MonadWriter
+                                       , listen
+                                       , tell
+                                       , writer
+                                       , pass )
 
-import Data.Functor.Identity      ( Identity )
+import Data.Functor.Identity           ( Identity )
 
-import Control.Applicative        ( Applicative(..) )
-import Control.Monad              ( liftM
-                                  , ap
-                                  , void )
-import Data.Monoid                ( Monoid )
-import Control.Monad.Fix          ( MonadFix(..) )
+import Control.Applicative             ( Applicative(..)
+                                       , Alternative(..)
+                                       )
+import Control.Monad                   ( MonadPlus(..)
+                                       , liftM
+                                       , ap
+                                       , void )
+import Control.Monad.Base              ( MonadBase(..)
+                                       , liftBaseDefault
+                                       )
+import Control.Monad.Trans.Control     ( MonadTransControl(..)
+                                       , MonadBaseControl(..)
+                                       , ComposeSt
+                                       , defaultLiftBaseWith
+                                       , defaultRestoreM
+                                       )
+import Data.Monoid                     ( Monoid )
+import Control.Monad.Fix               ( MonadFix(..) )
+import Control.Monad.IO.Class          ( MonadIO(..) )
 
 
 
@@ -247,3 +260,27 @@
   pass = MultiStateT .
     mapStateT (pass . liftM (\(~(~(a, f), w)) -> ((a, w), f))) .
     runMultiStateTRaw  
+
+instance MonadIO m => MonadIO (MultiStateT c m) where
+  liftIO = lift . liftIO
+
+instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiStateT s m) where
+  empty = lift mzero
+  MultiStateT m <|> MultiStateT n = MultiStateT $ m <|> n
+
+instance MonadPlus m => MonadPlus (MultiStateT s m) where
+  mzero = MultiStateT $ mzero
+  MultiStateT m `mplus` MultiStateT n = MultiStateT $ m `mplus` n
+
+instance MonadBase b m => MonadBase b (MultiStateT s m) where
+  liftBase = liftBaseDefault
+
+instance MonadTransControl (MultiStateT s) where
+  type StT (MultiStateT s) a = (a, HList s)
+  liftWith f = MultiStateT $ liftWith $ \s -> f $ \r -> s $ runMultiStateTRaw r
+  restoreT = MultiStateT . restoreT
+
+instance MonadBaseControl b m => MonadBaseControl b (MultiStateT s m) where
+  type StM (MultiStateT s m) a = ComposeSt (MultiStateT s) m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
diff --git a/src/Control/Monad/Trans/MultiState/Strict.hs b/src/Control/Monad/Trans/MultiState/Strict.hs
--- a/src/Control/Monad/Trans/MultiState/Strict.hs
+++ b/src/Control/Monad/Trans/MultiState/Strict.hs
@@ -47,29 +47,42 @@
 
 import Control.Monad.Trans.MultiState.Class
 
-import Control.Monad.State.Strict  ( StateT(..)
-                                   , MonadState(..)
-                                   , evalStateT
-                                   , execStateT
-                                   , mapStateT )
-import Control.Monad.Reader        ( ReaderT(..) )
-import Control.Monad.Writer.Strict ( WriterT(..) )
-import Control.Monad.Trans.Class   ( MonadTrans
-                                   , lift )
-import Control.Monad.Writer.Class  ( MonadWriter
-                                   , listen
-                                   , tell
-                                   , writer
-                                   , pass )
+import Control.Monad.State.Strict      ( StateT(..)
+                                       , MonadState(..)
+                                       , evalStateT
+                                       , execStateT
+                                       , mapStateT )
+import Control.Monad.Reader            ( ReaderT(..) )
+import Control.Monad.Writer.Strict     ( WriterT(..) )
+import Control.Monad.Trans.Class       ( MonadTrans
+                                       , lift )
+import Control.Monad.Writer.Class      ( MonadWriter
+                                       , listen
+                                       , tell
+                                       , writer
+                                       , pass )
 
-import Data.Functor.Identity       ( Identity )
+import Data.Functor.Identity           ( Identity )
 
-import Control.Applicative         ( Applicative(..) )
-import Control.Monad               ( liftM
-                                   , ap
-                                   , void )
-import Data.Monoid                 ( Monoid )
-import Control.Monad.Fix           ( MonadFix(..) )
+import Control.Applicative             ( Applicative(..)
+                                       , Alternative(..)
+                                       )
+import Control.Monad                   ( MonadPlus(..)
+                                       , liftM
+                                       , ap
+                                       , void )
+import Control.Monad.Base              ( MonadBase(..)
+                                       , liftBaseDefault
+                                       )
+import Control.Monad.Trans.Control     ( MonadTransControl(..)
+                                       , MonadBaseControl(..)
+                                       , ComposeSt
+                                       , defaultLiftBaseWith
+                                       , defaultRestoreM
+                                       )
+import Data.Monoid                     ( Monoid )
+import Control.Monad.Fix               ( MonadFix(..) )
+import Control.Monad.IO.Class          ( MonadIO(..) )
 
 
 
@@ -245,3 +258,27 @@
   pass = MultiStateT .
     mapStateT (pass . liftM (\((a, f), w) -> ((a, w), f))) .
     runMultiStateTRaw  
+
+instance MonadIO m => MonadIO (MultiStateT c m) where
+  liftIO = lift . liftIO
+
+instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiStateT s m) where
+  empty = lift mzero
+  MultiStateT m <|> MultiStateT n = MultiStateT $ m <|> n
+
+instance MonadPlus m => MonadPlus (MultiStateT s m) where
+  mzero = MultiStateT $ mzero
+  MultiStateT m `mplus` MultiStateT n = MultiStateT $ m `mplus` n
+
+instance MonadBase b m => MonadBase b (MultiStateT s m) where
+  liftBase = liftBaseDefault
+
+instance MonadTransControl (MultiStateT s) where
+  type StT (MultiStateT s) a = (a, HList s)
+  liftWith f = MultiStateT $ liftWith $ \s -> f $ \r -> s $ runMultiStateTRaw r
+  restoreT = MultiStateT . restoreT
+
+instance MonadBaseControl b m => MonadBaseControl b (MultiStateT s m) where
+  type StM (MultiStateT s m) a = ComposeSt (MultiStateT s) m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
diff --git a/src/Control/Monad/Trans/MultiWriter/Lazy.hs b/src/Control/Monad/Trans/MultiWriter/Lazy.hs
--- a/src/Control/Monad/Trans/MultiWriter/Lazy.hs
+++ b/src/Control/Monad/Trans/MultiWriter/Lazy.hs
@@ -44,27 +44,40 @@
 
 import Control.Monad.Trans.MultiWriter.Class ( MonadMultiWriter(..) )
 
-import Control.Monad.State.Lazy   ( StateT(..)
-                                  , MonadState(..)
-                                  , execStateT
-                                  , evalStateT
-                                  , mapStateT )
-import Control.Monad.Writer.Lazy  ( WriterT(..) ) 
-import Control.Monad.Trans.Class  ( MonadTrans
-                                  , lift )
-import Control.Monad.Writer.Class ( MonadWriter
-                                  , listen
-                                  , tell
-                                  , writer
-                                  , pass )
+import Control.Monad.State.Lazy        ( StateT(..)
+                                       , MonadState(..)
+                                       , execStateT
+                                       , evalStateT
+                                       , mapStateT )
+import Control.Monad.Writer.Lazy       ( WriterT(..) )
+import Control.Monad.Trans.Class       ( MonadTrans
+                                       , lift )
+import Control.Monad.Writer.Class      ( MonadWriter
+                                       , listen
+                                       , tell
+                                       , writer
+                                       , pass )
 
-import Data.Functor.Identity      ( Identity )
+import Data.Functor.Identity           ( Identity )
 
-import Control.Applicative        ( Applicative(..) )
-import Control.Monad              ( liftM
-                                  , ap
-                                  , void )
-import Control.Monad.Fix          ( MonadFix(..) )
+import Control.Applicative             ( Applicative(..)
+                                       , Alternative(..)
+                                       )
+import Control.Monad                   ( MonadPlus(..)
+                                       , liftM
+                                       , ap
+                                       , void )
+import Control.Monad.Base              ( MonadBase(..)
+                                       , liftBaseDefault
+                                       )
+import Control.Monad.Trans.Control     ( MonadTransControl(..)
+                                       , MonadBaseControl(..)
+                                       , ComposeSt
+                                       , defaultLiftBaseWith
+                                       , defaultRestoreM
+                                       )
+import Control.Monad.Fix               ( MonadFix(..) )
+import Control.Monad.IO.Class          ( MonadIO(..) )
 
 import Data.Monoid
 
@@ -226,3 +239,27 @@
   pass = MultiWriterT .
     mapStateT (pass . liftM (\(~(~(a, f), w)) -> ((a, w), f))) .
     runMultiWriterTRaw
+
+instance MonadIO m => MonadIO (MultiWriterT c m) where
+  liftIO = lift . liftIO
+
+instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiWriterT c m) where
+  empty = lift mzero
+  MultiWriterT m <|> MultiWriterT n = MultiWriterT $ m <|> n
+
+instance MonadPlus m => MonadPlus (MultiWriterT c m) where
+  mzero = MultiWriterT $ mzero
+  MultiWriterT m `mplus` MultiWriterT n = MultiWriterT $ m `mplus` n
+
+instance MonadBase b m => MonadBase b (MultiWriterT c m) where
+  liftBase = liftBaseDefault
+
+instance MonadTransControl (MultiWriterT c) where
+  type StT (MultiWriterT c) a = (a, HList c)
+  liftWith f = MultiWriterT $ liftWith $ \s -> f $ \r -> s $ runMultiWriterTRaw r
+  restoreT = MultiWriterT . restoreT
+
+instance MonadBaseControl b m => MonadBaseControl b (MultiWriterT c m) where
+  type StM (MultiWriterT c m) a = ComposeSt (MultiWriterT c) m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM
diff --git a/src/Control/Monad/Trans/MultiWriter/Strict.hs b/src/Control/Monad/Trans/MultiWriter/Strict.hs
--- a/src/Control/Monad/Trans/MultiWriter/Strict.hs
+++ b/src/Control/Monad/Trans/MultiWriter/Strict.hs
@@ -44,27 +44,40 @@
 
 import Control.Monad.Trans.MultiWriter.Class ( MonadMultiWriter(..) )
 
-import Control.Monad.State.Strict  ( StateT(..)
-                                   , MonadState(..)
-                                   , execStateT
-                                   , evalStateT
-                                   , mapStateT )
-import Control.Monad.Writer.Strict ( WriterT(..) )
-import Control.Monad.Trans.Class   ( MonadTrans
-                                   , lift )
-import Control.Monad.Writer.Class  ( MonadWriter
-                                   , listen
-                                   , tell
-                                   , writer
-                                   , pass )
+import Control.Monad.State.Strict      ( StateT(..)
+                                       , MonadState(..)
+                                       , execStateT
+                                       , evalStateT
+                                       , mapStateT )
+import Control.Monad.Writer.Strict     ( WriterT(..) )
+import Control.Monad.Trans.Class       ( MonadTrans
+                                       , lift )
+import Control.Monad.Writer.Class      ( MonadWriter
+                                       , listen
+                                       , tell
+                                       , writer
+                                       , pass )
 
-import Data.Functor.Identity       ( Identity )
+import Data.Functor.Identity           ( Identity )
 
-import Control.Applicative         ( Applicative(..) )
-import Control.Monad               ( liftM
-                                   , ap
-                                   , void )
-import Control.Monad.Fix           ( MonadFix(..) )
+import Control.Applicative             ( Applicative(..)
+                                       , Alternative(..)
+                                       )
+import Control.Monad                   ( MonadPlus(..)
+                                       , liftM
+                                       , ap
+                                       , void )
+import Control.Monad.Base              ( MonadBase(..)
+                                       , liftBaseDefault
+                                       )
+import Control.Monad.Trans.Control     ( MonadTransControl(..)
+                                       , MonadBaseControl(..)
+                                       , ComposeSt
+                                       , defaultLiftBaseWith
+                                       , defaultRestoreM
+                                       )
+import Control.Monad.Fix               ( MonadFix(..) )
+import Control.Monad.IO.Class          ( MonadIO(..) )
 
 import Data.Monoid
 
@@ -226,3 +239,27 @@
   pass = MultiWriterT .
     mapStateT (pass . liftM (\((a, f), w) -> ((a, w), f))) .
     runMultiWriterTRaw
+
+instance MonadIO m => MonadIO (MultiWriterT c m) where
+  liftIO = lift . liftIO
+
+instance (Functor m, Applicative m, MonadPlus m) => Alternative (MultiWriterT c m) where
+  empty = lift mzero
+  MultiWriterT m <|> MultiWriterT n = MultiWriterT $ m <|> n
+
+instance MonadPlus m => MonadPlus (MultiWriterT c m) where
+  mzero = MultiWriterT $ mzero
+  MultiWriterT m `mplus` MultiWriterT n = MultiWriterT $ m `mplus` n
+
+instance MonadBase b m => MonadBase b (MultiWriterT c m) where
+  liftBase = liftBaseDefault
+
+instance MonadTransControl (MultiWriterT c) where
+  type StT (MultiWriterT c) a = (a, HList c)
+  liftWith f = MultiWriterT $ liftWith $ \s -> f $ \r -> s $ runMultiWriterTRaw r
+  restoreT = MultiWriterT . restoreT
+
+instance MonadBaseControl b m => MonadBaseControl b (MultiWriterT c m) where
+  type StM (MultiWriterT c m) a = ComposeSt (MultiWriterT c) m a
+  liftBaseWith = defaultLiftBaseWith
+  restoreM = defaultRestoreM