diff --git a/cabal.project b/cabal.project
--- a/cabal.project
+++ b/cabal.project
@@ -1,1 +1,5 @@
 packages: .
+
+tests: True
+
+test-show-details: direct
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,16 @@
 # Hashtables changelog
 
+## 1.3
+
+Support Hashable 1.4. This new version of Hashable drops the Eq constraint, so the Eq constraint
+needs to be dropped in the SPECIALIZE statements in Hashtables.
+
+## 1.2.4.2
+
+Cabal file: add missing other-modules
+Silence import warnings. Know that we require ghc >= 7.8.
+Fix build with GHC 9.2
+
 ## 1.2.4.1
 
 Update some test suite dep upper bounds.
diff --git a/hashtables.cabal b/hashtables.cabal
--- a/hashtables.cabal
+++ b/hashtables.cabal
@@ -1,6 +1,6 @@
 Cabal-Version: 2.2
 Name:                hashtables
-Version:             1.2.4.2
+Version:             1.3
 Synopsis:            Mutable hash tables in the ST monad
 Homepage:            http://github.com/gregorycollins/hashtables
 License:             BSD-3-Clause
@@ -192,7 +192,7 @@
                      Data.HashTable.Internal.Linear.Bucket
 
   Build-depends:     base      >= 4.7 && <5,
-                     hashable  >= 1.1 && <1.2 || >= 1.2.1 && <1.4,
+                     hashable  >= 1.4 && < 1.5,
                      primitive,
                      vector    >= 0.7 && <0.13
 
@@ -270,7 +270,7 @@
     cpp-options: -DBOUNDS_CHECKING
 
   Build-depends:     base                       >= 4     && <5,
-                     hashable  >= 1.1 && <1.2 || >= 1.2.1 && <1.4,
+                     hashable                   >= 1.4 && < 1.5,
                      mwc-random                 >= 0.8   && <0.16,
                      primitive,
                      QuickCheck                 >= 2.3.0.2,
diff --git a/src/Data/HashTable/IO.hs b/src/Data/HashTable/IO.hs
--- a/src/Data/HashTable/IO.hs
+++ b/src/Data/HashTable/IO.hs
@@ -123,11 +123,11 @@
             IOHashTable h k v -> k -> v -> IO ()
 insert h k v = stToIO $ C.insert h k v
 {-# INLINE insert #-}
-{-# SPECIALIZE INLINE insert :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE insert :: Hashable k =>
                          BasicHashTable  k v -> k -> v -> IO () #-}
-{-# SPECIALIZE INLINE insert :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE insert :: Hashable k =>
                          LinearHashTable k v -> k -> v -> IO () #-}
-{-# SPECIALIZE INLINE insert :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE insert :: Hashable k =>
                          CuckooHashTable k v -> k -> v -> IO () #-}
 
 
@@ -137,11 +137,11 @@
             IOHashTable h k v -> k -> IO ()
 delete h k = stToIO $ C.delete h k
 {-# INLINE delete #-}
-{-# SPECIALIZE INLINE delete :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE delete :: Hashable k =>
                          BasicHashTable  k v -> k -> IO () #-}
-{-# SPECIALIZE INLINE delete :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE delete :: Hashable k =>
                          LinearHashTable k v -> k -> IO () #-}
-{-# SPECIALIZE INLINE delete :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE delete :: Hashable k =>
                          CuckooHashTable k v -> k -> IO () #-}
 
 
@@ -151,11 +151,11 @@
             IOHashTable h k v -> k -> IO (Maybe v)
 lookup h k = stToIO $ C.lookup h k
 {-# INLINE lookup #-}
-{-# SPECIALIZE INLINE lookup :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE lookup :: Hashable k =>
                          BasicHashTable  k v -> k -> IO (Maybe v) #-}
-{-# SPECIALIZE INLINE lookup :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE lookup :: Hashable k =>
                          LinearHashTable k v -> k -> IO (Maybe v) #-}
-{-# SPECIALIZE INLINE lookup :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE lookup :: Hashable k =>
                          CuckooHashTable k v -> k -> IO (Maybe v) #-}
 
 ------------------------------------------------------------------------------
@@ -164,11 +164,11 @@
                  IOHashTable h k v -> k -> IO (Maybe Word)
 lookupIndex h k = stToIO $ C.lookupIndex h k
 {-# INLINE lookupIndex #-}
-{-# SPECIALIZE INLINE lookupIndex :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE lookupIndex :: Hashable k =>
                          BasicHashTable  k v -> k -> IO (Maybe Word) #-}
-{-# SPECIALIZE INLINE lookupIndex :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE lookupIndex :: Hashable k =>
                          LinearHashTable k v -> k -> IO (Maybe Word) #-}
-{-# SPECIALIZE INLINE lookupIndex :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE lookupIndex :: Hashable k =>
                          CuckooHashTable k v -> k -> IO (Maybe Word) #-}
 
 ------------------------------------------------------------------------------
@@ -177,11 +177,11 @@
                  IOHashTable h k v -> Word -> IO (Maybe (Word,k,v))
 nextByIndex h k = stToIO $ C.nextByIndex h k
 {-# INLINE nextByIndex #-}
-{-# SPECIALIZE INLINE nextByIndex :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE nextByIndex :: Hashable k =>
                          BasicHashTable  k v -> Word -> IO (Maybe (Word,k,v)) #-}
-{-# SPECIALIZE INLINE nextByIndex :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE nextByIndex :: Hashable k =>
                          LinearHashTable k v -> Word -> IO (Maybe (Word,k,v)) #-}
-{-# SPECIALIZE INLINE nextByIndex :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE nextByIndex :: Hashable k =>
                          CuckooHashTable k v -> Word -> IO (Maybe (Word,k,v)) #-}
 
 ------------------------------------------------------------------------------
@@ -190,11 +190,11 @@
               IOHashTable h k v -> k -> (Maybe v -> IO (Maybe v, a)) -> IO a
 mutateIO h k f = stToIO $ C.mutateST h k (ioToST . f)
 {-# INLINE mutateIO #-}
-{-# SPECIALIZE INLINE mutateIO :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE mutateIO :: Hashable k =>
                          BasicHashTable  k v -> k -> (Maybe v -> IO (Maybe v, a)) -> IO a #-}
-{-# SPECIALIZE INLINE mutateIO :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE mutateIO :: Hashable k =>
                          LinearHashTable k v -> k -> (Maybe v -> IO (Maybe v, a)) -> IO a #-}
-{-# SPECIALIZE INLINE mutateIO :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE mutateIO :: Hashable k =>
                          CuckooHashTable k v -> k -> (Maybe v -> IO (Maybe v, a)) -> IO a #-}
 
 ------------------------------------------------------------------------------
@@ -203,11 +203,11 @@
             IOHashTable h k v -> k -> (Maybe v -> (Maybe v, a)) -> IO a
 mutate h k f = stToIO $ C.mutate h k f
 {-# INLINE mutate #-}
-{-# SPECIALIZE INLINE mutate :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE mutate :: Hashable k =>
                          BasicHashTable  k v -> k -> (Maybe v -> (Maybe v, a)) -> IO a #-}
-{-# SPECIALIZE INLINE mutate :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE mutate :: Hashable k =>
                          LinearHashTable k v -> k -> (Maybe v -> (Maybe v, a)) -> IO a #-}
-{-# SPECIALIZE INLINE mutate :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE mutate :: Hashable k =>
                          CuckooHashTable k v -> k -> (Maybe v -> (Maybe v, a)) -> IO a #-}
 
 
@@ -218,11 +218,11 @@
             [(k,v)] -> IO (IOHashTable h k v)
 fromList = stToIO . C.fromList
 {-# INLINE fromList #-}
-{-# SPECIALIZE INLINE fromList :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE fromList :: Hashable k =>
                            [(k,v)] -> IO (BasicHashTable  k v) #-}
-{-# SPECIALIZE INLINE fromList :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE fromList :: Hashable k =>
                            [(k,v)] -> IO (LinearHashTable k v) #-}
-{-# SPECIALIZE INLINE fromList :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE fromList :: Hashable k =>
                            [(k,v)] -> IO (CuckooHashTable k v) #-}
 
 
@@ -233,11 +233,11 @@
                         Int -> [(k,v)] -> IO (IOHashTable h k v)
 fromListWithSizeHint n = stToIO . C.fromListWithSizeHint n
 {-# INLINE fromListWithSizeHint #-}
-{-# SPECIALIZE INLINE fromListWithSizeHint :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE fromListWithSizeHint :: Hashable k =>
                            Int -> [(k,v)] -> IO (BasicHashTable  k v) #-}
-{-# SPECIALIZE INLINE fromListWithSizeHint :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE fromListWithSizeHint :: Hashable k =>
                            Int -> [(k,v)] -> IO (LinearHashTable k v) #-}
-{-# SPECIALIZE INLINE fromListWithSizeHint :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE fromListWithSizeHint :: Hashable k =>
                            Int -> [(k,v)] -> IO (CuckooHashTable k v) #-}
 
 
@@ -247,11 +247,11 @@
             IOHashTable h k v -> IO [(k,v)]
 toList = stToIO . C.toList
 {-# INLINE toList #-}
-{-# SPECIALIZE INLINE toList :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE toList :: Hashable k =>
                          BasicHashTable  k v -> IO [(k,v)] #-}
-{-# SPECIALIZE INLINE toList :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE toList :: Hashable k =>
                          LinearHashTable k v -> IO [(k,v)] #-}
-{-# SPECIALIZE INLINE toList :: (Eq k, Hashable k) =>
+{-# SPECIALIZE INLINE toList :: Hashable k =>
                          CuckooHashTable k v -> IO [(k,v)] #-}