diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,9 @@
+2.2
+---
+* `transformers` 0.4 support
+* Added instances for `ExceptT`
+* Added `modify'` to `Control.Monad.State.*`
+
 2.1.3.1
 -------
 * Avoid importing `Control.Monad.Instances` on GHC 7.8 to build without deprecation warnings.
diff --git a/Control/Monad/Cont/Class.hs b/Control/Monad/Cont/Class.hs
--- a/Control/Monad/Cont/Class.hs
+++ b/Control/Monad/Cont/Class.hs
@@ -55,6 +55,7 @@
 import Control.Monad.Trans.Cont (ContT)
 import qualified Control.Monad.Trans.Cont as ContT
 import Control.Monad.Trans.Error as Error
+import Control.Monad.Trans.Except as Except
 import Control.Monad.Trans.Identity as Identity
 import Control.Monad.Trans.List as List
 import Control.Monad.Trans.Maybe as Maybe
@@ -98,6 +99,9 @@
 
 instance (Error e, MonadCont m) => MonadCont (ErrorT e m) where
     callCC = Error.liftCallCC callCC
+
+instance MonadCont m => MonadCont (ExceptT e m) where
+    callCC = Except.liftCallCC callCC
 
 instance MonadCont m => MonadCont (IdentityT m) where
     callCC = Identity.liftCallCC callCC
diff --git a/Control/Monad/Error/Class.hs b/Control/Monad/Error/Class.hs
--- a/Control/Monad/Error/Class.hs
+++ b/Control/Monad/Error/Class.hs
@@ -40,7 +40,9 @@
     MonadError(..),
   ) where
 
+import Control.Monad.Trans.Except (Except(..), ExceptT)
 import Control.Monad.Trans.Error (Error(..), ErrorT)
+import qualified Control.Monad.Trans.Except as ExceptT (throwE, catchE)
 import qualified Control.Monad.Trans.Error as ErrorT (throwError, catchError)
 import Control.Monad.Trans.Identity as Identity
 import Control.Monad.Trans.List as List
@@ -110,6 +112,10 @@
 instance (Monad m, Error e) => MonadError e (ErrorT e m) where
     throwError = ErrorT.throwError
     catchError = ErrorT.catchError
+
+instance Monad m => MonadError e (ExceptT e m) where
+    throwError = ExceptT.throwE
+    catchError = ExceptT.catchE
 
 -- ---------------------------------------------------------------------------
 -- Instances for other mtl transformers
diff --git a/Control/Monad/RWS/Class.hs b/Control/Monad/RWS/Class.hs
--- a/Control/Monad/RWS/Class.hs
+++ b/Control/Monad/RWS/Class.hs
@@ -33,6 +33,7 @@
 
 import Control.Monad.Trans.Class
 import Control.Monad.Trans.Error(Error, ErrorT)
+import Control.Monad.Trans.Except(ExceptT)
 import Control.Monad.Trans.Maybe(MaybeT)
 import Control.Monad.Trans.Identity(IdentityT)
 import Control.Monad.Trans.RWS.Lazy as Lazy (RWST)
@@ -53,6 +54,7 @@
 -- All of these instances need UndecidableInstances,
 -- because they do not satisfy the coverage condition.
 
+instance MonadRWS r w s m => MonadRWS r w s (ExceptT e m)
 instance (Error e, MonadRWS r w s m) => MonadRWS r w s (ErrorT e m)
 instance MonadRWS r w s m => MonadRWS r w s (IdentityT m)
 instance MonadRWS r w s m => MonadRWS r w s (MaybeT m)
diff --git a/Control/Monad/Reader/Class.hs b/Control/Monad/Reader/Class.hs
--- a/Control/Monad/Reader/Class.hs
+++ b/Control/Monad/Reader/Class.hs
@@ -43,6 +43,7 @@
     ) where
 
 import Control.Monad.Trans.Cont as Cont
+import Control.Monad.Trans.Except
 import Control.Monad.Trans.Error
 import Control.Monad.Trans.Identity
 import Control.Monad.Trans.List
@@ -126,6 +127,11 @@
 instance (Error e, MonadReader r m) => MonadReader r (ErrorT e m) where
     ask   = lift ask
     local = mapErrorT . local
+    reader = lift . reader
+
+instance MonadReader r m => MonadReader r (ExceptT e m) where
+    ask   = lift ask
+    local = mapExceptT . local
     reader = lift . reader
 
 instance MonadReader r m => MonadReader r (IdentityT m) where
diff --git a/Control/Monad/State/Class.hs b/Control/Monad/State/Class.hs
--- a/Control/Monad/State/Class.hs
+++ b/Control/Monad/State/Class.hs
@@ -24,11 +24,13 @@
 module Control.Monad.State.Class (
     MonadState(..),
     modify,
-    gets,
+    modify',
+    gets
   ) where
 
 import Control.Monad.Trans.Cont
 import Control.Monad.Trans.Error
+import Control.Monad.Trans.Except
 import Control.Monad.Trans.Identity
 import Control.Monad.Trans.List
 import Control.Monad.Trans.Maybe
@@ -78,6 +80,11 @@
 modify :: MonadState s m => (s -> s) -> m ()
 modify f = state (\s -> ((), f s))
 
+-- | A variant of 'modify' in which the computation is strict in the
+-- new state.
+modify' :: MonadState s m => (s -> s) -> m ()
+modify' f = state (\s -> let s' = f s in s' `seq` ((), s'))
+
 -- | Gets specific component of the state, using a projection function
 -- supplied.
 gets :: MonadState s m => (s -> a) -> m a
@@ -117,6 +124,11 @@
     state = lift . state
 
 instance (Error e, MonadState s m) => MonadState s (ErrorT e m) where
+    get = lift get
+    put = lift . put
+    state = lift . state
+
+instance MonadState s m => MonadState s (ExceptT e m) where
     get = lift get
     put = lift . put
     state = lift . state
diff --git a/Control/Monad/State/Lazy.hs b/Control/Monad/State/Lazy.hs
--- a/Control/Monad/State/Lazy.hs
+++ b/Control/Monad/State/Lazy.hs
@@ -22,6 +22,7 @@
     -- * MonadState class
     MonadState(..),
     modify,
+    modify',
     gets,
     -- * The State monad
     State,
diff --git a/Control/Monad/State/Strict.hs b/Control/Monad/State/Strict.hs
--- a/Control/Monad/State/Strict.hs
+++ b/Control/Monad/State/Strict.hs
@@ -22,6 +22,7 @@
     -- * MonadState class
     MonadState(..),
     modify,
+    modify',
     gets,
     -- * The State monad
     State,
diff --git a/Control/Monad/Writer/Class.hs b/Control/Monad/Writer/Class.hs
--- a/Control/Monad/Writer/Class.hs
+++ b/Control/Monad/Writer/Class.hs
@@ -27,6 +27,7 @@
   ) where
 
 import Control.Monad.Trans.Error as Error
+import Control.Monad.Trans.Except as Except
 import Control.Monad.Trans.Identity as Identity
 import Control.Monad.Trans.Maybe as Maybe
 import Control.Monad.Trans.Reader
@@ -130,6 +131,12 @@
     tell   = lift . tell
     listen = Error.liftListen listen
     pass   = Error.liftPass pass
+
+instance MonadWriter w m => MonadWriter w (ExceptT e m) where
+    writer = lift . writer
+    tell   = lift . tell
+    listen = Except.liftListen listen
+    pass   = Except.liftPass pass
 
 instance MonadWriter w m => MonadWriter w (IdentityT m) where
     writer = lift . writer
diff --git a/mtl.cabal b/mtl.cabal
--- a/mtl.cabal
+++ b/mtl.cabal
@@ -1,5 +1,5 @@
 name:         mtl
-version:      2.1.3.1
+version:      2.2
 cabal-version: >= 1.6
 license:      BSD3
 license-file: LICENSE
@@ -45,7 +45,7 @@
     Control.Monad.Writer.Class
     Control.Monad.Writer.Lazy
     Control.Monad.Writer.Strict
-  build-depends: base < 6, transformers == 0.3.*
+  build-depends: base < 6, transformers == 0.4.*
   extensions:
     MultiParamTypeClasses
     FunctionalDependencies