diff --git a/happstack-server.cabal b/happstack-server.cabal
--- a/happstack-server.cabal
+++ b/happstack-server.cabal
@@ -1,5 +1,5 @@
 Name:                happstack-server
-Version:             7.3.5
+Version:             7.3.6
 Synopsis:            Web related tools and services.
 Description:         Happstack Server provides an HTTP server and a rich set of functions for routing requests, handling query parameters, generating responses, working with cookies, serving files, and more. For in-depth documentation see the Happstack Crash Course <http://happstack.com/docs/crashcourse/index.html>
 License:             BSD3
@@ -79,7 +79,7 @@
                        hslogger >= 1.0.2,
                        html,
                        monad-control >= 0.3 && < 0.4,
-                       mtl >= 2 && < 2.2,
+                       mtl >= 2 && < 2.3,
                        old-locale,
                        parsec < 4,
                        process,
@@ -90,7 +90,7 @@
                        time,
                        time-compat,
                        threads >= 0.5,
-                       transformers >= 0.1.3 && < 0.4,
+                       transformers >= 0.1.3 && < 0.5,
                        transformers-base >= 0.4 && < 0.5,
                        utf8-string >= 0.3.4 && < 0.4,
                        xhtml,
diff --git a/src/Happstack/Server/Internal/Monads.hs b/src/Happstack/Server/Internal/Monads.hs
--- a/src/Happstack/Server/Internal/Monads.hs
+++ b/src/Happstack/Server/Internal/Monads.hs
@@ -15,10 +15,12 @@
 import Control.Monad.Reader                      ( ReaderT(ReaderT), runReaderT
                                                  , MonadReader, ask, local, mapReaderT
                                                  )
-import Control.Monad.RWS                         ( RWST, mapRWST
-                                                 )
+import qualified Control.Monad.RWS.Lazy as Lazy       ( RWST, mapRWST )
+import qualified Control.Monad.RWS.Strict as Strict   ( RWST, mapRWST )
 
-import Control.Monad.State                       (MonadState, StateT, get, put, mapStateT)
+import Control.Monad.State.Class                      ( MonadState, get, put )
+import qualified Control.Monad.State.Lazy as Lazy     ( StateT, mapStateT )
+import qualified Control.Monad.State.Strict as Strict ( StateT, mapStateT )
 import Control.Monad.Trans                       ( MonadTrans, lift
                                                  , MonadIO, liftIO
                                                  )
@@ -26,11 +28,10 @@
                                                  , MonadBaseControl(..)
                                                  , ComposeSt, defaultLiftBaseWith, defaultRestoreM
                                                  )
-import Control.Monad.Writer                      ( WriterT(WriterT), runWriterT
-                                                 , MonadWriter, tell, pass
-                                                 , listens, mapWriterT
-                                                 )
-import qualified Control.Monad.Writer            as Writer (listen) -- So that we can disambiguate 'Listen.listen'
+import Control.Monad.Writer.Class                ( MonadWriter, tell, pass, listens )
+import qualified Control.Monad.Writer.Lazy as Lazy     ( WriterT(WriterT), runWriterT, mapWriterT )
+import qualified Control.Monad.Writer.Strict as Strict ( WriterT, mapWriterT )
+import qualified Control.Monad.Writer.Class as Writer  ( listen )
 
 import Control.Monad.Trans.Maybe                 (MaybeT(MaybeT), runMaybeT)
 import qualified Data.ByteString.Lazy.UTF8       as LU (fromString)
@@ -247,7 +248,7 @@
 filterFun :: (a -> a) -> FilterFun a
 filterFun = Set . Dual . Endo
 
-newtype FilterT a m b = FilterT { unFilterT :: WriterT (FilterFun a) m b }
+newtype FilterT a m b = FilterT { unFilterT :: Lazy.WriterT (FilterFun a) m b }
    deriving (Functor, Applicative, Monad, MonadTrans)
 
 instance MonadBase b m => MonadBase b (FilterT a m) where
@@ -258,7 +259,7 @@
     {-# INLINE liftIO #-}
 
 instance MonadTransControl (FilterT a) where
-    newtype StT (FilterT a) b = StFilter {unStFilter :: StT (WriterT (FilterFun a)) b}
+    newtype StT (FilterT a) b = StFilter {unStFilter :: StT (Lazy.WriterT (FilterFun a)) b}
     liftWith f = FilterT $ liftWith $ \run -> f $ liftM StFilter . run . unFilterT
     restoreT = FilterT . restoreT . liftM unStFilter
 
@@ -447,11 +448,11 @@
 -- | For when you really need to unpack a 'WebT' entirely (and not
 -- just unwrap the first layer with 'unWebT').
 ununWebT :: WebT m a -> UnWebT m a
-ununWebT = runMaybeT . runWriterT . unFilterT . runErrorT . unWebT
+ununWebT = runMaybeT . Lazy.runWriterT . unFilterT . runErrorT . unWebT
 
 -- | For wrapping a 'WebT' back up.  @'mkWebT' . 'ununWebT' = 'id'@
 mkWebT :: UnWebT m a -> WebT m a
-mkWebT = WebT . ErrorT . FilterT . WriterT . MaybeT
+mkWebT = WebT . ErrorT . FilterT . Lazy.WriterT . MaybeT
 
 -- | See 'mapServerPartT' for a discussion of this function.
 mapWebT :: (UnWebT m a -> UnWebT n b)
@@ -579,51 +580,92 @@
 
 -- StateT
 
-instance (ServerMonad m) => ServerMonad (StateT s m) where
+instance (ServerMonad m) => ServerMonad (Lazy.StateT s m) where
     askRq         = lift askRq
-    localRq f     = mapStateT (localRq f)
+    localRq f     = Lazy.mapStateT (localRq f)
 
-instance (FilterMonad res m) => FilterMonad res (StateT s m) where
+instance (ServerMonad m) => ServerMonad (Strict.StateT s m) where
+    askRq         = lift askRq
+    localRq f     = Strict.mapStateT (localRq f)
+
+instance (FilterMonad res m) => FilterMonad res (Lazy.StateT s m) where
     setFilter f   = lift $ setFilter f
     composeFilter = lift . composeFilter
-    getFilter   m = mapStateT (\m' ->
+    getFilter   m = Lazy.mapStateT (\m' ->
                                    do ((b,s), f) <- getFilter m'
                                       return ((b, f), s)) m
 
-instance (WebMonad a m) => WebMonad a (StateT s m) where
+instance (FilterMonad res m) => FilterMonad res (Strict.StateT s m) where
+    setFilter f   = lift $ setFilter f
+    composeFilter = lift . composeFilter
+    getFilter   m = Strict.mapStateT (\m' ->
+                                   do ((b,s), f) <- getFilter m'
+                                      return ((b, f), s)) m
+
+instance (WebMonad a m) => WebMonad a (Lazy.StateT s m) where
     finishWith    = lift . finishWith
 
+instance (WebMonad a m) => WebMonad a (Strict.StateT s m) where
+    finishWith    = lift . finishWith
 
 -- WriterT
 
-instance (ServerMonad m, Monoid w) => ServerMonad (WriterT w m) where
+instance (ServerMonad m, Monoid w) => ServerMonad (Lazy.WriterT w m) where
     askRq         = lift askRq
-    localRq f     = mapWriterT (localRq f)
+    localRq f     = Lazy.mapWriterT (localRq f)
 
-instance (FilterMonad res m, Monoid w) => FilterMonad res (WriterT w m) where
+instance (ServerMonad m, Monoid w) => ServerMonad (Strict.WriterT w m) where
+    askRq         = lift askRq
+    localRq f     = Strict.mapWriterT (localRq f)
+
+instance (FilterMonad res m, Monoid w) => FilterMonad res (Lazy.WriterT w m) where
     setFilter f   = lift $ setFilter f
     composeFilter = lift . composeFilter
-    getFilter   m = mapWriterT (\m' ->
+    getFilter   m = Lazy.mapWriterT (\m' ->
                                    do ((b,w), f) <- getFilter m'
                                       return ((b, f), w)) m
 
-instance (WebMonad a m, Monoid w) => WebMonad a (WriterT w m) where
+instance (FilterMonad res m, Monoid w) => FilterMonad res (Strict.WriterT w m) where
+    setFilter f   = lift $ setFilter f
+    composeFilter = lift . composeFilter
+    getFilter   m = Strict.mapWriterT (\m' ->
+                                   do ((b,w), f) <- getFilter m'
+                                      return ((b, f), w)) m
+
+instance (WebMonad a m, Monoid w) => WebMonad a (Lazy.WriterT w m) where
     finishWith    = lift . finishWith
 
+instance (WebMonad a m, Monoid w) => WebMonad a (Strict.WriterT w m) where
+    finishWith    = lift . finishWith
+
 -- RWST
 
-instance (ServerMonad m, Monoid w) => ServerMonad (RWST r w s m) where
+instance (ServerMonad m, Monoid w) => ServerMonad (Lazy.RWST r w s m) where
     askRq         = lift askRq
-    localRq f     = mapRWST (localRq f)
+    localRq f     = Lazy.mapRWST (localRq f)
 
-instance (FilterMonad res m, Monoid w) => FilterMonad res (RWST r w s m) where
+instance (ServerMonad m, Monoid w) => ServerMonad (Strict.RWST r w s m) where
+    askRq         = lift askRq
+    localRq f     = Strict.mapRWST (localRq f)
+
+instance (FilterMonad res m, Monoid w) => FilterMonad res (Lazy.RWST r w s m) where
     setFilter f   = lift $ setFilter f
     composeFilter = lift . composeFilter
-    getFilter   m = mapRWST (\m' ->
+    getFilter   m = Lazy.mapRWST (\m' ->
                                    do ((b,s,w), f) <- getFilter m'
                                       return ((b, f), s, w)) m
 
-instance (WebMonad a m, Monoid w) => WebMonad a (RWST r w s m) where
+instance (FilterMonad res m, Monoid w) => FilterMonad res (Strict.RWST r w s m) where
+    setFilter f   = lift $ setFilter f
+    composeFilter = lift . composeFilter
+    getFilter   m = Strict.mapRWST (\m' ->
+                                   do ((b,s,w), f) <- getFilter m'
+                                      return ((b, f), s, w)) m
+
+instance (WebMonad a m, Monoid w) => WebMonad a (Lazy.RWST r w s m) where
+    finishWith     = lift . finishWith
+
+instance (WebMonad a m, Monoid w) => WebMonad a (Strict.RWST r w s m) where
     finishWith     = lift . finishWith
 
 -- ErrorT
diff --git a/src/Happstack/Server/Monads.hs b/src/Happstack/Server/Monads.hs
--- a/src/Happstack/Server/Monads.hs
+++ b/src/Happstack/Server/Monads.hs
@@ -42,10 +42,13 @@
 import Control.Monad.Error               (Error, ErrorT)
 import Control.Monad.Trans               (MonadIO(..),MonadTrans(lift))
 import Control.Monad.Reader              (ReaderT)
-import Control.Monad.Writer              (WriterT)
-import Control.Monad.State               (StateT)
-import Control.Monad.RWS                 (RWST)
-import qualified Data.ByteString.Char8   as B
+import qualified Control.Monad.Writer.Lazy   as Lazy   (WriterT)
+import qualified Control.Monad.Writer.Strict as Strict (WriterT)
+import qualified Control.Monad.State.Lazy    as Lazy   (StateT)
+import qualified Control.Monad.State.Strict  as Strict (StateT)
+import qualified Control.Monad.RWS.Lazy      as Lazy   (RWST)
+import qualified Control.Monad.RWS.Strict    as Strict (RWST)
+import qualified Data.ByteString.Char8       as B
 import Data.Monoid                       (Monoid)
 import Happstack.Server.Internal.Monads
 import Happstack.Server.Types            (Response, addHeader, getHeader, setHeader)
@@ -58,10 +61,13 @@
 
 instance (Functor m, Monad m, MonadPlus m
          , MonadIO m)            => Happstack (ServerPartT m)
-instance (Happstack m)           => Happstack (StateT      s m)
-instance (Happstack m)           => Happstack (ReaderT r     m)
-instance (Happstack m, Monoid w) => Happstack (WriterT   w   m)
-instance (Happstack m, Monoid w) => Happstack (RWST    r w s m)
+instance (Happstack m)           => Happstack (Lazy.StateT        s m)
+instance (Happstack m)           => Happstack (Strict.StateT      s m)
+instance (Happstack m)           => Happstack (ReaderT        r     m)
+instance (Happstack m, Monoid w) => Happstack (Lazy.WriterT   w     m)
+instance (Happstack m, Monoid w) => Happstack (Strict.WriterT   w   m)
+instance (Happstack m, Monoid w) => Happstack (Lazy.RWST      r w s m)
+instance (Happstack m, Monoid w) => Happstack (Strict.RWST    r w s m)
 instance (Happstack m, Error e)  => Happstack (ErrorT e m)
 
 -- | Get a header out of the request.
diff --git a/src/Happstack/Server/RqData.hs b/src/Happstack/Server/RqData.hs
--- a/src/Happstack/Server/RqData.hs
+++ b/src/Happstack/Server/RqData.hs
@@ -62,9 +62,12 @@
 import Control.Concurrent.MVar                  (newMVar)
 import Control.Monad                            (MonadPlus(mzero))
 import Control.Monad.Reader                     (ReaderT(ReaderT, runReaderT), MonadReader(ask, local), mapReaderT)
-import Control.Monad.State                      (StateT, mapStateT)
-import Control.Monad.Writer                     (WriterT, mapWriterT)
-import Control.Monad.RWS                        (RWST, mapRWST)
+import qualified Control.Monad.State.Lazy as Lazy      (StateT, mapStateT)
+import qualified Control.Monad.State.Strict as Strict  (StateT, mapStateT)
+import qualified Control.Monad.Writer.Lazy as Lazy     (WriterT, mapWriterT)
+import qualified Control.Monad.Writer.Strict as Strict (WriterT, mapWriterT)
+import qualified Control.Monad.RWS.Lazy as Lazy        (RWST, mapRWST)
+import qualified Control.Monad.RWS.Strict as Strict    (RWST, mapRWST)
 import Control.Monad.Error                      (Error(noMsg, strMsg), ErrorT, mapErrorT)
 import Control.Monad.Trans                      (MonadIO(..), lift)
 import qualified Data.ByteString.Char8          as P
@@ -190,19 +193,34 @@
     localRqEnv f  = mapReaderT (localRqEnv f)
     rqDataError e = lift (rqDataError e)
 
-instance (Monad m, HasRqData m) => HasRqData (StateT s m) where
+instance (Monad m, HasRqData m) => HasRqData (Lazy.StateT s m) where
     askRqEnv      = lift askRqEnv
-    localRqEnv f  = mapStateT (localRqEnv f)
+    localRqEnv f  = Lazy.mapStateT (localRqEnv f)
     rqDataError e = lift (rqDataError e)
 
-instance (Monad m, HasRqData m, Monoid w) => HasRqData (WriterT w m) where
+instance (Monad m, HasRqData m) => HasRqData (Strict.StateT s m) where
     askRqEnv      = lift askRqEnv
-    localRqEnv f  = mapWriterT (localRqEnv f)
+    localRqEnv f  = Strict.mapStateT (localRqEnv f)
     rqDataError e = lift (rqDataError e)
 
-instance (Monad m, HasRqData m, Monoid w) => HasRqData (RWST r w s m) where
+instance (Monad m, HasRqData m, Monoid w) => HasRqData (Lazy.WriterT w m) where
     askRqEnv      = lift askRqEnv
-    localRqEnv f  = mapRWST (localRqEnv f)
+    localRqEnv f  = Lazy.mapWriterT (localRqEnv f)
+    rqDataError e = lift (rqDataError e)
+
+instance (Monad m, HasRqData m, Monoid w) => HasRqData (Strict.WriterT w m) where
+    askRqEnv      = lift askRqEnv
+    localRqEnv f  = Strict.mapWriterT (localRqEnv f)
+    rqDataError e = lift (rqDataError e)
+
+instance (Monad m, HasRqData m, Monoid w) => HasRqData (Lazy.RWST r w s m) where
+    askRqEnv      = lift askRqEnv
+    localRqEnv f  = Lazy.mapRWST (localRqEnv f)
+    rqDataError e = lift (rqDataError e)
+
+instance (Monad m, HasRqData m, Monoid w) => HasRqData (Strict.RWST r w s m) where
+    askRqEnv      = lift askRqEnv
+    localRqEnv f  = Strict.mapRWST (localRqEnv f)
     rqDataError e = lift (rqDataError e)
 
 instance (Monad m, Error e, HasRqData m) => HasRqData (ErrorT e m) where