diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,13 @@
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/).
 
+## [0.1.5] - 2022-02-01
+### Added
+- `Eq1` and `Eq2` instances
+
+### Changed
+- Support `hashable-1.4`
+
 ## [0.1.4] - 2020-11-11
 ### Changed
 - Fixed `NFData` instances
diff --git a/src/Data/Tuple/Strict/T10.hs b/src/Data/Tuple/Strict/T10.hs
--- a/src/Data/Tuple/Strict/T10.hs
+++ b/src/Data/Tuple/Strict/T10.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T10 a b c d e f g h i)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq1 (T10 a b c d e f g h i) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq2 (T10 a b c d e f g h) where
+  liftEq2 e1 e2 (T10 a b c d e f g h i j) (T10 a' b' c' d' e' f' g' h' i' j') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && e1 i i' && e2 j j'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g, Monoid h, Monoid i) => Applicative (T10 a b c d e f g h i) where
diff --git a/src/Data/Tuple/Strict/T11.hs b/src/Data/Tuple/Strict/T11.hs
--- a/src/Data/Tuple/Strict/T11.hs
+++ b/src/Data/Tuple/Strict/T11.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T11 a b c d e f g h i j)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq1 (T11 a b c d e f g h i j) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq2 (T11 a b c d e f g h i) where
+  liftEq2 e1 e2 (T11 a b c d e f g h i j k) (T11 a' b' c' d' e' f' g' h' i' j' k') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && e1 j j' && e2 k k'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g, Monoid h, Monoid i, Monoid j) => Applicative (T11 a b c d e f g h i j) where
diff --git a/src/Data/Tuple/Strict/T12.hs b/src/Data/Tuple/Strict/T12.hs
--- a/src/Data/Tuple/Strict/T12.hs
+++ b/src/Data/Tuple/Strict/T12.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T12 a b c d e f g h i j k)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq1 (T12 a b c d e f g h i j k) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq2 (T12 a b c d e f g h i j) where
+  liftEq2 e1 e2 (T12 a b c d e f g h i j k l) (T12 a' b' c' d' e' f' g' h' i' j' k' l') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && j == j' && e1 k k' && e2 l l'
 
 -- | @since 0.1.3
 instance
diff --git a/src/Data/Tuple/Strict/T13.hs b/src/Data/Tuple/Strict/T13.hs
--- a/src/Data/Tuple/Strict/T13.hs
+++ b/src/Data/Tuple/Strict/T13.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T13 a b c d e f g h i j k l)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq1 (T13 a b c d e f g h i j k l) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq2 (T13 a b c d e f g h i j k) where
+  liftEq2 e1 e2 (T13 a b c d e f g h i j k l m) (T13 a' b' c' d' e' f' g' h' i' j' k' l' m') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && j == j' && k == k' && e1 l l' && e2 m m'
 
 -- | @since 0.1.3
 instance
diff --git a/src/Data/Tuple/Strict/T14.hs b/src/Data/Tuple/Strict/T14.hs
--- a/src/Data/Tuple/Strict/T14.hs
+++ b/src/Data/Tuple/Strict/T14.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T14 a b c d e f g h i j k l m)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq1 (T14 a b c d e f g h i j k l m) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq2 (T14 a b c d e f g h i j k l) where
+  liftEq2 e1 e2 (T14 a b c d e f g h i j k l m n) (T14 a' b' c' d' e' f' g' h' i' j' k' l' m' n') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && j == j' && k == k' && l == l' && e1 m m' && e2 n n'
 
 -- | @since 0.1.3
 instance
diff --git a/src/Data/Tuple/Strict/T15.hs b/src/Data/Tuple/Strict/T15.hs
--- a/src/Data/Tuple/Strict/T15.hs
+++ b/src/Data/Tuple/Strict/T15.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T15 a b c d e f g h i j k l m n)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq1 (T15 a b c d e f g h i j k l m n) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq2 (T15 a b c d e f g h i j k l m) where
+  liftEq2 e1 e2 (T15 a b c d e f g h i j k l m n o) (T15 a' b' c' d' e' f' g' h' i' j' k' l' m' n' o') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && j == j' && k == k' && l == l' && m == m' && e1 n n' && e2 o o'
 
 -- | @since 0.1.3
 instance
diff --git a/src/Data/Tuple/Strict/T16.hs b/src/Data/Tuple/Strict/T16.hs
--- a/src/Data/Tuple/Strict/T16.hs
+++ b/src/Data/Tuple/Strict/T16.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T16 a b c d e f g h i j k l m n o)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq1 (T16 a b c d e f g h i j k l m n o) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq2 (T16 a b c d e f g h i j k l m n) where
+  liftEq2 e1 e2 (T16 a b c d e f g h i j k l m n o p) (T16 a' b' c' d' e' f' g' h' i' j' k' l' m' n' o' p') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && j == j' && k == k' && l == l' && m == m' && n == n' && e1 o o' && e2 p p'
 
 -- | @since 0.1.3
 instance
diff --git a/src/Data/Tuple/Strict/T17.hs b/src/Data/Tuple/Strict/T17.hs
--- a/src/Data/Tuple/Strict/T17.hs
+++ b/src/Data/Tuple/Strict/T17.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T17 a b c d e f g h i j k l m n o p)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o, Eq p) => Eq1 (T17 a b c d e f g h i j k l m n o p) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq2 (T17 a b c d e f g h i j k l m n o) where
+  liftEq2 e1 e2 (T17 a b c d e f g h i j k l m n o p q) (T17 a' b' c' d' e' f' g' h' i' j' k' l' m' n' o' p' q') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && j == j' && k == k' && l == l' && m == m' && n == n' && o == o' && e1 p p' && e2 q q'
 
 -- | @since 0.1.3
 instance
diff --git a/src/Data/Tuple/Strict/T18.hs b/src/Data/Tuple/Strict/T18.hs
--- a/src/Data/Tuple/Strict/T18.hs
+++ b/src/Data/Tuple/Strict/T18.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T18 a b c d e f g h i j k l m n o p q)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o, Eq p, Eq q) => Eq1 (T18 a b c d e f g h i j k l m n o p q) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o, Eq p) => Eq2 (T18 a b c d e f g h i j k l m n o p) where
+  liftEq2 e1 e2 (T18 a b c d e f g h i j k l m n o p q r) (T18 a' b' c' d' e' f' g' h' i' j' k' l' m' n' o' p' q' r') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && j == j' && k == k' && l == l' && m == m' && n == n' && o == o' && p == p' && e1 q q' && e2 r r'
 
 -- | @since 0.1.3
 instance
diff --git a/src/Data/Tuple/Strict/T19.hs b/src/Data/Tuple/Strict/T19.hs
--- a/src/Data/Tuple/Strict/T19.hs
+++ b/src/Data/Tuple/Strict/T19.hs
@@ -13,6 +13,7 @@
 where
 
 import Control.DeepSeq (NFData, rnf)
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T19 a b c d e f g h i j k l m n o p q r)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o, Eq p, Eq q, Eq r) => Eq1 (T19 a b c d e f g h i j k l m n o p q r) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o, Eq p, Eq q) => Eq2 (T19 a b c d e f g h i j k l m n o p q) where
+  liftEq2 e1 e2 (T19 a b c d e f g h i j k l m n o p q r s) (T19 a' b' c' d' e' f' g' h' i' j' k' l' m' n' o' p' q' r' s') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && h == h' && i == i' && j == j' && k == k' && l == l' && m == m' && n == n' && o == o' && p == p' && q == q' && e1 r r' && e2 s s'
 
 -- | @since 0.1.3
 instance
diff --git a/src/Data/Tuple/Strict/T2.hs b/src/Data/Tuple/Strict/T2.hs
--- a/src/Data/Tuple/Strict/T2.hs
+++ b/src/Data/Tuple/Strict/T2.hs
@@ -21,6 +21,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -45,6 +46,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T2 a)
+
+-- | @since 0.1.5
+instance Eq a => Eq1 (T2 a) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance Eq2 T2 where
+  liftEq2 e1 e2 (T2 a b) (T2 a' b') =
+    e1 a a' && e2 b b'
 
 -- | @since 0.1.3
 instance Monoid a => Applicative (T2 a) where
diff --git a/src/Data/Tuple/Strict/T3.hs b/src/Data/Tuple/Strict/T3.hs
--- a/src/Data/Tuple/Strict/T3.hs
+++ b/src/Data/Tuple/Strict/T3.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T3 a b)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b) => Eq1 (T3 a b) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance Eq a => Eq2 (T3 a) where
+  liftEq2 e1 e2 (T3 a b c ) (T3 a' b' c') =
+    a == a' && e1 b b' && e2 c c'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b) => Applicative (T3 a b) where
diff --git a/src/Data/Tuple/Strict/T4.hs b/src/Data/Tuple/Strict/T4.hs
--- a/src/Data/Tuple/Strict/T4.hs
+++ b/src/Data/Tuple/Strict/T4.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T4 a b c)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c) => Eq1 (T4 a b c) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b) => Eq2 (T4 a b) where
+  liftEq2 e1 e2 (T4 a b c d) (T4 a' b' c' d') =
+    a == a' && b == b' && e1 c c' && e2 d d'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b, Monoid c) => Applicative (T4 a b c) where
diff --git a/src/Data/Tuple/Strict/T5.hs b/src/Data/Tuple/Strict/T5.hs
--- a/src/Data/Tuple/Strict/T5.hs
+++ b/src/Data/Tuple/Strict/T5.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T5 a b c d)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d) => Eq1 (T5 a b c d) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c) => Eq2 (T5 a b c) where
+  liftEq2 e1 e2 (T5 a b c d e) (T5 a' b' c' d' e') =
+    a == a' && b == b' && c == c' && e1 d d' && e2 e e'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b, Monoid c, Monoid d) => Applicative (T5 a b c d) where
diff --git a/src/Data/Tuple/Strict/T6.hs b/src/Data/Tuple/Strict/T6.hs
--- a/src/Data/Tuple/Strict/T6.hs
+++ b/src/Data/Tuple/Strict/T6.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T6 a b c d e)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq1 (T6 a b c d e) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d) => Eq2 (T6 a b c d) where
+  liftEq2 e1 e2 (T6 a b c d e f) (T6 a' b' c' d' e' f') =
+    a == a' && b == b' && c == c' && d == d' && e1 e e' && e2 f f'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Applicative (T6 a b c d e) where
diff --git a/src/Data/Tuple/Strict/T7.hs b/src/Data/Tuple/Strict/T7.hs
--- a/src/Data/Tuple/Strict/T7.hs
+++ b/src/Data/Tuple/Strict/T7.hs
@@ -17,6 +17,7 @@
 import Data.Bifoldable
 import Data.Bitraversable
 import Data.Hashable (Hashable, hash, hashWithSalt)
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable.Lifted
   ( Hashable1,
     Hashable2,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T7 a b c d e f)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq1 (T7 a b c d e f) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq2 (T7 a b c d e) where
+  liftEq2 e1 e2 (T7 a b c d e f g) (T7 a' b' c' d' e' f' g') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && e1 f f' && e2 g g'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f) => Applicative (T7 a b c d e f) where
diff --git a/src/Data/Tuple/Strict/T8.hs b/src/Data/Tuple/Strict/T8.hs
--- a/src/Data/Tuple/Strict/T8.hs
+++ b/src/Data/Tuple/Strict/T8.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T8 a b c d e f g)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq1 (T8 a b c d e f g) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq2 (T8 a b c d e f) where
+  liftEq2 e1 e2 (T8 a b c d e f g h) (T8 a' b' c' d' e' f' g' h') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && e1 g g' && e2 h h'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g) => Applicative (T8 a b c d e f g) where
diff --git a/src/Data/Tuple/Strict/T9.hs b/src/Data/Tuple/Strict/T9.hs
--- a/src/Data/Tuple/Strict/T9.hs
+++ b/src/Data/Tuple/Strict/T9.hs
@@ -16,6 +16,7 @@
 import Data.Biapplicative
 import Data.Bifoldable
 import Data.Bitraversable
+import Data.Functor.Classes (Eq1 (liftEq), Eq2 (liftEq2))
 import Data.Hashable (Hashable, hash, hashWithSalt)
 import Data.Hashable.Lifted
   ( Hashable1,
@@ -40,6 +41,15 @@
 
 -- | @since 0.1.3
 deriving stock instance Traversable (T9 a b c d e f g h)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq1 (T9 a b c d e f g h) where
+  liftEq = liftEq2 (==)
+
+-- | @since 0.1.5
+instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq2 (T9 a b c d e f g) where
+  liftEq2 e1 e2 (T9 a b c d e f g h i) (T9 a' b' c' d' e' f' g' h' i') =
+    a == a' && b == b' && c == c' && d == d' && e == e' && f == f' && g == g' && e1 h h' && e2 i i'
 
 -- | @since 0.1.3
 instance (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g, Monoid h) => Applicative (T9 a b c d e f g h) where
diff --git a/strict-tuple.cabal b/strict-tuple.cabal
--- a/strict-tuple.cabal
+++ b/strict-tuple.cabal
@@ -1,7 +1,7 @@
 cabal-version: 2.2
 
 name: strict-tuple
-version: 0.1.4
+version: 0.1.5
 category: Data
 description: Strict tuples.
 synopsis: Strict tuples
@@ -9,10 +9,11 @@
 maintainer: Mitchell Rosen <mitchellwrosen@gmail.com>
 homepage: https://github.com/mitchellwrosen/strict-tuple
 bug-reports: https://github.com/mitchellwrosen/strict-tuple/issues
-copyright: (c) 2018-2020, Mitchell Rosen
+copyright: (c) 2018-2022, Mitchell Rosen
 license: BSD-3-Clause
 license-file: LICENSE
 build-type: Simple
+tested-with: GHC ==8.10.7, GHC ==9.0.2, GHC ==9.2.1
 
 extra-source-files:
   CHANGELOG.md
@@ -41,10 +42,10 @@
 library
   import: component
   build-depends:
-    base ^>= 4.11 || ^>= 4.12 || ^>= 4.13 || ^>= 4.14,
+    base ^>= 4.11 || ^>= 4.12 || ^>= 4.13 || ^>= 4.14 || ^>= 4.15 || ^>= 4.16,
     bifunctors ^>= 5.5,
     deepseq ^>= 1.4.3.0,
-    hashable ^>= 1.2.5.0 || ^>= 1.3
+    hashable ^>= 1.2.5.0 || ^>= 1.3 || ^>= 1.4
   exposed-modules: Data.Tuple.Strict
   hs-source-dirs: src
   other-modules: