diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Revision history for deriving-trans
 
+## 0.7.0.0 *31 Jan 2023*
+
+* Update required version bounds for `exceptions` to `>= 0.10.5`.
+* Remove redundant `MonadIO` constraints from instances `StatefulGen`, `FrozenGen` and `RandomGenM`.
+* Drop support for `GHC < 9.2`.
+
 ## 0.6.1.0 *27 Jan 2023*
 
 * Add optional dependency `random >= 1.2`.
diff --git a/deriving-trans.cabal b/deriving-trans.cabal
--- a/deriving-trans.cabal
+++ b/deriving-trans.cabal
@@ -1,6 +1,6 @@
 cabal-version: 3.0
 name: deriving-trans
-version: 0.6.1.0
+version: 0.7.0.0
 synopsis: Derive instances for monad transformer stacks
 description:
   Implementing instances for monad transformer stacks can be tedious.
@@ -63,14 +63,14 @@
     Control.Monad.Trans.Compose.Transparent
     Control.Monad.Trans.Elevator
   build-depends:
-    , base < 5
+    , base >= 4.16.1.0 && < 5
     , monad-control
     , monad-control-identity
     , transformers >= 0.6
     , transformers-base
   if flag(exceptions)
     build-depends:
-      , exceptions >= 0.4
+      , exceptions >= 0.10.5
   if flag(mtl)
     other-modules:
       Control.Monad.Accum.OrphanInstances
@@ -90,34 +90,20 @@
     build-depends:
       , unliftio-core
   hs-source-dirs: src
-  default-language: Haskell2010
+  default-language: GHC2021
   default-extensions:
-    BangPatterns
-    ConstraintKinds
     DataKinds
-    DeriveFoldable
-    DeriveFunctor
-    DeriveGeneric
-    DeriveTraversable
     DerivingStrategies
     DerivingVia
-    EmptyDataDeriving
-    FlexibleContexts
-    FlexibleInstances
     FunctionalDependencies
-    GeneralizedNewtypeDeriving
-    ImportQualifiedPost
-    MultiParamTypeClasses
-    NamedFieldPuns
     OverloadedStrings
-    RankNTypes
-    StandaloneDeriving
-    StandaloneKindSignatures
-    TupleSections
-    TypeApplications
     TypeFamilies
-    TypeOperators
+    UnboxedTuples
   ghc-options:
-    -Wall
-    -Wunused-packages
-    -Wredundant-constraints
+    -Weverything
+    -Wno-implicit-prelude
+    -Wno-missing-kind-signatures
+    -Wno-missing-export-lists
+    -Wno-missing-import-lists
+    -Wno-missing-safe-haskell-mode
+    -Wno-unsafe
diff --git a/src/Control/Monad/Accum/OrphanInstances.hs b/src/Control/Monad/Accum/OrphanInstances.hs
--- a/src/Control/Monad/Accum/OrphanInstances.hs
+++ b/src/Control/Monad/Accum/OrphanInstances.hs
@@ -3,7 +3,7 @@
 module Control.Monad.Accum.OrphanInstances where
 
 import Control.Monad.Accum
-import qualified Control.Monad.Trans.Accum as T
+import Control.Monad.Trans.Accum qualified as T
 
 instance (Monoid w, Monad m) => MonadAccum w (T.AccumT w m) where
   look = T.look
diff --git a/src/Control/Monad/Select/OrphanInstances.hs b/src/Control/Monad/Select/OrphanInstances.hs
--- a/src/Control/Monad/Select/OrphanInstances.hs
+++ b/src/Control/Monad/Select/OrphanInstances.hs
@@ -4,7 +4,7 @@
 
 import Control.Monad.Select
 import Control.Monad.Trans.Control.Identity
-import qualified Control.Monad.Trans.Select as T
+import Control.Monad.Trans.Select qualified as T
 import Data.Functor.Identity
 
 instance MonadBaseControlIdentity Identity m => MonadSelect r (T.SelectT r m) where
diff --git a/src/Control/Monad/Trans/Compose.hs b/src/Control/Monad/Trans/Compose.hs
--- a/src/Control/Monad/Trans/Compose.hs
+++ b/src/Control/Monad/Trans/Compose.hs
@@ -1,6 +1,5 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE QuantifiedConstraints #-}
-{-# LANGUAGE UnboxedTuples #-}
 {-# LANGUAGE UndecidableInstances #-}
 
 module Control.Monad.Trans.Compose where
@@ -82,10 +81,10 @@
 -- [@t2 :: ('Type' -> 'Type') -> 'Type' -> 'Type'@] inner monad transformer
 -- [@m :: 'Type' -> 'Type'@] monad
 -- [@a :: 'Type'@] value
-type ComposeT :: ((Type -> Type) -> Type -> Type) -- ^ @t1@
-              -> ((Type -> Type) -> Type -> Type) -- ^ @t2@
-              -> (Type -> Type) -- ^ @m@
-              -> Type -- ^ @a@
+type ComposeT :: ((Type -> Type) -> Type -> Type) -- @t1@
+              -> ((Type -> Type) -> Type -> Type) -- @t2@
+              -> (Type -> Type) -- @m@
+              -> Type -- @a@
               -> Type
 newtype ComposeT t1 t2 m a = ComposeT { deComposeT :: t1 (t2 m) a }
   deriving newtype (Applicative, Functor, Monad)
@@ -185,7 +184,7 @@
     ) => Mtl.MonadCont (ComposeT t1 t2 m)
 
 -- | Set by 'Mtl.T.ContT'.
-deriving via Mtl.T.ContT r (t2 (m :: Type -> Type))
+deriving via Mtl.T.ContT (r :: Type) (t2 (m :: Type -> Type))
   instance Mtl.MonadCont (ComposeT (Mtl.T.ContT r) t2 m)
 
 -- | /OVERLAPPABLE/.
@@ -383,10 +382,9 @@
 #endif
 
 #if defined(VERSION_random)
--- TODO: `MonadIO (t2 m)` should not be required for this instance
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-instance {-# OVERLAPPABLE #-} (Random.StatefulGen g (t2 m), MonadTrans t1, MonadIO (t2 m)) => Random.StatefulGen (Random.Const g (ComposeT t1 t2)) (ComposeT t1 t2 m) where
+instance {-# OVERLAPPABLE #-} (Random.StatefulGen g (t2 m), MonadTrans t1) => Random.StatefulGen (Random.Const g (ComposeT t1 t2)) (ComposeT t1 t2 m) where
   uniformWord32R word32 = ComposeT . lift . Random.uniformWord32R word32 . Random.getConst
   uniformWord64R word64 = ComposeT . lift . Random.uniformWord64R word64 . Random.getConst
   uniformWord8 = ComposeT . lift . Random.uniformWord8 . Random.getConst
@@ -395,18 +393,16 @@
   uniformWord64 = ComposeT . lift . Random.uniformWord64 . Random.getConst
   uniformShortByteString n = ComposeT . lift . Random.uniformShortByteString n . Random.getConst
 
--- TODO: `MonadIO (t2 m)` should not be required for this instance
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-instance {-# OVERLAPPABLE #-} (Random.FrozenGen f (t2 m), MonadTrans t1, MonadIO (t2 m)) => Random.FrozenGen (Random.Const f (ComposeT t1 t2)) (ComposeT t1 t2 m) where
+instance {-# OVERLAPPABLE #-} (Random.FrozenGen f (t2 m), MonadTrans t1) => Random.FrozenGen (Random.Const f (ComposeT t1 t2)) (ComposeT t1 t2 m) where
   type MutableGen (Random.Const f (ComposeT t1 t2)) (ComposeT t1 t2 m) = Random.Const (Random.MutableGen f (t2 m)) (ComposeT t1 t2)
   freezeGen = ComposeT . lift . fmap Random.Const . Random.freezeGen . Random.getConst
   thawGen = ComposeT . lift . fmap Random.Const . Random.thawGen . Random.getConst
 
--- TODO: `MonadIO (t2 m)` should not be required for this instance
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-instance {-# OVERLAPPABLE #-} (Random.RandomGenM g r (t2 m), MonadTrans t1, MonadIO (t2 m)) => Random.RandomGenM (Random.Const g (ComposeT t1 t2)) r (ComposeT t1 t2 m) where
+instance {-# OVERLAPPABLE #-} (Random.RandomGenM g r (t2 m), MonadTrans t1) => Random.RandomGenM (Random.Const g (ComposeT t1 t2)) r (ComposeT t1 t2 m) where
   applyRandomGenM f = ComposeT . lift . Random.applyRandomGenM f . Random.getConst
 #endif
 
diff --git a/src/Control/Monad/Trans/Elevator.hs b/src/Control/Monad/Trans/Elevator.hs
--- a/src/Control/Monad/Trans/Elevator.hs
+++ b/src/Control/Monad/Trans/Elevator.hs
@@ -66,9 +66,9 @@
 -- [@t :: ('Type' -> 'Type') -> 'Type' -> 'Type'@] monad transformer
 -- [@m :: 'Type' -> 'Type'@] monad
 -- [@a :: 'Type'@] value
-type Elevator :: ((Type -> Type) -> Type -> Type) -- ^ @t@
-              -> (Type -> Type) -- ^ @m@
-              -> Type -- ^ @a@
+type Elevator :: ((Type -> Type) -> Type -> Type) -- @t@
+              -> (Type -> Type) -- @m@
+              -> Type -- @a@
               -> Type
 newtype Elevator t m a = Ascend { descend :: t m a }
   deriving newtype (Applicative, Functor, Monad)
@@ -155,8 +155,7 @@
 #endif
 
 #if defined(VERSION_random)
--- TODO: `MonadIO m` should be redundant.
-instance (Random.StatefulGen g m, MonadTrans t, MonadIO m) => Random.StatefulGen (Random.Const g (Elevator t)) (Elevator t m) where
+instance (Random.StatefulGen g m, MonadTrans t) => Random.StatefulGen (Random.Const g (Elevator t)) (Elevator t m) where
   uniformWord32R word32 = lift . Random.uniformWord32R word32 . Random.getConst
   uniformWord64R word64 = lift . Random.uniformWord64R word64 . Random.getConst
   uniformWord8 = lift . Random.uniformWord8 . Random.getConst
@@ -165,14 +164,12 @@
   uniformWord64 = lift . Random.uniformWord64 . Random.getConst
   uniformShortByteString n = lift . Random.uniformShortByteString n . Random.getConst
 
--- TODO: `MonadIO m` should be redundant.
-instance (Random.FrozenGen f m, MonadTrans t, MonadIO m) => Random.FrozenGen (Random.Const f (Elevator t)) (Elevator t m) where
+instance (Random.FrozenGen f m, MonadTrans t) => Random.FrozenGen (Random.Const f (Elevator t)) (Elevator t m) where
   type MutableGen (Const f (Elevator t)) (Elevator t m) = Const (Random.MutableGen f m) (Elevator t)
   freezeGen = lift . fmap Random.Const . Random.freezeGen . Random.getConst
   thawGen = lift . fmap Random.Const . Random.thawGen . Random.getConst
 
--- TODO: `MonadIO m` should be redundant.
-instance (Random.RandomGenM g r m, MonadTrans t, MonadIO m) => Random.RandomGenM (Random.Const g (Elevator t)) r (Elevator t m) where
+instance (Random.RandomGenM g r m, MonadTrans t) => Random.RandomGenM (Random.Const g (Elevator t)) r (Elevator t m) where
   applyRandomGenM f = lift . Random.applyRandomGenM f . Random.getConst
 #endif