diff --git a/CHANGES.markdown b/CHANGES.markdown
--- a/CHANGES.markdown
+++ b/CHANGES.markdown
@@ -1,3 +1,13 @@
+0.2 (20 August 2014)
+--------------------
+
+  - change `Rand` from a `newtype` to a type synonym
+  - `MonadRandom` and `MonadSplit` instances for
+      - `ExceptT`
+	  - strict variants of `StateT` and `WriterT`
+	  - both lazy and strict variants of `RWST`
+  - remove unneeded `RandomGen` constraint from `MonadState RandT` instance
+
 0.1.13 (9 February 2014)
 ------------------------
 
diff --git a/Control/Monad/Random.hs b/Control/Monad/Random.hs
--- a/Control/Monad/Random.hs
+++ b/Control/Monad/Random.hs
@@ -47,17 +47,25 @@
 
 import           Control.Applicative
 import           Control.Arrow
-import           Control.Monad              ()
+import           Control.Monad                  ()
 import           Control.Monad.Cont
 import           Control.Monad.Error
+import           Control.Monad.Except
 import           Control.Monad.Identity
 import           Control.Monad.Random.Class
 import           Control.Monad.Reader
+import qualified Control.Monad.RWS.Lazy         as RWSL
+import qualified Control.Monad.RWS.Strict       as RWSS
 import           Control.Monad.State
-import           Control.Monad.Trans        ()
+import qualified Control.Monad.State.Lazy       as SL
+import qualified Control.Monad.State.Strict     as SS
+import           Control.Monad.Trans            ()
 import           Control.Monad.Trans.Identity
 import           Control.Monad.Trans.Maybe
-import           Control.Monad.Writer
+import           Control.Monad.Writer.Class
+import qualified Control.Monad.Writer.Lazy      as WL
+import qualified Control.Monad.Writer.Strict    as WS
+import           Data.Monoid                    (Monoid)
 import           System.Random
 
 -- | A monad transformer which adds a random number generator to an
@@ -85,7 +93,7 @@
 liftRand :: (RandomGen g, Random a) =>
             (g -> (a, g)) -- ^ action returning value and new generator state
             -> Rand g a
-liftRand = Rand . RandT . liftState
+liftRand = RandT . liftState
 
 instance (Monad m, RandomGen g) => MonadRandom (RandT g m) where
     getRandom = RandT . liftState $ random
@@ -109,19 +117,18 @@
 runRandT (RandT x) g = runStateT x g
 
 -- | A basic random monad.
-newtype Rand g a = Rand (RandT g Identity a)
-    deriving (Functor, Applicative, Monad, MonadRandom, MonadSplit g, MonadFix)
+type Rand g a = RandT g Identity a
 
 -- | Evaluate a random computation using the generator @g@.  Note that the
 -- generator @g@ is not returned, so there's no way to recover the
 -- updated version of @g@.
 evalRand :: (RandomGen g) => Rand g a -> g -> a
-evalRand (Rand x) g = runIdentity (evalRandT x g)
+evalRand x g = runIdentity (evalRandT x g)
 
 -- | Run a random computation using the generator @g@, returning the result
 -- and the updated generator.
 runRand :: (RandomGen g) => Rand g a -> g -> (a, g)
-runRand (Rand x) g = runIdentity (runRandT x g)
+runRand x g = runIdentity (runRandT x g)
 
 -- | Evaluate a random computation in the IO monad, splitting the global standard generator to get a new one for the computation.
 evalRandIO :: Rand StdGen a -> IO a
@@ -150,30 +157,60 @@
     getRandoms = lift getRandoms
     getRandomRs = lift . getRandomRs
 
-instance (MonadRandom m) => MonadRandom (StateT s m) where
+instance (MonadRandom m) => MonadRandom (SL.StateT s m) where
     getRandom = lift getRandom
     getRandomR = lift . getRandomR
     getRandoms = lift getRandoms
     getRandomRs = lift . getRandomRs
 
-instance (MonadRandom m, Monoid w) => MonadRandom (WriterT w m) where
+instance (MonadRandom m) => MonadRandom (SS.StateT s m) where
     getRandom = lift getRandom
     getRandomR = lift . getRandomR
     getRandoms = lift getRandoms
     getRandomRs = lift . getRandomRs
 
+instance (MonadRandom m, Monoid w) => MonadRandom (WL.WriterT w m) where
+    getRandom = lift getRandom
+    getRandomR = lift . getRandomR
+    getRandoms = lift getRandoms
+    getRandomRs = lift . getRandomRs
+
+instance (MonadRandom m, Monoid w) => MonadRandom (WS.WriterT w m) where
+    getRandom = lift getRandom
+    getRandomR = lift . getRandomR
+    getRandoms = lift getRandoms
+    getRandomRs = lift . getRandomRs
+
 instance (MonadRandom m) => MonadRandom (ReaderT r m) where
     getRandom = lift getRandom
     getRandomR = lift . getRandomR
     getRandoms = lift getRandoms
     getRandomRs = lift . getRandomRs
 
+instance (MonadRandom m, Monoid w) => MonadRandom (RWSL.RWST r w s m) where
+    getRandom = lift getRandom
+    getRandomR = lift . getRandomR
+    getRandoms = lift getRandoms
+    getRandomRs = lift . getRandomRs
+
+instance (MonadRandom m, Monoid w) => MonadRandom (RWSS.RWST r w s m) where
+    getRandom = lift getRandom
+    getRandomR = lift . getRandomR
+    getRandoms = lift getRandoms
+    getRandomRs = lift . getRandomRs
+
 instance (Error e, MonadRandom m) => MonadRandom (ErrorT e m) where
     getRandom = lift getRandom
     getRandomR = lift . getRandomR
     getRandoms = lift getRandoms
     getRandomRs = lift . getRandomRs
 
+instance (MonadRandom m) => MonadRandom (ExceptT e m) where
+    getRandom = lift getRandom
+    getRandomR = lift . getRandomR
+    getRandoms = lift getRandoms
+    getRandomRs = lift . getRandomRs
+
 instance (MonadRandom m) => MonadRandom (MaybeT m) where
     getRandom = lift getRandom
     getRandomR = lift . getRandomR
@@ -189,25 +226,40 @@
 instance (MonadSplit g m) => MonadSplit g (IdentityT m) where
     getSplit = lift getSplit
 
-instance (MonadSplit g m) => MonadSplit g (StateT s m) where
+instance (MonadSplit g m) => MonadSplit g (SL.StateT s m) where
     getSplit = lift getSplit
 
-instance (MonadSplit g m, Monoid w) => MonadSplit g (WriterT w m) where
+instance (MonadSplit g m) => MonadSplit g (SS.StateT s m) where
     getSplit = lift getSplit
 
+instance (MonadSplit g m, Monoid w) => MonadSplit g (WL.WriterT w m) where
+    getSplit = lift getSplit
+
+instance (MonadSplit g m, Monoid w) => MonadSplit g (WS.WriterT w m) where
+    getSplit = lift getSplit
+
 instance (MonadSplit g m) => MonadSplit g (ReaderT r m) where
     getSplit = lift getSplit
 
+instance (MonadSplit g m, Monoid w) => MonadSplit g (RWSL.RWST r w s m) where
+    getSplit = lift getSplit
+
+instance (MonadSplit g m, Monoid w) => MonadSplit g (RWSS.RWST r w s m) where
+    getSplit = lift getSplit
+
 instance (Error e, MonadSplit g m) => MonadSplit g (ErrorT e m) where
     getSplit = lift getSplit
 
+instance (MonadSplit g m) => MonadSplit g (ExceptT e m) where
+    getSplit = lift getSplit
+
 instance (MonadSplit g m) => MonadSplit g (MaybeT m) where
     getSplit = lift getSplit
 
 instance (MonadSplit g m) => MonadSplit g (ContT r m) where
     getSplit = lift getSplit
 
-instance (MonadState s m, RandomGen g) => MonadState s (RandT g m) where
+instance (MonadState s m) => MonadState s (RandT g m) where
     get = lift get
     put = lift . put
 
diff --git a/MonadRandom.cabal b/MonadRandom.cabal
--- a/MonadRandom.cabal
+++ b/MonadRandom.cabal
@@ -1,5 +1,5 @@
 name:                MonadRandom
-version:             0.1.13
+version:             0.2
 synopsis:            Random-number generation monad.
 description:         Support for computations which consume random values.
 license:             OtherLicense
@@ -9,7 +9,7 @@
 bug-reports:         https://github.com/byorgey/MonadRandom/issues
 category:            Control
 build-type:          Simple
-cabal-version:       >=1.8
+cabal-version:       >=1.10
 extra-source-files:  CHANGES.markdown
 source-repository head
   type:     git
@@ -17,5 +17,6 @@
 
 library
   exposed-modules:     Control.Monad.Random, Control.Monad.Random.Class
-  build-depends:       base >= 2 && < 5, transformers, mtl, random
-  ghc-options: -Wall
+  build-depends:       base >= 2 && < 5, transformers >= 0.4, mtl, random
+  ghc-options:         -Wall
+  default-language:    Haskell2010