diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Revision history for deriving-trans
 
+## 0.8.1.0 *20 Feb 2023*
+
+* Support new optional dependency logict `>= 0.8.0.0`.
+* Add `MonadLogic` instances to `Elevator` and `ComposeT` including a `LogicT` "base-case" instance.
+* Add `MonadMask` instances to `Elevator` and `ComposeT` including a `CatchT` "base-case" instance.
+* Add `MonadPlus` "base-case" instances for `ExceptT`, `MaybeT`, `CatchT` and `LogicT`.
+
 ## 0.8.0.0 *31 Jan 2023*
 
 * Update version boundaries of dependencies:
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.8.0.0
+version: 0.8.1.0
 synopsis: Derive instances for monad transformer stacks
 description:
   Implementing instances for monad transformer stacks can be tedious.
@@ -30,6 +30,11 @@
   description:
     Implement instances for 'MonadThrow' and 'MonadCatch'.
 
+flag logict
+  default: True
+  description:
+    Implement instances for `MonadLogic`.
+
 flag mtl
   default: True
   description:
@@ -71,6 +76,9 @@
   if flag(exceptions)
     build-depends:
       , exceptions >= 0.10.5
+  if flag(logict)
+    build-depends:
+      , logict >= 0.8.0.0
   if flag(mtl)
     other-modules:
       Control.Monad.Accum.OrphanInstances
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
@@ -24,6 +24,11 @@
 import Control.Monad.Catch.Pure qualified as Exceptions.T
 #endif
 
+#if defined(VERSION_logict)
+import Control.Monad.Logic qualified as LogicT.T
+import Control.Monad.Logic.Class qualified as LogicT
+#endif
+
 #if defined(VERSION_mtl)
 import Control.Monad.Accum qualified as Mtl
 import Control.Monad.Accum.OrphanInstances qualified as Mtl ()
@@ -180,9 +185,27 @@
     , 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 #-}
+    ( MonadPlus (t2 m)
+    , MonadTransControl t1
+    ) => MonadPlus (ComposeT t1 t2 m)
 
+-- | Set by 'T.ExceptT'.
+deriving via T.ExceptT e (t2 (m :: Type -> Type))
+  instance
+    ( Monoid e
+    , Monad (t2 m)
+    ) => MonadPlus (ComposeT (T.ExceptT e) t2 m)
+
+-- | Set by 'T.MaybeT'.
+deriving via T.MaybeT (t2 (m :: Type -> Type))
+  instance
+    ( Monad (t2 m)
+    ) => MonadPlus (ComposeT T.MaybeT t2 m)
+
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
@@ -204,6 +227,12 @@
     ( Monad (t2 m)
     ) => MonadFail (ComposeT Exceptions.T.CatchT t2 m)
 
+-- | Set by 'Exceptions.T.CatchT'.
+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))
+  instance
+    ( Monad (t2 m)
+    ) => MonadPlus (ComposeT Exceptions.T.CatchT t2 m)
+
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
@@ -231,6 +260,46 @@
   instance
     ( Monad (t2 m)
     ) => Exceptions.MonadCatch (ComposeT Exceptions.T.CatchT t2 m)
+
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+deriving via Elevator t1 (t2 (m :: Type -> Type))
+  instance {-# OVERLAPPABLE #-}
+    ( Exceptions.MonadMask (t2 m)
+    , MonadTransControl t1
+    ) => Exceptions.MonadMask (ComposeT t1 t2 m)
+
+-- | Set by 'Exceptions.T.CatchT'.
+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))
+  instance
+    ( Monad (t2 m)
+    ) => Exceptions.MonadMask (ComposeT Exceptions.T.CatchT t2 m)
+#endif
+
+#if defined(VERSION_logict)
+-- | Set by 'LogicT.T.LogicT'.
+deriving via LogicT.T.LogicT (t2 (m :: Type -> Type))
+  instance Alternative (ComposeT LogicT.T.LogicT t2 m)
+
+-- | Set by 'Logic.T.LogicT'.
+deriving via LogicT.T.LogicT (t2 (m :: Type -> Type))
+  instance MonadFail (ComposeT LogicT.T.LogicT t2 m)
+
+-- | Set by 'LogicT.T.LogicT'.
+deriving via LogicT.T.LogicT (t2 (m :: Type -> Type))
+  instance MonadPlus (ComposeT LogicT.T.LogicT t2 m)
+
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+instance {-# OVERLAPPABLE #-} (LogicT.MonadLogic (t2 m), MonadTransControlIdentity t1) => LogicT.MonadLogic (ComposeT t1 t2 m) where
+  msplit = (((\(a, b) -> (a, ComposeT $ descend b)) <$>) <$>) .
+    ComposeT . descend . LogicT.msplit . Ascend . deComposeT
+
+-- | Set by 'LogicT.T.LogicT'.
+deriving via LogicT.T.LogicT (t2 (m :: Type -> Type))
+  instance
+    ( Monad (t2 m)
+    ) => LogicT.MonadLogic (ComposeT LogicT.T.LogicT t2 m)
 #endif
 
 #if defined(VERSION_mtl)
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
@@ -19,6 +19,10 @@
 import Control.Monad.Catch qualified as Exceptions
 #endif
 
+#if defined(VERSION_logict)
+import Control.Monad.Logic.Class qualified as LogicT
+#endif
+
 #if defined(VERSION_mtl)
 import Control.Monad.Accum qualified as Mtl
 import Control.Monad.Cont.Class qualified as Mtl
@@ -111,6 +115,36 @@
 instance (Exceptions.MonadCatch m, MonadTransControl t) => Exceptions.MonadCatch (Elevator t m) where
   catch throwing catching = (restoreT . pure =<<) $ liftWith $ \ runT ->
     Exceptions.catch (runT throwing) (runT . catching)
+
+instance (Exceptions.MonadMask m, MonadTransControl t) => Exceptions.MonadMask (Elevator t m) where
+  mask f = (restoreT . pure =<<) $ liftWith $ \ runT ->
+    Exceptions.mask $ \ u -> runT $ f $ restoreT . u . runT
+  uninterruptibleMask f = (restoreT . pure =<<) $ liftWith $ \ runT ->
+    Exceptions.uninterruptibleMask $ \ u -> runT $ f $ restoreT . u . runT
+  generalBracket acquire release use = do
+    (usageResult', releaseResult') <- liftWith $ \ runT -> do
+      Exceptions.generalBracket
+        (runT acquire)
+        (\ resource' exitCase' -> runT $ do
+          resource <- restoreT $ pure resource'
+          case exitCase' of
+            Exceptions.ExitCaseSuccess x' ->
+              release resource . Exceptions.ExitCaseSuccess =<< restoreT (pure x')
+            Exceptions.ExitCaseException e ->
+              release resource (Exceptions.ExitCaseException e)
+            Exceptions.ExitCaseAbort ->
+              release resource Exceptions.ExitCaseAbort
+        )
+        (\ resource -> runT $ use =<< restoreT (pure resource))
+    usageResult <- restoreT $ pure usageResult'
+    releaseResult <- restoreT $ pure releaseResult'
+    pure (usageResult, releaseResult)
+#endif
+
+#if defined(VERSION_logict)
+instance (LogicT.MonadLogic m, MonadTransControlIdentity t) => LogicT.MonadLogic (Elevator t m) where
+  msplit tma = (((\(a, b) -> (a, lift b)) <$>) <$>) $
+    liftWithIdentity $ \runT -> LogicT.msplit $ runT tma
 #endif
 
 #if defined(VERSION_mtl)