diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+### 0.13.15 [2024.10.22]
+* Support building with `template-haskell-2.22.1`.
+* Drop support for pre-8.0 versions of GHC.
+
 ### 0.13.14 [2022.08.21]
 * Only depend on `th-lift-instances` for `ghc <= 7.8`.
 
diff --git a/src/Language/Haskell/TH/Instances.hs b/src/Language/Haskell/TH/Instances.hs
--- a/src/Language/Haskell/TH/Instances.hs
+++ b/src/Language/Haskell/TH/Instances.hs
@@ -5,22 +5,8 @@
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE TypeFamilies #-}
 
-#if defined(__GLASGOW_HASKELL__)
-# define LANGUAGE_DeriveDataTypeable
-{-# LANGUAGE DeriveDataTypeable #-}
-#endif
-
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 704
-# define LANGUAGE_DeriveGeneric
-{-# LANGUAGE DeriveGeneric #-}
-#endif
-
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 706
-{-# LANGUAGE DataKinds #-}
-#endif
-
-{-# OPTIONS_GHC -fno-warn-deprecations #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# OPTIONS_GHC -Wno-deprecations #-}
+{-# OPTIONS_GHC -Wno-orphans #-}
 
 -- |
 -- Module      :  Language.Haskell.TH.Instances
@@ -32,29 +18,14 @@
 --
 -- It provides the following instances:
 --
---   * 'Ord', 'Lift', 'Generic', 'Show', 'Eq', 'Data', 'Typeable',
---   'Ppr', instances for the datatypes in "Language.Haskell.TH"
---
---   * 'Lift' instances for "Data.Word" / "Data.Int" types
---
---   * 'Applicative' for 'Q'
+--   * 'Lift' instances for the datatypes in "Language.Haskell.TH"
 --
 --   * 'Quasi' for 'ReaderT', 'WriterT', 'StateT', and 'RWST'.
 --
---   * 'Typeable' for 'Lift', 'NameIs', 'Ppr', 'PprM', 'Q', 'Quasi',
---   'QuasiQuoter', and 'TExp'
---
--- More recent versions of template-haskell, particularly 2.10 (GHC
--- 7.10), provide these instances.  However, in order to support older
--- versions you should import this module.
---
--- Note that the 'Ord' instances are not guaranteed to produce
--- consistent results across template-haskell / GHC versions, as they
--- have different data types, with different constructor orders.
+--   * 'MonadFix' for 'Q'
 --
--- This module also implicitly re-exports the instances defined in
--- "Instances.TH.Lift". This is mostly to ensure that there aren't
--- collisions of orphans between @th-orphans@ and @th-lift-instances@.
+-- More recent versions of template-haskell provide these instances. However, in
+-- order to support older versions you should import this module.
 module Language.Haskell.TH.Instances () where
 
 import Language.Haskell.TH hiding (newName)
@@ -69,59 +40,12 @@
 import Control.Monad.State (StateT(StateT), runStateT)
 import qualified Control.Monad.Trans as Trans (MonadTrans(lift))
 import Control.Monad.Writer (WriterT(WriterT), runWriterT)
-#if !MIN_VERSION_base(4,8,0)
-import Instances.TH.Lift ()
-#endif
 
-#if !(MIN_VERSION_template_haskell(2,8,0))
-import Unsafe.Coerce (unsafeCoerce)
-#endif
-
-#if MIN_VERSION_template_haskell(2,11,0) && !(MIN_VERSION_template_haskell(2,15,0))
+#if !(MIN_VERSION_template_haskell(2,15,0))
 import Language.Haskell.TH.LanguageExtensions (Extension(..))
 #endif
 
--- Thanks to Richard Eisenberg, GHC 7.10 adds many of the instances
--- from this module.
-#if !MIN_VERSION_template_haskell(2,10,0)
-import Language.Haskell.TH.Ppr
-# if MIN_VERSION_template_haskell(2,3,0)
-import Language.Haskell.TH.PprLib
-import Language.Haskell.TH.Quote
-# endif
-# if MIN_VERSION_template_haskell(2,4,0) && !(MIN_VERSION_template_haskell(2,8,0))
-import Language.Haskell.TH.Syntax.Internals
-# endif
-
-# if !(MIN_VERSION_template_haskell(2,9,0))
-#  if !(MIN_VERSION_base(4,8,0))
-import Control.Applicative (Applicative(..))
-#  endif
-import Control.Monad (ap, liftM)
-# endif
-
-# if !(MIN_VERSION_base(4,8,0))
-import Data.Monoid (Monoid (..))
-# endif
-
-# if MIN_VERSION_template_haskell(2,3,0) && defined(LANGUAGE_DeriveDataTypeable)
-import Data.Data hiding (Fixity(..))
-# endif
-
-# if __GLASGOW_HASKELL__ > 702
-import GHC.Generics (Generic)
-# endif
-
-# if __GLASGOW_HASKELL__ <= 702 || !(MIN_VERSION_template_haskell(2,10,0))
-import qualified Generics.Deriving.TH as Generic (deriveAll)
-# endif
-#endif
-
-#if !(MIN_VERSION_template_haskell(2,11,0))
-import qualified Control.Monad.Fail as Fail
-#endif
-
-#if MIN_VERSION_template_haskell(2,16,0)
+#if MIN_VERSION_template_haskell(2,16,0) && !(MIN_VERSION_template_haskell(2,22,1))
 import GHC.Ptr (Ptr(Ptr))
 import GHC.ForeignPtr (newForeignPtr_)
 import Language.Haskell.TH.Syntax.Compat (liftTypedFromUntypedSplice)
@@ -142,300 +66,35 @@
 # endif
 #endif
 
-#if !MIN_VERSION_template_haskell(2,11,0)
-deriving instance Show NameFlavour
-deriving instance Show NameSpace
-
-instance Fail.MonadFail Q where
-  fail s = report True s >> q (fail "Q monad failure")
-    where
-      q :: (forall m. Quasi m => m a) -> Q a
-# if MIN_VERSION_template_haskell(2,8,0)
-      q = Q
-# else
-      -- Early versions of template-haskell did not expose Q's newtype
-      -- constructor. Desperate times call for desperate measures.
-      q = unsafeCoerce
-# endif
-#endif
-
--- Ideally, it'd be possible to use reifyManyWithoutInstances for
--- these Ord instances, but TH can't output deriving instances (and
--- even if this is added for later versions, we need to support many
--- ghc / th versions).  We can't generate Ord instances from TH due to
--- some undiagnosed funkiness:
--- https://github.com/mgsloan/th-orphans/issues/14
-
--- GHC 7.10 comes with Ord instances for TH datatypes.
-#if !MIN_VERSION_template_haskell(2,10,0)
-instance Ppr Lit where
-    ppr = pprLit noPrec
-
-deriving instance Eq Info
-
-deriving instance Ord Body
-deriving instance Ord Callconv
-deriving instance Ord Clause
-deriving instance Ord Con
-deriving instance Ord Dec
-deriving instance Ord Exp
-deriving instance Ord Fixity
-deriving instance Ord FixityDirection
-deriving instance Ord Foreign
-deriving instance Ord FunDep
-deriving instance Ord Guard
-deriving instance Ord Info
-deriving instance Ord Lit
-deriving instance Ord Match
-deriving instance Ord Pat
-deriving instance Ord Range
-deriving instance Ord Safety
-deriving instance Ord Stmt
-deriving instance Ord Strict
-deriving instance Ord Type
-
-# if defined(LANGUAGE_DeriveDataTypeable)
-deriving instance Typeable  NameIs
-deriving instance Typeable1 PprM
-deriving instance Typeable1 Q
-# endif
-
-# if defined(LANGUAGE_DeriveGeneric)
-deriving instance Generic Body
-deriving instance Generic Callconv
-deriving instance Generic Clause
-deriving instance Generic Con
-deriving instance Generic Dec
-deriving instance Generic Exp
-deriving instance Generic Fixity
-deriving instance Generic FixityDirection
-deriving instance Generic Foreign
-deriving instance Generic FunDep
-deriving instance Generic Guard
-deriving instance Generic Info
-deriving instance Generic Lit
-deriving instance Generic Match
-deriving instance Generic Name
-deriving instance Generic NameSpace
-deriving instance Generic Pat
-deriving instance Generic Range
-deriving instance Generic Safety
-deriving instance Generic Stmt
-deriving instance Generic Strict
-deriving instance Generic Type
-# else
-$(Generic.deriveAll ''Body)
-$(Generic.deriveAll ''Callconv)
-$(Generic.deriveAll ''Clause)
-$(Generic.deriveAll ''Con)
-$(Generic.deriveAll ''Dec)
-$(Generic.deriveAll ''Exp)
-$(Generic.deriveAll ''Fixity)
-$(Generic.deriveAll ''FixityDirection)
-$(Generic.deriveAll ''Foreign)
-$(Generic.deriveAll ''FunDep)
-$(Generic.deriveAll ''Guard)
-$(Generic.deriveAll ''Info)
-$(Generic.deriveAll ''Lit)
-$(Generic.deriveAll ''Match)
-$(Generic.deriveAll ''Name)
-$(Generic.deriveAll ''NameSpace)
-$(Generic.deriveAll ''Pat)
-$(Generic.deriveAll ''Range)
-$(Generic.deriveAll ''Safety)
-$(Generic.deriveAll ''Stmt)
-$(Generic.deriveAll ''Strict)
-$(Generic.deriveAll ''Type)
-# endif
-
--- Unconditionally use Template Haskell to derive this Generic instance, since
--- NameFlavour has fields with unboxed types (for which deriving Generic
--- support wasn't added to GHC until 8.0).
-$(Generic.deriveAll ''NameFlavour)
-
-# if MIN_VERSION_template_haskell(2,3,0)
-instance Ppr Loc where
-    ppr (Loc { loc_module = md
-             , loc_package = pkg
-             , loc_start = (start_ln, start_col)
-             , loc_end = (end_ln, end_col) })
-      = hcat [ text pkg, colon, text md, colon
-             , parens $ int start_ln <> comma <> int start_col
-             , text "-"
-             , parens $ int end_ln <> comma <> int end_col ]
-
-deriving instance Eq Loc
-deriving instance Ord Loc
-deriving instance Show Loc
-
-#  if defined(LANGUAGE_DeriveDataTypeable)
-deriving instance Data Loc
-deriving instance Typeable Loc
-
-deriving instance Typeable QuasiQuoter
-#  endif
-
-#  if defined(LANGUAGE_DeriveGeneric)
-deriving instance Generic Loc
-#  else
-$(Generic.deriveAll ''Loc)
-#  endif
-# endif
-
-# if MIN_VERSION_template_haskell(2,4,0)
-deriving instance Ord FamFlavour
-deriving instance Ord Pragma
-deriving instance Ord Pred
-deriving instance Ord TyVarBndr
-
-#  if defined(LANGUAGE_DeriveGeneric)
-deriving instance Generic FamFlavour
-deriving instance Generic ModName
-deriving instance Generic OccName
-deriving instance Generic PkgName
-deriving instance Generic Pragma
-deriving instance Generic Pred
-deriving instance Generic TyVarBndr
-#  else
-$(Generic.deriveAll ''FamFlavour)
-$(Generic.deriveAll ''ModName)
-$(Generic.deriveAll ''OccName)
-$(Generic.deriveAll ''PkgName)
-$(Generic.deriveAll ''Pragma)
-$(Generic.deriveAll ''Pred)
-$(Generic.deriveAll ''TyVarBndr)
-#  endif
-
-#  if !(MIN_VERSION_template_haskell(2,8,0))
-deriving instance Ord InlineSpec
-deriving instance Ord Kind
-
-#   if defined(LANGUAGE_DeriveGeneric)
-deriving instance Generic InlineSpec
-deriving instance Generic Kind
-#   else
-$(Generic.deriveAll ''InlineSpec)
-$(Generic.deriveAll ''Kind)
-#   endif
-#  endif
-# endif
-
-# if MIN_VERSION_template_haskell(2,5,0) && !(MIN_VERSION_template_haskell(2,7,0))
-deriving instance Eq ClassInstance
-deriving instance Ord ClassInstance
-
-#  if defined(LANGUAGE_DeriveGeneric)
-deriving instance Generic ClassInstance
-#  else
-$(Generic.deriveAll ''ClassInstance)
-#  endif
-# endif
-
-# if !(MIN_VERSION_template_haskell(2,7,0))
-instance Applicative Q where
-    pure  = return
-    (<*>) = ap
-# endif
-
-# if MIN_VERSION_template_haskell(2,8,0)
-deriving instance Ord Inline
-deriving instance Ord Phases
-deriving instance Ord RuleBndr
-deriving instance Ord RuleMatch
-deriving instance Ord TyLit
-
-#  if defined(LANGUAGE_DeriveGeneric)
-deriving instance Generic Inline
-deriving instance Generic Phases
-deriving instance Generic RuleBndr
-deriving instance Generic RuleMatch
-deriving instance Generic TyLit
-#  else
-$(Generic.deriveAll ''Inline)
-$(Generic.deriveAll ''Phases)
-$(Generic.deriveAll ''RuleBndr)
-$(Generic.deriveAll ''RuleMatch)
-$(Generic.deriveAll ''TyLit)
-#  endif
-# endif
-
-# if MIN_VERSION_template_haskell(2,9,0)
-deriving instance Eq ModuleInfo
-
-deriving instance Ord AnnLookup
-deriving instance Ord AnnTarget
-deriving instance Ord ModuleInfo
-deriving instance Ord Role
-deriving instance Ord TySynEqn
-
-#  if defined(LANGUAGE_DeriveDataTypeable)
-deriving instance Typeable TExp
-#  endif
-
-#  if defined(LANGUAGE_DeriveGeneric)
-deriving instance Generic AnnLookup
-deriving instance Generic AnnTarget
-deriving instance Generic Module
-deriving instance Generic ModuleInfo
-deriving instance Generic Role
-deriving instance Generic TySynEqn
-#  else
-$(Generic.deriveAll ''AnnLookup)
-$(Generic.deriveAll ''AnnTarget)
-$(Generic.deriveAll ''Module)
-$(Generic.deriveAll ''ModuleInfo)
-$(Generic.deriveAll ''Role)
-$(Generic.deriveAll ''TySynEqn)
-#  endif
-# else
-deriving instance Show ModName
-deriving instance Show OccName
-deriving instance Show PkgName
-
-instance Functor PprM where
-    fmap = liftM
-
-instance Applicative PprM where
-    pure  = return
-    (<*>) = ap
-# endif
-#endif
-
-#if MIN_VERSION_template_haskell(2,11,0) && !(MIN_VERSION_template_haskell(2,15,0))
+#if !(MIN_VERSION_template_haskell(2,15,0))
 deriving instance Bounded Extension
 #endif
 
 instance Quote m => Quote (ReaderT r m) where
     newName = Trans.lift . newName
 $(deriveQuasiTrans
-    [t| forall r m. Quasi m => Proxy2 (ReaderT r m) |]
+    [t| forall r m. Quasi m => Quasi (ReaderT r m) |]
     [e| \m1 m2 -> ReaderT $ \ r -> runReaderT m1 r `qRecover` runReaderT m2 r |])
 
 instance (Quote m, Monoid w) => Quote (WriterT w m) where
     newName = Trans.lift . newName
 $(deriveQuasiTrans
-    [t| forall w m. (Quasi m, Monoid w) => Proxy2 (WriterT w m) |]
+    [t| forall w m. (Quasi m, Monoid w) => Quasi (WriterT w m) |]
     [e| \m1 m2 -> WriterT $ runWriterT m1 `qRecover` runWriterT m2 |])
 
 instance Quote m => Quote (StateT s m) where
     newName = Trans.lift . newName
 $(deriveQuasiTrans
-    [t| forall s m. Quasi m => Proxy2 (StateT s m) |]
+    [t| forall s m. Quasi m => Quasi (StateT s m) |]
     [e| \m1 m2 -> StateT $ \ s -> runStateT m1 s `qRecover` runStateT m2 s |])
 
 instance (Quote m, Monoid w) => Quote (RWST r w s m) where
     newName = Trans.lift . newName
 $(deriveQuasiTrans
-    [t| forall r w s m. (Quasi m, Monoid w) => Proxy2 (RWST r w s m) |]
+    [t| forall r w s m. (Quasi m, Monoid w) => Quasi (RWST r w s m) |]
     [e| \m1 m2 -> RWST $ \ r s -> runRWST m1 r s `qRecover` runRWST m2 r s |])
 
-#if MIN_VERSION_base(4,7,0) && defined(LANGUAGE_DeriveDataTypeable) && __GLASGOW_HASKELL__ < 710
-deriving instance Typeable Lift
-deriving instance Typeable Ppr
-deriving instance Typeable Quasi
-#endif
-
-#if MIN_VERSION_template_haskell(2,16,0)
+#if MIN_VERSION_template_haskell(2,16,0) && !(MIN_VERSION_template_haskell(2,22,1))
 instance Lift Bytes where
   lift bytes =
     [| Bytes
diff --git a/src/Language/Haskell/TH/Instances/Internal.hs b/src/Language/Haskell/TH/Instances/Internal.hs
--- a/src/Language/Haskell/TH/Instances/Internal.hs
+++ b/src/Language/Haskell/TH/Instances/Internal.hs
@@ -1,13 +1,9 @@
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE TemplateHaskell #-}
 
 -- | Defines a utility function for deriving 'Quasi' instances for monad
 -- transformer data types.
-module Language.Haskell.TH.Instances.Internal
-  ( deriveQuasiTrans
-  , Proxy2
-  ) where
+module Language.Haskell.TH.Instances.Internal (deriveQuasiTrans) where
 
 import qualified Control.Monad.Trans as MTL (lift)
 import Language.Haskell.TH.Lib
@@ -17,11 +13,7 @@
 deriveQuasiTrans ::
      Q Type  -- ^ The instance head. For example, this might be of the form:
              --
-             --   > [t| forall r m. Quasi m => Proxy2 (ReaderT r m) |]
-             --
-             --   Why use 'Proxy2' instead of 'Quasi'? Sadly, GHC 7.0/7.2 will
-             --   not accept it if you use the latter due to old TH bugs, so we
-             --   use 'Proxy2' as an ugly workaround.
+             --   > [t| forall r m. Quasi m => Quasi (ReaderT r m) |]
   -> Q Exp   -- ^ The implementation of 'qRecover'
   -> Q [Dec] -- ^ The 'Quasi' instance declaration
 deriveQuasiTrans qInstHead qRecoverExpr = do
@@ -30,7 +22,7 @@
       qInstCxt = return instCxt
       qInstTy  = case mangledInstTy of
                    ConT proxy2 `AppT` instTy
-                     |  proxy2 == ''Proxy2
+                     |  proxy2 == ''Quasi
                      -> conT ''Quasi `appT` return instTy
                    _ -> fail $ "Unexpected type " ++ pprint mangledInstTy
   instDec <- instanceD qInstCxt qInstTy qInstMethDecs
@@ -53,11 +45,9 @@
             , ('qReify,              [| MTL.lift . qReify |])
             , ('qLocation,           [| MTL.lift qLocation |])
             , ('qRunIO,              [| MTL.lift . qRunIO |])
-#if MIN_VERSION_template_haskell(2,7,0)
             , ('qReifyInstances,     [| \a b -> MTL.lift $ qReifyInstances a b |])
             , ('qLookupName,         [| \a b -> MTL.lift $ qLookupName a b |])
             , ('qAddDependentFile,   [| MTL.lift . qAddDependentFile |])
-# if MIN_VERSION_template_haskell(2,9,0)
             , ('qReifyRoles,         [| MTL.lift . qReifyRoles |])
             , ('qReifyAnnotations,   [| MTL.lift . qReifyAnnotations |])
             , ('qReifyModule,        [| MTL.lift . qReifyModule |])
@@ -65,16 +55,10 @@
             , ('qAddModFinalizer,    [| MTL.lift . qAddModFinalizer |])
             , ('qGetQ,               [| MTL.lift qGetQ |])
             , ('qPutQ,               [| MTL.lift . qPutQ |])
-# endif
-# if MIN_VERSION_template_haskell(2,11,0)
             , ('qReifyFixity,        [| MTL.lift . qReifyFixity |])
             , ('qReifyConStrictness, [| MTL.lift . qReifyConStrictness |])
             , ('qIsExtEnabled,       [| MTL.lift . qIsExtEnabled |])
             , ('qExtsEnabled,        [| MTL.lift qExtsEnabled |])
-# endif
-#elif MIN_VERSION_template_haskell(2,5,0)
-            , ('qClassInstances,     [| \a b -> MTL.lift $ qClassInstances a b |])
-#endif
 #if MIN_VERSION_template_haskell(2,14,0)
             , ('qAddForeignFilePath, [| \a b -> MTL.lift $ qAddForeignFilePath a b |])
             , ('qAddTempFile,        [| MTL.lift . qAddTempFile |])
@@ -100,7 +84,3 @@
           mkDec methName methRhs = valD (varP methName) (normalB methRhs) []
 
       in map (uncurry mkDec) instMeths
-
--- | See the Haddocks for 'deriveQuasiTrans' for an explanation of why this
--- type needs to exist.
-data Proxy2 (m :: * -> *)
diff --git a/th-orphans.cabal b/th-orphans.cabal
--- a/th-orphans.cabal
+++ b/th-orphans.cabal
@@ -1,5 +1,5 @@
 name:               th-orphans
-version:            0.13.14
+version:            0.13.15
 cabal-version:      >= 1.10
 build-type:         Simple
 license:            BSD3
@@ -10,20 +10,19 @@
 maintainer:         Ryan Scott <ryan.gl.scott@gmail.com>
 bug-reports:        https://github.com/mgsloan/th-orphans/issues
 stability:          experimental
-tested-with:        GHC == 7.0.4
-                  , GHC == 7.2.2
-                  , GHC == 7.4.2
-                  , GHC == 7.6.3
-                  , GHC == 7.8.4
-                  , GHC == 7.10.3
-                  , GHC == 8.0.2
+tested-with:        GHC == 8.0.2
                   , GHC == 8.2.2
                   , GHC == 8.4.4
                   , GHC == 8.6.5
                   , GHC == 8.8.4
                   , GHC == 8.10.7
-                  , GHC == 9.0.1
-                  , GHC == 9.2.1
+                  , GHC == 9.0.2
+                  , GHC == 9.2.8
+                  , GHC == 9.4.8
+                  , GHC == 9.6.6
+                  , GHC == 9.8.2
+                  , GHC == 9.10.1
+                  , GHC == 9.12.1
 synopsis:           Orphan instances for TH datatypes
 description:        Orphan instances for TH datatypes.  In particular, instances
                     for Ord and Lift, as well as a few missing Show / Eq.  These
@@ -32,27 +31,13 @@
 extra-source-files: CHANGELOG.md, README.md
 
 library
-  build-depends:      base >= 4.3 && < 5,
-                      template-haskell < 2.20,
+  build-depends:      base >= 4.9 && < 5,
+                      template-haskell >= 2.11 && < 2.23,
                       th-compat >= 0.1 && < 0.2,
                       -- https://github.com/mboes/th-lift/issues/14
                       th-lift >= 0.7.1,
                       th-reify-many >= 0.1.9 && < 0.2,
                       mtl >= 2
-
-  if !impl(ghc >= 8.0)
-    build-depends:    fail == 4.9.*,
-                      semigroups >= 0.18.5  && < 0.21
-
-  -- Use TH to derive Generics instances instead of DeriveGeneric, for < 7.10
-  if impl(ghc < 7.10)
-    build-depends:    generic-deriving >= 1.9
-                    , th-lift-instances
-
-  -- Prior to GHC 7.6, GHC generics lived in ghc-prim
-  if impl(ghc >= 7.2) && impl(ghc < 7.6)
-    build-depends:    ghc-prim
-
   hs-source-dirs:     src
   ghc-options:        -Wall
   if impl(ghc >= 8.6)