diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,11 @@
+0.16.1.4
+=========
+
+_Andreas Abel, 2025-08-27_
+
+- Drop support for GHC 7
+- Tested with GHC 8.2 - 9.14.1-alpha1
+
 0.16.1.3
 ========
 
diff --git a/acid-state.cabal b/acid-state.cabal
--- a/acid-state.cabal
+++ b/acid-state.cabal
@@ -1,5 +1,6 @@
+Cabal-version:       1.18
 Name:                acid-state
-Version:             0.16.1.3
+Version:             0.16.1.4
 Synopsis:            Add ACID guarantees to any serializable Haskell data structure.
 Description:         Use regular Haskell data structures as your database and get stronger ACID guarantees than most RDBMS offer.
 Homepage:            https://github.com/acid-state/acid-state
@@ -9,11 +10,14 @@
 -- Copyright:
 Category:            Database
 Build-type:          Simple
-Cabal-version:       >=1.10
 
 tested-with:
-  GHC == 9.6.2
-  GHC == 9.4.5
+  GHC == 9.14.1
+  GHC == 9.12.2
+  GHC == 9.10.2
+  GHC == 9.8.4
+  GHC == 9.6.7
+  GHC == 9.4.8
   GHC == 9.2.8
   GHC == 9.0.2
   GHC == 8.10.7
@@ -21,12 +25,13 @@
   GHC == 8.6.5
   GHC == 8.4.4
   GHC == 8.2.2
-  GHC == 8.0.2
-  GHC == 7.10.3
-  GHC == 7.8.4
+  -- cabal-3.12 cannot install dependency system-filepath any more in the GHC 8.0 environment
+  -- https://github.com/haskell/cabal/issues/10379
+  -- GHC == 8.0.2
 
-Extra-source-files:
+Extra-doc-files:
         CHANGELOG.md
+Extra-source-files:
         test-state/OldStateTest1/*.log
         test-state/OldStateTest1/*.version
         test-state/OldStateTest2/*.log
@@ -44,40 +49,41 @@
   manual: False
 
 Library
-  Exposed-Modules:     Data.Acid,
-                       Data.Acid.Archive,
-                       Data.Acid.Common,
-                       Data.Acid.Local, Data.Acid.Memory,
-                       Data.Acid.Memory.Pure, Data.Acid.Remote,
-                       Data.Acid.Advanced,
-                       Data.Acid.Log, Data.Acid.CRC,
-                       Data.Acid.Abstract, Data.Acid.Core,
+  Exposed-Modules:     Data.Acid
+                       Data.Acid.Archive
+                       Data.Acid.Common
+                       Data.Acid.Local Data.Acid.Memory
+                       Data.Acid.Memory.Pure Data.Acid.Remote
+                       Data.Acid.Advanced
+                       Data.Acid.Log Data.Acid.CRC
+                       Data.Acid.Abstract Data.Acid.Core
                        Data.Acid.TemplateHaskell
                        Data.Acid.Repair
 
-  Other-modules:       Paths_acid_state,
+  Other-modules:       Paths_acid_state
                        FileIO
 
-  Build-depends:       array,
-                       base >= 4.7 && < 5,
-                       bytestring >= 0.10.2,
-                       cereal >= 0.4.1.0,
-                       containers,
-                       safecopy >= 0.6 && < 0.11,
-                       stm >= 2.4,
-                       directory,
-                       filelock,
-                       filepath,
-                       mtl,
-                       network < 3.2,
-                       network-bsd,
-                       template-haskell < 2.22,
-                       th-expand-syns
+  -- Lower bounds taken from GHC 8.0 / LTS 7.0
+  Build-depends:       array             >= 0.5.1.1
+                     , base              >= 4.9        && < 5
+                     , bytestring        >= 0.10.8.0
+                     , cereal            >= 0.5.3.0
+                     , containers        >= 0.5.7.1
+                     , safecopy          >= 0.6        && < 0.11
+                     , stm               >= 2.4
+                     , directory         >= 1.2.6.2
+                     , filelock          >= 0.1.0.1
+                     , filepath          >= 1.4.1.0
+                     , mtl               >= 2.2.1
+                     , network           >= 2.6.3.1    && < 3.3
+                     , network-bsd
+                     , template-haskell  >= 2.11.0.0   && < 2.25
+                     , th-expand-syns    >= 0.4.0.0
 
   if os(windows)
-     Build-depends:       Win32
+     Build-depends:       Win32          >= 2.3.1.1
   else
-     Build-depends:       unix
+     Build-depends:       unix           >= 2.7.2.0
 
   Hs-Source-Dirs:      src/
 
@@ -88,13 +94,12 @@
 
   default-language:    Haskell2010
   GHC-Options:         -Wall
-                       -fno-warn-dodgy-imports
-                       -fno-warn-missing-signatures
-                       -fno-warn-name-shadowing
-                       -fno-warn-unused-do-bind
-                       -fno-warn-unused-matches
-  if impl(ghc >= 8.0)
-    ghc-options:       -Wcompat
+                       -Wcompat
+                       -Wno-dodgy-imports
+                       -Wno-missing-signatures
+                       -Wno-name-shadowing
+                       -Wno-unused-do-bind
+                       -Wno-unused-matches
 
 executable acid-state-repair
   hs-source-dirs: repair
@@ -113,7 +118,6 @@
                      , acid-state
                      , deepseq
                      , hspec
-                     , hspec-discover
                      , mtl
                      , safecopy
                      , template-haskell
diff --git a/examples/CheckpointCutsEvent.hs b/examples/CheckpointCutsEvent.hs
--- a/examples/CheckpointCutsEvent.hs
+++ b/examples/CheckpointCutsEvent.hs
@@ -14,7 +14,6 @@
 files should contain 10 checkpoints each.
 
 -}
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
@@ -27,7 +26,6 @@
 import           Data.Acid
 import           Data.List            ( sort )
 import           Data.SafeCopy
-import           Data.Typeable
 import           System.Directory
 import           System.Environment
 
@@ -35,7 +33,7 @@
 -- The Haskell structure that we want to encapsulate
 
 newtype Counter = Counter { unCounter :: Integer }
-    deriving (Show, Typeable)
+    deriving (Show)
 
 $(deriveSafeCopy 0 'base ''Counter)
 
diff --git a/examples/HelloDatabase.hs b/examples/HelloDatabase.hs
--- a/examples/HelloDatabase.hs
+++ b/examples/HelloDatabase.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
diff --git a/examples/HelloWorld.hs b/examples/HelloWorld.hs
--- a/examples/HelloWorld.hs
+++ b/examples/HelloWorld.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -8,14 +7,13 @@
 import           Control.Monad.State
 import           Data.Acid
 import           Data.SafeCopy
-import           Data.Typeable
 import           System.Environment
 
 ------------------------------------------------------
 -- The Haskell structure that we want to encapsulate
 
 data HelloWorldState = HelloWorldState String
-    deriving (Show, Typeable)
+    deriving (Show)
 
 $(deriveSafeCopy 0 'base ''HelloWorldState)
 
diff --git a/examples/HelloWorldNoTH.hs b/examples/HelloWorldNoTH.hs
--- a/examples/HelloWorldNoTH.hs
+++ b/examples/HelloWorldNoTH.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -13,13 +12,11 @@
 import           Data.SafeCopy
 import           System.Environment
 
-import           Data.Typeable
-
 ------------------------------------------------------
 -- The Haskell structure that we want to encapsulate
 
 data HelloWorldState = HelloWorldState String
-    deriving (Show, Typeable)
+    deriving (Show)
 
 instance SafeCopy HelloWorldState where
     putCopy (HelloWorldState state) = contain $ safePut state
@@ -57,8 +54,6 @@
 data WriteState = WriteState String
 data QueryState = QueryState
 
-
-deriving instance Typeable WriteState
 instance SafeCopy WriteState where
     putCopy (WriteState st) = contain $ safePut st
     getCopy = contain $ liftM WriteState safeGet
@@ -67,7 +62,6 @@
     type MethodState WriteState = HelloWorldState
 instance UpdateEvent WriteState
 
-deriving instance Typeable QueryState
 instance SafeCopy QueryState where
     putCopy QueryState = contain $ return ()
     getCopy = contain $ return QueryState
diff --git a/examples/KeyValue.hs b/examples/KeyValue.hs
--- a/examples/KeyValue.hs
+++ b/examples/KeyValue.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -15,8 +14,6 @@
 import           System.Exit
 import           System.IO
 
-import           Data.Typeable
-
 import qualified Data.Map             as Map
 
 ------------------------------------------------------
@@ -26,7 +23,6 @@
 type Value = String
 
 data KeyValue = KeyValue !(Map.Map Key Value)
-    deriving (Typeable)
 
 $(deriveSafeCopy 0 'base ''KeyValue)
 
diff --git a/examples/KeyValueNoTH.hs b/examples/KeyValueNoTH.hs
--- a/examples/KeyValueNoTH.hs
+++ b/examples/KeyValueNoTH.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -15,8 +14,6 @@
 import           System.Environment
 import           System.IO
 
-import           Data.Typeable
-
 import qualified Data.Map             as Map
 
 ------------------------------------------------------
@@ -26,7 +23,6 @@
 type Value = String
 
 data KeyValue = KeyValue !(Map.Map Key Value)
-    deriving (Typeable)
 
 instance SafeCopy KeyValue where
     putCopy (KeyValue state) = contain $ safePut state
@@ -74,8 +70,6 @@
 data InsertKey = InsertKey Key Value
 data LookupKey = LookupKey Key
 
-
-deriving instance Typeable InsertKey
 instance SafeCopy InsertKey where
     putCopy (InsertKey key value) = contain $ safePut key >> safePut value
     getCopy = contain $ InsertKey <$> safeGet <*> safeGet
@@ -84,7 +78,6 @@
     type MethodState InsertKey = KeyValue
 instance UpdateEvent InsertKey
 
-deriving instance Typeable LookupKey
 instance SafeCopy LookupKey where
     putCopy (LookupKey key) = contain $ safePut key
     getCopy = contain $ LookupKey <$> safeGet
diff --git a/examples/MonadStateConstraint.hs b/examples/MonadStateConstraint.hs
--- a/examples/MonadStateConstraint.hs
+++ b/examples/MonadStateConstraint.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE FlexibleContexts   #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
@@ -9,14 +8,13 @@
 import           Control.Monad.State
 import           Data.Acid
 import           Data.SafeCopy
-import           Data.Typeable
 import           System.Environment
 
 ------------------------------------------------------
 -- The Haskell structure that we want to encapsulate
 
 data HelloWorldState = HelloWorldState String
-    deriving (Show, Typeable)
+    deriving (Show)
 
 $(deriveSafeCopy 0 'base ''HelloWorldState)
 
diff --git a/examples/ParameterisedState.hs b/examples/ParameterisedState.hs
--- a/examples/ParameterisedState.hs
+++ b/examples/ParameterisedState.hs
@@ -1,5 +1,4 @@
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE TypeFamilies #-}
@@ -28,10 +27,6 @@
 
 newtype Store k = Store { store :: Map.Map k (Entry k) }
     deriving (Eq, Generic)
-
-#if __GLASGOW_HASKELL__ <= 708
-deriving instance Typeable1 Store
-#endif
 
 instance (Ord k, Serialize k, SafeCopy k, Typeable k) => SafeCopy (Store k)
 instance (Ord k, Serialize k) => Serialize (Store k)
diff --git a/examples/Proxy.hs b/examples/Proxy.hs
--- a/examples/Proxy.hs
+++ b/examples/Proxy.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -15,13 +14,10 @@
 import           System.Environment
 import           System.IO
 
-import           Data.Typeable
-
 ------------------------------------------------------
 -- The Haskell structure that we want to encapsulate
 
 data ProxyStressState = StressState !Int
-    deriving (Typeable)
 
 $(deriveSafeCopy 0 'base ''ProxyStressState)
 
diff --git a/examples/RemoteCommon.hs b/examples/RemoteCommon.hs
--- a/examples/RemoteCommon.hs
+++ b/examples/RemoteCommon.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -8,12 +7,11 @@
 import           Control.Monad.State
 import           Data.Acid
 import           Data.SafeCopy
-import           Data.Typeable
 
 ------------------------------------------------------
 -- The Haskell structure that we want to encapsulate
 
-data StressState = StressState !Int deriving (Typeable)
+data StressState = StressState !Int
 
 $(deriveSafeCopy 0 'base ''StressState)
 
diff --git a/examples/SlowCheckpoint.hs b/examples/SlowCheckpoint.hs
--- a/examples/SlowCheckpoint.hs
+++ b/examples/SlowCheckpoint.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
diff --git a/examples/StressTest.hs b/examples/StressTest.hs
--- a/examples/StressTest.hs
+++ b/examples/StressTest.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -13,13 +12,10 @@
 import           System.Environment
 import           System.IO
 
-import           Data.Typeable
-
 ------------------------------------------------------
 -- The Haskell structure that we want to encapsulate
 
 data StressState = StressState !Int
-    deriving (Typeable)
 
 $(deriveSafeCopy 0 'base ''StressState)
 
diff --git a/examples/StressTestNoTH.hs b/examples/StressTestNoTH.hs
--- a/examples/StressTestNoTH.hs
+++ b/examples/StressTestNoTH.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -14,13 +13,10 @@
 import           System.Environment
 import           System.IO
 
-import           Data.Typeable
-
 ------------------------------------------------------
 -- The Haskell structure that we want to encapsulate
 
 data StressState = StressState !Int
-    deriving (Typeable)
 
 instance SafeCopy StressState where
     putCopy (StressState state) = contain $ safePut state
@@ -66,7 +62,6 @@
 data PokeState = PokeState
 data QueryState = QueryState
 
-deriving instance Typeable PokeState
 instance SafeCopy PokeState where
     putCopy PokeState = contain $ return ()
     getCopy = contain $ return PokeState
@@ -75,7 +70,6 @@
     type MethodState PokeState = StressState
 instance UpdateEvent PokeState
 
-deriving instance Typeable QueryState
 instance SafeCopy QueryState where
     putCopy QueryState = contain $ return ()
     getCopy = contain $ return QueryState
diff --git a/examples/errors/Exceptions.hs b/examples/errors/Exceptions.hs
--- a/examples/errors/Exceptions.hs
+++ b/examples/errors/Exceptions.hs
@@ -1,5 +1,4 @@
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -8,17 +7,12 @@
 import           Data.Acid
 import           Data.Acid.Local     (createCheckpointAndClose)
 
-#if !MIN_VERSION_base(4,8,0)
-import           Control.Applicative
-#endif
 import           Control.Monad
 import           Control.Monad.State ( get, put )
 import           Data.SafeCopy
 import           System.Directory
 import           System.Environment
 
-import           Data.Typeable
-
 import           Control.Exception
 import           Prelude             hiding (catch)
 
@@ -26,7 +20,7 @@
 -- The Haskell structure that we want to encapsulate
 
 data MyState = MyState Integer
-    deriving (Show, Typeable)
+    deriving (Show)
 
 $(deriveSafeCopy 0 'base ''MyState)
 
diff --git a/examples/errors/RemoveEvent.hs b/examples/errors/RemoveEvent.hs
--- a/examples/errors/RemoveEvent.hs
+++ b/examples/errors/RemoveEvent.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
@@ -11,8 +10,6 @@
 import           System.Directory
 import           System.Environment
 import           Data.List (isSuffixOf)
-
-import           Data.Typeable
 
 import           Control.Exception
 import           Prelude             hiding (catch)
diff --git a/src/Data/Acid/Abstract.hs b/src/Data/Acid/Abstract.hs
--- a/src/Data/Acid/Abstract.hs
+++ b/src/Data/Acid/Abstract.hs
@@ -18,18 +18,10 @@
 import Data.ByteString.Lazy    ( ByteString )
 import Control.Monad           ( void )
 import Control.Monad.Trans     ( MonadIO(liftIO) )
-#if __GLASGOW_HASKELL__ >= 707
 import Data.Typeable           ( Typeable, gcast, typeOf )
-#else
-import Data.Typeable           ( Typeable1, gcast1, typeOf1 )
-#endif
 
 data AnyState st where
-#if __GLASGOW_HASKELL__ >= 707
   AnyState :: Typeable sub_st => sub_st st -> AnyState st
-#else
-  AnyState :: Typeable1 sub_st => sub_st st -> AnyState st
-#endif
 
 -- Haddock doesn't get the types right on its own.
 {-| State container offering full ACID (Atomicity, Consistency, Isolation and Durability)
@@ -116,14 +108,9 @@
 query' :: (QueryEvent event, MonadIO m) => AcidState (EventState event) -> event -> m (EventResult event)
 query' acidState event = liftIO (query acidState event)
 
-#if __GLASGOW_HASKELL__ >= 707
 mkAnyState :: Typeable sub_st => sub_st st -> AnyState st
-#else
-mkAnyState :: Typeable1 sub_st => sub_st st -> AnyState st
-#endif
 mkAnyState = AnyState
 
-#if __GLASGOW_HASKELL__ >= 707
 downcast :: (Typeable sub, Typeable st) => AcidState st -> sub st
 downcast AcidState{acidSubState = AnyState sub}
   = r
@@ -133,14 +120,3 @@
          _ ->
            error $
             "Data.Acid.Abstract: Invalid subtype cast: " ++ show (typeOf sub) ++ " -> " ++ show (typeOf r)
-#else
-downcast :: Typeable1 sub => AcidState st -> sub st
-downcast AcidState{acidSubState = AnyState sub}
-  = r
- where
-   r = case gcast1 (Just sub) of
-         Just (Just x) -> x
-         _ ->
-           error $
-            "Data.Acid.Abstract: Invalid subtype cast: " ++ show (typeOf1 sub) ++ " -> " ++ show (typeOf1 r)
-#endif
diff --git a/src/Data/Acid/Common.hs b/src/Data/Acid/Common.hs
--- a/src/Data/Acid/Common.hs
+++ b/src/Data/Acid/Common.hs
@@ -17,10 +17,6 @@
 import Control.Monad
 import Control.Monad.State   (MonadState, get, State)
 import Control.Monad.Reader  (MonadReader, Reader, runReader)
-#if !MIN_VERSION_base(4,8,0)
-import Control.Applicative
-#endif
-
 
 class IsAcidic st where
     acidEvents :: [Event st]
diff --git a/src/Data/Acid/Core.hs b/src/Data/Acid/Core.hs
--- a/src/Data/Acid/Core.hs
+++ b/src/Data/Acid/Core.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, GADTs, DeriveDataTypeable, TypeFamilies,
+{-# LANGUAGE CPP, GADTs, TypeFamilies,
              FlexibleContexts, BangPatterns,
              DefaultSignatures, ScopedTypeVariables #-}
 -----------------------------------------------------------------------------
@@ -60,17 +60,9 @@
 import Data.Serialize                     ( runPutLazy, runGetLazy )
 import Data.SafeCopy                      ( SafeCopy, safeGet, safePut )
 
-import Data.Typeable                      ( Typeable, TypeRep, typeRepTyCon, typeOf )
+import Data.Typeable                      ( Typeable, TypeRep, typeRepTyCon, typeOf, tyConModule )
 import Unsafe.Coerce                      ( unsafeCoerce )
 
-#if MIN_VERSION_base(4,5,0)
-import Data.Typeable                      ( tyConModule )
-#else
-import Data.Typeable.Internal             ( tyConModule )
-#endif
-
-#if MIN_VERSION_base(4,4,0)
-
 -- in base >= 4.4 the Show instance for TypeRep no longer provides a
 -- fully qualified name. But we have old data around that expects the
 -- FQN. So we will recreate the old naming system for newer versions
@@ -79,14 +71,6 @@
 showQualifiedTypeRep :: TypeRep -> String
 showQualifiedTypeRep tr = tyConModule con ++ "." ++ show tr
   where con = typeRepTyCon tr
-
-#else
-
-showQualifiedTypeRep :: TypeRep -> String
-showQualifiedTypeRep tr = show tr
-
-#endif
-
 
 -- | Interface for (de)serialising values of type @a@.
 --
diff --git a/src/Data/Acid/Local.hs b/src/Data/Acid/Local.hs
--- a/src/Data/Acid/Local.hs
+++ b/src/Data/Acid/Local.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE DeriveDataTypeable, BangPatterns, CPP #-}
+{-# LANGUAGE BangPatterns, CPP #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Acid.Local
@@ -41,9 +41,6 @@
 import Control.Exception              ( onException, evaluate, Exception, throwIO )
 import Control.Monad.State            ( runState )
 import Control.Monad                  ( join )
-#if !MIN_VERSION_base(4,8,0)
-import Control.Applicative            ( (<$>), (<*>) )
-#endif
 import Data.ByteString.Lazy           ( ByteString )
 import qualified Data.ByteString.Lazy as Lazy ( length )
 
@@ -76,9 +73,9 @@
                  , localEvents      :: FileLog (Tagged ByteString)
                  , localCheckpoints :: FileLog (Checkpoint st)
                  , localLock        :: FileLock
-                 } deriving (Typeable)
+                 }
 
-newtype StateIsLocked = StateIsLocked FilePath deriving (Show, Typeable)
+newtype StateIsLocked = StateIsLocked FilePath deriving (Show)
 
 instance Exception StateIsLocked
 
diff --git a/src/Data/Acid/Memory.hs b/src/Data/Acid/Memory.hs
--- a/src/Data/Acid/Memory.hs
+++ b/src/Data/Acid/Memory.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE DeriveDataTypeable, BangPatterns #-}
+{-# LANGUAGE BangPatterns #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Acid.Memory
@@ -22,7 +22,6 @@
 import Control.Concurrent             ( newEmptyMVar, putMVar, MVar )
 import Control.Monad.State            ( runState )
 import Data.ByteString.Lazy           ( ByteString )
-import Data.Typeable                  ( Typeable )
 import Data.IORef                     ( IORef, newIORef, readIORef, writeIORef )
 
 
@@ -42,7 +41,7 @@
 data MemoryState st
     = MemoryState { localCore    :: Core st
                   , localCopy    :: IORef st
-                  } deriving (Typeable)
+                  }
 
 -- | Create an 'AcidState' given an initial value.  The state is kept only in
 -- memory, so it is not durable.
diff --git a/src/Data/Acid/Memory/Pure.hs b/src/Data/Acid/Memory/Pure.hs
--- a/src/Data/Acid/Memory/Pure.hs
+++ b/src/Data/Acid/Memory/Pure.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE DeriveDataTypeable, BangPatterns #-}
+{-# LANGUAGE BangPatterns #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Acid.Memory.Pure
diff --git a/src/Data/Acid/Remote.hs b/src/Data/Acid/Remote.hs
--- a/src/Data/Acid/Remote.hs
+++ b/src/Data/Acid/Remote.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, DeriveDataTypeable, RankNTypes, RecordWildCards, ScopedTypeVariables #-}
+{-# LANGUAGE CPP, RankNTypes, RecordWildCards, ScopedTypeVariables #-}
 -----------------------------------------------------------------------------
 {- |
  Module      :  Data.Acid.Remote
@@ -96,9 +96,6 @@
     ) where
 
 import Prelude                                hiding ( catch )
-#if !MIN_VERSION_base(4,8,0)
-import Control.Applicative
-#endif
 import Control.Concurrent.STM                        ( atomically )
 import Control.Concurrent.STM.TMVar                  ( newEmptyTMVar, readTMVar, takeTMVar, tryTakeTMVar, putTMVar )
 import Control.Concurrent.STM.TQueue
@@ -122,7 +119,6 @@
 import Data.IORef                                    ( newIORef, readIORef, writeIORef )
 import Data.Serialize
 import Data.Set                                      ( Set, member )
-import Data.Typeable                                 ( Typeable )
 import GHC.IO.Exception                              ( IOErrorType(..) )
 import Network.BSD                                   ( PortNumber, getProtocolNumber, getHostByName, hostAddress )
 import Network.Socket
@@ -150,7 +146,7 @@
     | AcidStateClosed
     | SerializeError String
     | AuthenticationError String
-      deriving (Eq, Show, Typeable)
+      deriving (Eq, Show)
 instance Exception AcidRemoteException
 
 -- | create a 'CommChannel' from a 'Handle'. The 'Handle' should be
@@ -380,7 +376,6 @@
                                 writeChan chan (return Acknowledgement)
 
 data RemoteState st = RemoteState (Command -> IO (MVar Response)) (IO ())
-                    deriving (Typeable)
 
 {- | Connect to an acid-state server which is sharing an 'AcidState'. -}
 openRemoteState :: IsAcidic st =>
diff --git a/src/Data/Acid/TemplateHaskell.hs b/src/Data/Acid/TemplateHaskell.hs
--- a/src/Data/Acid/TemplateHaskell.hs
+++ b/src/Data/Acid/TemplateHaskell.hs
@@ -17,9 +17,6 @@
 #if !MIN_VERSION_base(4,11,0)
 import Data.Monoid ((<>))
 #endif
-#if !MIN_VERSION_base(4,8,0)
-import Control.Applicative
-#endif
 import Control.Monad
 import Control.Monad.State (MonadState)
 import Control.Monad.Reader (MonadReader)
@@ -89,22 +86,14 @@
            TyConI tycon
              ->case tycon of
 
-#if MIN_VERSION_template_haskell(2,11,0)
                  DataD _cxt _name tyvars _kind constructors _derivs
-#else
-                 DataD _cxt _name tyvars constructors _derivs
-#endif
 #if MIN_VERSION_template_haskell(2,21,0)
                    -> makeAcidic' ss eventNames stateName (map void tyvars) constructors
 #else
                    -> makeAcidic' ss eventNames stateName tyvars constructors
 #endif
 
-#if MIN_VERSION_template_haskell(2,11,0)
                  NewtypeD _cxt _name tyvars _kind constructor _derivs
-#else
-                 NewtypeD _cxt _name tyvars constructor _derivs
-#endif
 #if MIN_VERSION_template_haskell(2,21,0)
                    -> makeAcidic' ss eventNames stateName (map void tyvars) [constructor]
 #else
@@ -156,11 +145,7 @@
 getEventType eventName
     = do eventInfo <- reify eventName
          case eventInfo of
-#if MIN_VERSION_template_haskell(2,11,0)
            VarI _name eventType _decl
-#else
-           VarI _name eventType _decl _fixity
-#endif
              -> expandSyns eventType
            _ -> error $ "Data.Acid.TemplateHaskell: Events must be functions: " ++ show eventName
 
@@ -239,12 +224,7 @@
     where
       -- | rename the type variables in a Pred
       unify :: [(Name, Name)] -> Pred -> Pred
-#if MIN_VERSION_template_haskell(2,10,0)
       unify table p = rename p table p -- in 2.10.0: type Pred = Type
-#else
-      unify table p@(ClassP n tys) = ClassP n (map (rename p table) tys)
-      unify table p@(EqualP a b)   = EqualP (rename p table a) (rename p table b)
-#endif
 
       -- | rename the type variables in a Type
       rename :: Pred -> [(Name, Name)] -> Type -> Type
@@ -289,12 +269,7 @@
 renameState :: Type -> Type -> Cxt -> Cxt
 renameState tfrom tto cxt = map renamePred cxt
   where
-#if MIN_VERSION_template_haskell(2,10,0)
     renamePred p = renameType p -- in 2.10.0: type Pred = Type
-#else
-    renamePred (ClassP n tys) = ClassP n (map renameType tys)
-    renamePred (EqualP a b)   = EqualP (renameType a) (renameType b)
-#endif
     renameType n | n == tfrom = tto
     renameType (AppT a b)     = AppT (renameType a) (renameType b)
     renameType (SigT a k)     = SigT (renameType a) k
@@ -328,18 +303,11 @@
                       , pprint stateType
                       ]
 
---data MyUpdateEvent = MyUpdateEvent Arg1 Arg2
---  deriving (Typeable)
+-- data MyUpdateEvent = MyUpdateEvent Arg1 Arg2
 makeEventDataType :: Name -> Type -> DecQ
 makeEventDataType eventName eventType
     = do let con = normalC eventStructName [ strictType notStrict (return arg) | arg <- args ]
-#if MIN_VERSION_template_haskell(2,12,0)
-             cxt = [derivClause Nothing [conT ''Typeable]]
-#elif MIN_VERSION_template_haskell(2,11,0)
-             cxt = mapM conT [''Typeable]
-#else
-             cxt = [''Typeable]
-#endif
+             cxt = []
          case args of
 #if MIN_VERSION_template_haskell(2,21,0)
           [_] -> newtypeD (return []) eventStructName (map (BndrReq <$) tyvars) Nothing con cxt
@@ -445,7 +413,6 @@
 analyseType :: Name -> Type -> TypeAnalysis
 analyseType eventName t = go [] [] [] t
   where
-#if MIN_VERSION_template_haskell(2,10,0)
     getMonadReader :: Cxt -> Name -> [(Type, Type)]
     getMonadReader cxt m = do
        constraint@(AppT (AppT (ConT c) x) m') <- cxt
@@ -457,19 +424,6 @@
        constraint@(AppT (AppT (ConT c) x) m') <- cxt
        guard (c == ''MonadState && m' == VarT m)
        return (constraint, x)
-#else
-    getMonadReader :: Cxt -> Name -> [(Pred, Type)]
-    getMonadReader cxt m = do
-       constraint@(ClassP c [x, m']) <- cxt
-       guard (c == ''MonadReader && m' == VarT m)
-       return (constraint, x)
-
-    getMonadState :: Cxt -> Name -> [(Pred, Type)]
-    getMonadState cxt m = do
-       constraint@(ClassP c [x, m']) <- cxt
-       guard (c == ''MonadState && m' == VarT m)
-       return (constraint, x)
-#endif
 
     -- a -> b
     go tyvars cxt args (AppT (AppT ArrowT a) b)
diff --git a/test/Data/Acid/KeyValueStateMachine.hs b/test/Data/Acid/KeyValueStateMachine.hs
--- a/test/Data/Acid/KeyValueStateMachine.hs
+++ b/test/Data/Acid/KeyValueStateMachine.hs
@@ -17,7 +17,6 @@
 import           Data.Acid.StateMachineTest
 import           Data.SafeCopy
 import qualified Data.Map as Map
-import           Data.Typeable
 import           GHC.Generics
 import           Hedgehog
 import qualified Hedgehog.Gen as Gen
@@ -28,7 +27,7 @@
 type Value = String
 
 data KeyValue = KeyValue !(Map.Map Key Value)
-    deriving (Eq, Show, Typeable)
+    deriving (Eq, Show)
 
 $(deriveSafeCopy 0 'base ''KeyValue)
 
diff --git a/test/Data/Acid/TemplateHaskellSpec.hs b/test/Data/Acid/TemplateHaskellSpec.hs
--- a/test/Data/Acid/TemplateHaskellSpec.hs
+++ b/test/Data/Acid/TemplateHaskellSpec.hs
@@ -11,7 +11,6 @@
 import Test.Hspec hiding (context)
 
 import Data.SafeCopy (SafeCopy)
-import Data.Typeable (Typeable)
 import Control.DeepSeq (force)
 import Control.Exception (evaluate)
 import Language.Haskell.TH
@@ -105,15 +104,10 @@
                 `shouldBe` TypeAnalysis
                     { tyvars = []
                     , context =
-#if MIN_VERSION_template_haskell(2,10,0)
                         [ ConT ''MonadReader
                             `AppT` ConT ''Int
                             `AppT` VarT m
                         ]
-#else
-                        [ ClassP ''MonadReader [ConT ''Int, VarT m]
-                        ]
-#endif
                     , argumentTypes = [ConT ''Int]
                     , stateType = ConT ''Int
                     , resultType = VarT m `AppT` TupleT 0
@@ -155,21 +149,13 @@
 
             eventCxts stateType binders name eventType
                 `shouldBe`
-#if MIN_VERSION_template_haskell(2,10,0)
                     [ConT ''Ord `AppT` VarT x]
-#else
-                    [ClassP ''Ord [VarT x]]
-#endif
 
         it "can rename a polymorphic state" $ do
             eventType <- runQ [t| forall r m. (MonadReader r m, Ord r) => Int -> m Char |]
             eventCxts stateType binders name eventType
                 `shouldBe`
-#if MIN_VERSION_template_haskell(2,10,0)
                     [ConT ''Ord `AppT` ConT ''Char]
-#else
-                    [ClassP ''Ord [ConT ''Char]]
-#endif
 
 
 quoteShouldBe :: (Eq a, Show a) => Q a -> Q [a] -> Expectation