diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,20 @@
 # Revision history for deriving-trans
 
+## 0.8.0.0 *31 Jan 2023*
+
+* Update version boundaries of dependencies:
+  - monad-control `>= 1.0.3`
+  - monad-control-identity `>= 0.2.0.0`
+  - transformers-base `>= 0.4.6`
+  - primitive `>= 0.7.1.0`
+  - unliftio-core `>= 0.2.0.0`
+* Add common instances to `ComposeT`:
+  - `Alternative` (recursive and "base-case")
+  - `MonadFail` (recursive and "base-case")
+  - `MonadFix` (recursive; didn't find any "base-case")
+  - `MonadPlus` (determined by `Alternative`)
+  - `MonadZip` (recursive; didn't find any "base-case")
+
 ## 0.7.0.0 *31 Jan 2023*
 
 * Update required version bounds for `exceptions` to `>= 0.10.5`.
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.7.0.0
+version: 0.8.0.0
 synopsis: Derive instances for monad transformer stacks
 description:
   Implementing instances for monad transformer stacks can be tedious.
@@ -64,10 +64,10 @@
     Control.Monad.Trans.Elevator
   build-depends:
     , base >= 4.16.1.0 && < 5
-    , monad-control
-    , monad-control-identity
+    , monad-control >= 1.0.3
+    , monad-control-identity >= 0.2.0.0
     , transformers >= 0.6
-    , transformers-base
+    , transformers-base >= 0.4.6
   if flag(exceptions)
     build-depends:
       , exceptions >= 0.10.5
@@ -79,7 +79,7 @@
       , mtl >= 2.3
   if flag(primitive)
     build-depends:
-      , primitive
+      , primitive >= 0.7.1.0
   if flag(random)
     build-depends:
       , random >= 1.2
@@ -88,7 +88,7 @@
       , resourcet >= 1.2
   if flag(unliftio)
     build-depends:
-      , unliftio-core
+      , unliftio-core >= 0.2.0.0
   hs-source-dirs: src
   default-language: GHC2021
   default-extensions:
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
@@ -4,14 +4,21 @@
 
 module Control.Monad.Trans.Compose where
 
+import Control.Applicative
+import Control.Monad
 import Control.Monad.Base
+import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
 import Control.Monad.Trans.Control
 import Control.Monad.Trans.Control.Identity
 import Control.Monad.Trans.Elevator
+import Control.Monad.Zip
 import Data.Kind
 
+import Control.Monad.Trans.Except qualified as T
+import Control.Monad.Trans.Maybe qualified as T
+
 #if defined(VERSION_exceptions)
 import Control.Monad.Catch qualified as Exceptions
 import Control.Monad.Catch.Pure qualified as Exceptions.T
@@ -104,13 +111,6 @@
 -- | Elevated to @m@.
 deriving via Elevator (ComposeT t1 t2) m
   instance
-    ( MonadIO m
-    , MonadTrans (ComposeT t1 t2)
-    ) => MonadIO (ComposeT t1 t2 m)
-
--- | Elevated to @m@.
-deriving via Elevator (ComposeT t1 t2) m
-  instance
     ( MonadBase b m
     , MonadTrans (ComposeT t1 t2)
     ) => MonadBase b (ComposeT t1 t2 m)
@@ -129,7 +129,81 @@
     , MonadTransControlIdentity (ComposeT t1 t2)
     ) => MonadBaseControlIdentity b (ComposeT t1 t2 m)
 
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+deriving via Elevator t1 (t2 (m :: Type -> Type))
+  instance {-# OVERLAPPABLE #-}
+    ( Alternative (t2 m)
+    , Monad (t2 m)
+    , MonadTransControl t1
+    ) => Alternative (ComposeT t1 t2 m)
+
+-- | Set by 'T.ExceptT'.
+deriving via T.ExceptT e (t2 (m :: Type -> Type))
+  instance
+    ( Monoid e
+    , Monad (t2 m)
+    ) => Alternative (ComposeT (T.ExceptT e) t2 m)
+
+-- | Set by 'T.MaybeT'.
+deriving via T.MaybeT (t2 (m :: Type -> Type))
+  instance
+    ( Monad (t2 m)
+    ) => Alternative (ComposeT T.MaybeT t2 m)
+
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+deriving via Elevator t1 (t2 (m :: Type -> Type))
+  instance {-# OVERLAPPABLE #-}
+    ( MonadFail (t2 m)
+    , MonadTrans t1
+    ) => MonadFail (ComposeT t1 t2 m)
+
+-- | Set by 'T.MaybeT'.
+deriving via T.MaybeT (t2 (m :: Type -> Type))
+  instance
+    ( Monad (t2 m)
+    ) => MonadFail (ComposeT T.MaybeT t2 m)
+
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+deriving via Elevator t1 (t2 (m :: Type -> Type))
+  instance {-# OVERLAPPABLE #-}
+    ( MonadFix (t2 m)
+    , MonadTransControlIdentity t1
+    ) => MonadFix (ComposeT t1 t2 m)
+
+-- | Elevated to @m@.
+deriving via Elevator (ComposeT t1 t2) m
+  instance
+    ( MonadIO m
+    , MonadTrans (ComposeT t1 t2)
+    ) => MonadIO (ComposeT t1 t2 m)
+
+-- | Determined by 'Alternative'.
+instance (MonadPlus (t2 m), MonadTransControl t1) => MonadPlus (ComposeT t1 t2 m)
+
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+deriving via Elevator t1 (t2 (m :: Type -> Type))
+  instance {-# OVERLAPPABLE #-}
+    ( MonadZip (t2 m)
+    , MonadTransControlIdentity t1
+    ) => MonadZip (ComposeT t1 t2 m)
+
 #if defined(VERSION_exceptions)
+-- | Set by 'Exceptions.T.CatchT'.
+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))
+  instance
+    ( Monad (t2 m)
+    ) => Alternative (ComposeT Exceptions.T.CatchT t2 m)
+
+-- | Set by 'Exceptions.T.CatchT'.
+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))
+  instance
+    ( Monad (t2 m)
+    ) => MonadFail (ComposeT Exceptions.T.CatchT t2 m)
+
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))